การดำเนินการเชลล์บูลีน

$ ถ้าเป็นจริงก็แสดงว่าใช่ อย่างอื่นก็สะท้อนไม่ใช่

ตัวอย่าง: และการดำเนินการ

 $ ถ้าเป็นจริง && จริง; จากนั้นก้องใช่; fiYES$ ถ้าเป็นจริง && เท็จ; อย่างอื่นก็สะท้อนว่าไม่ใช่; ; จากนั้นก้อง YES; อย่างอื่นก็สะท้อน fiNO;

ตัวอย่าง: การดำเนินการ OR

 $ ถ้าเป็นจริง ||. จริง; แล้วก้องใช่; อีกอย่างก็สะท้อนใช่; เท็จ ||. เท็จ; จากนั้นก้องใช่;

ตัวอย่าง: NOT การดำเนินการ เช่น การปฏิเสธ

 $ ถ้า ! เท็จ; แล้วสะท้อนใช่;

ก็สามารถมองเห็นได้

 จริง

และ

 เท็จ

เราดำเนินการตามความเข้าใจของเราในการดำเนินการเชิงตรรกะ แต่เพื่อที่จะเข้าใจการนำการดำเนินการเชิงตรรกะของเชลล์ไปใช้ให้ดีขึ้น เราจะต้องคิดออก

 จริง

และ

 เท็จ

มันทำงานอย่างไร?

เป็นจริงและเท็จใน Bash 1 และ 0 ที่เรามักจะนึกถึงหรือไม่?

คำตอบคือ: ไม่

ตัวอย่าง: ค่าส่งคืนเทียบกับค่าตรรกะ

 จริง

และ

 เท็จ

ค่าเหล่านี้ไม่ใช่ค่าตรรกะ แต่เป็นคำสั่งในตัวของ Shell แต่ค่าที่ส่งคืนคือ "ค่าตรรกะ":

 $ true$ ก้อง $?0$ false$ ก้อง $?1

สามารถมองเห็นได้

 จริง

ส่งคืน 0 และ

 เท็จ

จากนั้น 1 จะถูกส่งกลับ มันไม่สอดคล้องกับค่าจริง 1 และ 0 ที่เราเรียนรู้ในคณิตศาสตร์แยก แต่เป็นสิ่งที่ตรงกันข้าม

ตัวอย่าง: ดูวิธีใช้และประเภทจริงและเท็จ

 $ ช่วย จริง falsetrue: true ส่งคืนผลลัพธ์ที่สำเร็จ false: false ส่งคืนผลลัพธ์ที่ไม่สำเร็จ $ ประเภท true falsetrue คือเชลล์บิวท์อินฟอลส์คือเชลล์ในตัว

แสดงให้เห็น:

 -

เป็นตัวแปรพิเศษที่เก็บสถานะสิ้นสุด (รหัสสถานะทางออก) ของกระบวนการสุดท้าย

จากการดำเนินการข้างต้น จึงไม่ยากที่จะคิดว่าเหตุใดจึงเน้นไปที่การเขียนโปรแกรมภาษา C

 หลัก

เพิ่มไว้หน้าฟังก์ชัน

 ภายใน

และเพิ่มในตอนท้าย

 กลับ 0

- เพราะในเชลล์ 0 จะถูกใช้เป็นสัญญาณว่าโปรแกรมสิ้นสุดสำเร็จหรือไม่ นี่คือสิ่งที่เชลล์

 จริง

และ

 เท็จ

โดยพื้นฐานแล้วใช้เพื่อสะท้อนให้เห็นว่าโปรแกรมบางโปรแกรมสิ้นสุดอย่างถูกต้องหรือไม่มากกว่าค่าจริงและค่าเท็จแบบดั้งเดิม (1 และ 0) ในทางกลับกันจะส่งคืนค่า 0 และ 1 โชคดีที่เราไม่จำเป็นต้องกังวลเกี่ยวกับสิ่งเหล่านี้เมื่อดำเนินการเชิงตรรกะ

การทดสอบสภาพ

จากหัวข้อที่แล้ว เราได้เข้าใจอย่างชัดเจนว่า "ค่าตรรกะ" ใต้ Shell คืออะไร มันคือค่าที่ส่งคืนเมื่อกระบวนการออก หากส่งคืนสำเร็จ แสดงว่าเป็นความจริง หากส่งคืนไม่สำเร็จ แสดงว่าเป็นเท็จ

และการทดสอบแบบมีเงื่อนไขก็ใช้

 ทดสอบ

คำสั่งดังกล่าวใช้เพื่อทำการทดสอบเชิงตัวเลข (การทดสอบคุณลักษณะเชิงตัวเลขต่างๆ) การทดสอบสตริง (การทดสอบคุณลักษณะสตริงต่างๆ) และการทดสอบไฟล์ (การทดสอบคุณลักษณะของไฟล์ต่างๆ) เราจะตัดสินว่าการทดสอบที่เกี่ยวข้องนั้นสำเร็จหรือไม่ ดังนั้นหลังจากเสร็จสิ้นงานประจำต่างๆ ควบคู่ไปกับการผสมผสานเชิงตรรกะของการทดสอบต่างๆ จึงสามารถทำงานที่ซับซ้อนมากขึ้นได้

การใช้การทดสอบแบบมีเงื่อนไขเบื้องต้น

ตัวอย่าง: การทดสอบเชิงตัวเลข

 $ ถ้าทดสอบ 5 -eq 5; จากนั้น echo YES; fiYES$ ถ้าทดสอบ 5 -ne 5; จากนั้น echo YES;

ตัวอย่าง: การทดสอบสตริง

 $ ถ้า test -n ไม่ว่าง; ก็ echo YES; ถ้า test -z ไม่ว่าง; ก็ echo NO; ถ้า test -n แล้ว echo YES;

ตัวอย่าง: การทดสอบไฟล์

 $ ถ้า test -f /boot/System.map; แล้ว echo YES; fiYES$ ถ้า test -d /boot/System.map;

การรวมกันของการทดสอบตรรกะต่างๆ

ตัวอย่าง: ถ้า a, b, c ทั้งหมดเท่ากับค่าที่สอดคล้องกันด้านล่าง ให้พิมพ์ YES และทดสอบด้วย -a

 $ a=5;b=4;c=6;$ ถ้าทดสอบ $a -eq 5 -a $b -eq 4 -a $c -eq 6; จากนั้นก้อง YES;

ตัวอย่าง: เพื่อทดสอบว่า "สิ่ง" บางอย่างเป็นไฟล์หรือไดเร็กทอรีหรือไม่ ให้ใช้ -o เพื่อดำเนินการ "OR"

 $ ถ้า test -f /etc/profile -o -d /etc/profile;แล้ว echo YES;

ตัวอย่าง: ทดสอบว่า "สิ่งของ" เป็นไฟล์หรือไม่ ทดสอบ

 -

ไม่ดำเนินการ

 $ ถ้า test ! -f /etc/profile;

ข้างต้นเป็นเพียงการสาธิตเท่านั้น

 ทดสอบ

สั่งการทดสอบง่ายๆ ที่คุณสามารถผ่านได้

 ช่วยทดสอบ

รับ

 ทดสอบ

การใช้งานเพิ่มเติมของ . ก็ควรสังเกตว่า

 ทดสอบ

มีความแตกต่างบางประการระหว่างการดำเนินการเชิงตรรกะภายในคำสั่งและตัวดำเนินการเชิงตรรกะของเชลล์ สิ่งที่เกี่ยวข้องคือ:

 -ก

และ

 -

-

 -o

และ

 -

ทั้งสองไม่อาจสับสนได้ แทนที่จะดำเนินการอยู่

 -

เปรียบเทียบด้านล่าง

เปรียบเทียบ -a กับ &&, -o กับ ||, ! ทดสอบกับ test !

ตัวอย่าง: หากต้องการให้ไฟล์สามารถเรียกใช้งานได้และมีเนื้อหา ให้ใช้ -a และ && เพื่อให้บรรลุสิ่งนี้ตามลำดับ

 $ cat > test.sh#!/bin/bashecho test[CTRL+D] # กดคีย์ผสม CTRL และ D เพื่อสิ้นสุดอินพุต cat เช่นเดียวกับด้านล่าง ไม่ต้องระบุ $ chmod +x test.sh$ อีกต่อไปหาก test -s test .sh -a -x test.sh; มิฉะนั้น echo NO;

ตัวอย่าง: กำหนดให้สตริงว่างเปล่าหรือเท่ากับสตริง

 $ str1=test$ str2=test$ if test -z $str2 -o $str2 == $str1; มิฉะนั้นก็สะท้อน NO; fiYES$ ถ้า test -z $str2 == $str1; จากนั้นก้องใช่; อย่างอื่นก้องไม่;

ตัวอย่าง: ทดสอบว่าตัวเลขไม่ตรงตามเงื่อนไขที่ระบุทั้งหมด

 $ i=5$ if test ! $i -lt 5 -a $i -eq 6; ; อย่างอื่นก้องไม่;

มันง่ายที่จะมองเห็นความแตกต่างระหว่างพวกเขา

 -ก

และ

 -o

เนื่องจากเป็นพารามิเตอร์ของคำสั่ง test จึงถูกใช้ภายในคำสั่ง test และ

 -

และ

 -

ใช้ในการคำนวณผลตอบแทนของการทดสอบ

 -

เหมือนกันทั้งสองอย่าง สิ่งที่ต้องให้ความสนใจคือ:

บางครั้งก็ไม่จำเป็น

 -

ผู้ดำเนินการ เช่น

 -eq

และ

 -ne

ตรงกันข้ามสามารถใช้เพื่อทดสอบว่าค่าทั้งสองมีค่าเท่ากันหรือไม่

 -z

และ

 -n

นอกจากนี้ยังสอดคล้องกันและใช้เพื่อทดสอบว่าสตริงบางสตริงว่างเปล่าหรือไม่

มีอยู่

 ทุบตี

ข้างใน,

 ทดสอบ

คำสั่งสามารถถูกแทนที่ด้วยตัวดำเนินการ [] แต่ควรสังเกตว่า [

 หลังจากนั้นด้วย

] ต้องมีช่องว่างเพิ่มเติมนำหน้า

เมื่อทดสอบสตริง ขอแนะนำให้ใส่ตัวแปรทั้งหมดไว้ในเครื่องหมายคำพูดคู่เพื่อป้องกันสถานการณ์ที่มีเพียงพารามิเตอร์ทดสอบและไม่มีเนื้อหาทดสอบเมื่อเนื้อหาตัวแปรว่างเปล่า

ด้านล่างนี้เราใช้ตัวอย่างเพื่อแสดงให้เห็นถึงข้อควรระวังสามประการข้างต้น:

 -ne

และ

 -eq

ในทำนองเดียวกัน บางครั้งเราก็สามารถละทิ้งได้

 -

การดำเนินการ

 $ i=5$ ถ้าทดสอบ $i -eq 5; มิฉะนั้นก็ echo NO; fiYES$ ถ้าทดสอบ $i -eq 5; จากนั้นก้องใช่; อย่างอื่นก้องไม่;

ใช้

 -

สามารถเปลี่ยนได้

 ทดสอบ

ก็จะดู “สวยงาม” มากขึ้น

 $ if [ $i -eq 5 ]; ดังนั้น echo NO; fiYES$ ถ้า [ $i -gt 4 ];

อย่าลืมเพิ่มตัวแปรสตริงบางตัว

,จดจำ

 -

หลังจากนั้นด้วย

 -

เพิ่มช่องว่างก่อน

 $ str=$ if [ $str = test]; ดังนั้น echo YES; bash: [: =: ตัวดำเนินการ unary ที่คาดหวัง NO$ ถ้า [ $str = test ]; จากนั้นก้อง YES;

ณ จุดนี้ มีการแนะนำ การทดสอบแบบมีเงื่อนไข แล้ว ที่จริงแล้ว เราได้ใช้มันไปแล้วข้างต้น นั่นคือการรวมกันของคำสั่งทดสอบหลายรายการ

 -

-

 -

และ

 -

ลำดับของคำสั่งที่รวมกัน ลำดับคำสั่งนี้จะเข้ามาแทนที่อย่างมีประสิทธิภาพ

 ถ้า/แล้ว

โครงสร้างสาขาแบบมีเงื่อนไข ไม่ใช่เรื่องยากที่จะนึกถึงคำถามแบบปรนัยต่อไปนี้ที่เรามักทำในการเขียนโปรแกรมภาษา C (ตัวอย่างที่น่าเบื่อมาก แต่มีความหมาย): Will the following prints หรือไม่?

 เจ

ถ้าพิมพ์จะพิมพ์อะไร?

 #include <stdio.h>int main(){ int i, j; i=5;j=1; if ((i==5) && (j=5)) printf(%dn, j); กลับ 0;}

ง่ายที่จะรู้ว่าเลข 5 จะพิมพ์เพราะว่า

 ฉัน==5

เงื่อนไขนี้คงอยู่และต่อมา

 -

เพื่อตัดสินว่ามีการกำหนดเงื่อนไขทั้งหมดหรือไม่ เราต้องทำการตัดสินใจครั้งต่อไป แต่การตัดสินนี้ไม่ใช่การตัดสินแบบธรรมดา แต่ก่อนอื่น

 เจ

แก้ไขเป็น 5 แล้วแปลงเป็นค่าจริง เพื่อให้เงื่อนไขเป็นจริงและพิมพ์ 5 ดังนั้น ประโยคนี้จึงตีความได้ว่า: ถ้า

 ฉัน

เท่ากับ 5 แล้วใส่

 เจ

กำหนดค่าเป็น 5 ถ้า

 เจ

มากกว่า 1 (เนื่องจากเคยเป็นจริงมาก่อนแล้ว) จากนั้นจึงพิมพ์ออกมา

 เจ

ค่า. ใช้วิธีนี้

 -

คำพิพากษาที่ต่อกันจะแทนที่สองคำ

 ถ้า

คำชี้แจงสาขาแบบมีเงื่อนไข

มันขึ้นอยู่กับคุณสมบัติเฉพาะของการดำเนินการเชิงตรรกะที่เราสามารถผ่านได้อย่างแม่นยำ

 -

-

 -

เพื่อแทนที่

 ถ้า/แล้ว

รอโครงสร้างสาขาแบบมีเงื่อนไข จึงสร้างรายการคำสั่ง

รายการคำสั่ง

กฎการดำเนินการรายการคำสั่ง

กฎการดำเนินการของรายการคำสั่งเป็นไปตามกฎการดำเนินการของการดำเนินการเชิงตรรกะ

 -

สำหรับคำสั่งที่เชื่อมต่อ หากคำสั่งเดิมส่งคืนสำเร็จ คำสั่งต่อไปนี้จะถูกดำเนินการ มิฉะนั้นให้ใช้

 -

หากคำสั่งที่เชื่อมต่อกลับมาสำเร็จ คำสั่งต่อมาจะไม่ถูกดำเนินการ และในทางกลับกัน

ตัวอย่าง: หาก ping www.lzu.edu.cn ให้พิมพ์ข้อมูลการเชื่อมต่อ

 $ ping -c 1 www.lzu.edu.cn -W 1 && echo =======เชื่อมต่อ========

คำถามที่น่าสนใจมากเกิดขึ้น ซึ่งเป็นสิ่งที่เราได้กล่าวไปแล้วข้างต้น: เหตุใดโปรแกรม C จึงควรเป็นเช่นนั้น

 หลัก()

ฟังก์ชันส่งคืน 0 ในตอนท้ายหรือไม่? ถ้าไม่เช่นนั้น การใส่โปรแกรมประเภทนี้เข้าไปในรายการคำสั่งจะส่งผลอย่างไร? เขียนโปรแกรม C ง่ายๆ ด้วยตัวเอง แล้วใส่ลงในรายการคำสั่งเพื่อดู

บทบาทของรายการคำสั่ง

บางครั้งมีการใช้รายการคำสั่งแทน

 ถ้า/แล้ว

โครงสร้างสาขาแบบมีเงื่อนไขสามารถบันทึกโค้ดบางส่วนและทำให้โปรแกรมสวยงามและอ่านง่ายยิ่งขึ้น เช่น:

ตัวอย่าง: กำหนดจำนวนพารามิเตอร์และประเภทพารามิเตอร์ของโปรแกรมในสคริปต์

 #!/bin/bashecho $#echo $1if [ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null); จากนั้นก้อง YESfi

หมายเหตุ: ตัวอย่างข้างต้นกำหนดให้จำนวนพารามิเตอร์เป็น 1 และประเภทเป็นตัวเลข

บวก

 ทางออก 1

เราจะละเว้น

 ถ้า/แล้ว

โครงสร้าง

 #!/bin/bashecho $#echo $1! ([ $# -eq 1 ] && (echo $1 | grep ^[0-9]*$ >/dev/null)) && ออกจาก 1echo ใช่

หลังจากการประมวลผลนี้ การตัดสินพารามิเตอร์ของโปรแกรมต้องใช้โค้ดเพียงบรรทัดเดียวเท่านั้น และจะมีความสวยงามมากขึ้น

สรุป

ส่วนนี้จะแนะนำการดำเนินการเชิงตรรกะ การทดสอบตามเงื่อนไข และรายการคำสั่งในการเขียนโปรแกรมเชลล์