9 ตัวอย่างลูปใน Linux Bash Scripts

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

The for Loop

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

ที่เกี่ยวข้อง 9 ตัวอย่างสคริปต์ทุบตีเพื่อให้คุณเริ่มต้นบน Linux

Bash for loop นั้นยืดหยุ่นมาก มันสามารถทำงานกับตัวเลข คำ อาร์เรย์ ตัวแปรบรรทัดคำสั่ง หรือผลลัพธ์ของคำสั่งอื่น ๆ สิ่งเหล่านี้ถูกใช้ใน ส่วนหัว ของลูป ส่วนหัวกำหนดสิ่งที่ลูปทำงานด้วย เช่น ตัวเลขหรือสตริง และเงื่อนไขสิ้นสุดที่จะหยุดการวนซ้ำคืออะไร

เนื้อหา ของลูปมีโค้ดที่คุณต้องการทำซ้ำ มันถือสิ่งที่คุณต้องการให้ลูป ทำ เนื้อหาลูปสามารถมีคำสั่งสคริปต์ที่ถูกต้องได้

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

ง่ายสำหรับลูป

หากคุณต้องการเขียนลูปเป็นครั้งแรก ตัวอย่างง่ายๆ เหล่านี้จะช่วยให้คุณเริ่มต้นได้

สำหรับลูปโดยใช้รายการตัวเลข

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

 สำหรับฉันใน 1 2 3 4 5; ทำ echo $i; เสร็จแล้ว 

สิ่งสำคัญที่ควรทราบในที่นี้คือตัวแปร i จะเพิ่มขึ้นหนึ่งครั้งในแต่ละครั้งที่วงรอบหมุน แต่นั่นเป็นเพราะรายการของตัวเลขเพิ่มขึ้นครั้งละหนึ่งรายการ

รายการตัวเลขนี้เริ่มต้นที่ 3 และเพิ่มขึ้นเป็นขั้นที่สอง จากนั้นจึงกระโดดไปที่ 44 โดยพลการ

 สำหรับฉันใน 3 5 7 9 11 44; ทำ echo $i; เสร็จแล้ว 

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

หรือตัวเลขไม่จำเป็นต้องเรียงจากน้อยไปมาก พวกเขาสามารถอยู่ในลำดับใดก็ได้

 สำหรับฉันใน 3 43 44 11 9; ทำ echo $i; เสร็จแล้ว 

สำหรับลูปโดยใช้รายการคำ

เราสามารถทำเช่นเดียวกันได้อย่างง่ายดายด้วยคำพูด คัดลอกข้อความของสคริปต์ลงในโปรแกรมแก้ไขและบันทึกเป็น "word-list.sh"

 #!/bin/bash

สำหรับคำใน นี่คือลำดับของคำ
ทำ 
  ก้อง $word
เสร็จแล้ว

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

 chmod +x word-list.sh 

มาเรียกใช้สคริปต์กันเถอะ

 ./word-list.sh 

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

สำหรับลูปที่มีช่วงจำนวน

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

สคริปต์นี้คือ “number-range.sh”

 #!/bin/bash

สำหรับฉันใน {1..10}
ทำ
  echo "วนรอบ:" $i
เสร็จแล้ว

ช่วงตัวเลขกำหนดไว้ในวงเล็บปีกกา “ {} ” โดยมีจุดสองจุด “ .. ” แยกตัวเลขที่เริ่มต้นและสิ้นสุดช่วง ตรวจสอบให้แน่ใจว่าคุณไม่ได้ใส่ช่องว่างใดๆ ในการกำหนดช่วง

นี่คือวิธีการทำงาน:

 ./number-range.sh 

คุณสามารถรวมตัวเลขอื่นที่กำหนดขนาดขั้นตอนที่ตัววนซ้ำควรใช้เพื่อดูตัวเลขในช่วง สคริปต์นี้ “number-range2.sh” จะใช้ช่วง 0 ถึง 32 และขนาดขั้นตอนที่ 4

 #!/bin/bash

สำหรับฉันใน {0.32..4}
ทำ
  echo "วนรอบ:" $i
เสร็จแล้ว

ตัววนซ้ำจะผ่านช่วงตัวเลขโดยกระโดดเป็นสี่ครั้ง

 ./number-range2.sh 

สำหรับลูปโดยใช้ชื่อไฟล์

เนื่องจากเราสามารถประมวลผลรายการคำ เราจึงสามารถให้สคริปต์ของเราทำงานกับชื่อไฟล์ได้ สคริปต์นี้เรียกว่า “filenames.sh”

 #!/bin/bash

สำหรับไฟล์ใน word-list.sh number-range.sh number-range2.sh filenames.sh
ทำ
  ls -lh "$ ไฟล์"
เสร็จแล้ว

มันคงไร้จุดหมายที่จะมีสคริปต์ที่ทำแค่สิ่งที่ ls ทำได้ แต่มันสาธิตวิธีเข้าถึงชื่อไฟล์ภายในเนื้อหาของลูป

 ./filenames.sh 

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

สคริปต์นี้เรียกว่า “filenames2.sh” เราได้แทนที่รายการชื่อไฟล์ด้วยรูปแบบชื่อไฟล์ “*.sh” เพื่อให้มีรายงานสคริปต์ของไฟล์สคริปต์ทั้งหมดในไดเร็กทอรีปัจจุบัน

 #!/bin/bash

สำหรับไฟล์ใน *.sh
ทำ
  ls -lh "$ ไฟล์"
เสร็จแล้ว

นี่คือผลลัพธ์

 ./filenames2.sh 

สำหรับลูปโดยใช้พารามิเตอร์บรรทัดคำสั่ง

เราสามารถเพิ่มความยืดหยุ่นได้โดยการส่งผ่านรูปแบบชื่อไฟล์บนบรรทัดคำสั่ง ตัวแปร $* แสดงถึงพารามิเตอร์บรรทัดคำสั่งทั้งหมดที่ส่งผ่านไปยังสคริปต์

นี่คือ "filenames3.sh"

 #!/bin/bash

สำหรับไฟล์ใน $*
ทำ
  ls -lh "$ ไฟล์"
เสร็จแล้ว

เราจะขอชื่อไฟล์ที่ขึ้นต้นด้วย “n” และมีนามสกุล SH

 ./filenames3.sh n*.sh 

นอกจากนี้เรายังสามารถส่งผ่านได้มากกว่าหนึ่งรูปแบบในแต่ละครั้ง

 ./filenames3.sh n*.sh .bashrc 

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

ที่เกี่ยวข้อง: วิธีทำงานกับตัวแปรใน Bash

C-like สำหรับลูป

Bash รองรับลูปสามคำแบบคลาสสิก เช่น ที่พบในภาษาการเขียนโปรแกรม C เรียกว่า ลูป 3 เทอม เนื่องจากมีสามคำในส่วนหัวของลูป

• ค่าเริ่มต้นของตัววนซ้ำลูป
• การทดสอบว่าลูปจะดำเนินต่อไปหรือสิ้นสุด
• การเพิ่มขึ้นหรือลดลงของตัววนซ้ำ

สคริปต์นี้คือ “c-like.sh”

ตัววนซ้ำ I ถูกตั้งค่าเป็น 1 ที่จุดเริ่มต้นของลูป และลูปจะทำงานตราบเท่าที่คำสั่ง ” i<=10 ” เป็นจริง ทันทีที่ i ถึง 11 ลูป for จะหยุด ตัววนซ้ำกำลังเพิ่มขึ้นหนึ่งรอบ ทุกรอบของลูป

 #!/bin/bash

สำหรับ (( i=1; i<=10; i++ ))
ทำ 
  echo "หมายเลขลูป:" $i
เสร็จแล้ว

มาเรียกใช้สคริปต์นี้กันเถอะ

 ./c-like.sh 

C-like for loop อนุญาตให้สร้าง for ลูปที่มีข้อกำหนดแปลก ๆ เล็กน้อยได้ง่าย วนรอบนี้เริ่มต้นที่ 15 และนับถอยหลังในขั้นตอนที่ 3 นี่คือ “c-like2.sh”

 #!/bin/bash

สำหรับ (( i=15; i>0; i-=3 ))
ทำ 
  echo "หมายเลขลูป:" $i
เสร็จแล้ว

เมื่อเราเรียกใช้ มันควรกระโดดถอยหลังในขั้นตอนที่สาม

 ./c-like2.sh 

ไม่มีที่สิ้นสุดสำหรับลูป

คุณยังสามารถใช้รูปแบบ for loop นี้เพื่อสร้างการวนซ้ำแบบอนันต์ สิ่งที่คุณต้องทำคือลบองค์ประกอบทั้งหมดออกจากส่วนหัวของลูปเช่นนี้ นี่คือ "infinite.sh"

 #!/bin/bash

สำหรับ (( ; ; ))
ทำ
  echo "กด Ctrl+C เพื่อหยุด..."
  นอน 1
เสร็จแล้ว

คุณจะต้องกด Ctrl+C เพื่อหยุดการวนซ้ำ

 ./infinite.sh 

สำหรับลูปโดยใช้ Word Arrays

เราสามารถทำซ้ำได้อย่างง่ายดายผ่านอาร์เรย์ของคำ เราจำเป็นต้องระบุชื่อของอาร์เรย์ในส่วนหัวของลูป และตัววนซ้ำจะตรวจสอบรายการทั้งหมดในอาร์เรย์ นี่คือ "word-array.sh"

 #!/bin/bash

การแจกแจง = ("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

สำหรับ distro ในการแจกจ่าย $
ทำ
  echo $ distro
เสร็จแล้ว

การแจกแจงทั้งหมดแสดงไว้สำหรับเรา

 ./word-array.sh 

คำสั่งต่อเนื่อง

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

นี่คือ "word-array2.sh" มันก้าวข้ามรายการอาร์เรย์ "Arch" แต่ประมวลผลสมาชิกอาร์เรย์อื่น ๆ ทั้งหมด

 #!/bin/bash

การแจกแจง = ("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

สำหรับ distro ในการแจกจ่าย $
ทำ
  ถ้า [[ "$distro" == "Arch" ]] ;
    แล้ว
    ดำเนินต่อ
  fi
  echo $ distro
เสร็จแล้ว

“Arch” ไม่ปรากฏในหน้าต่างเทอร์มินัล

 ./word-array2.sh 

คำสั่งแบ่ง

คำสั่ง break ออกจากลูปและป้องกันไม่ให้มีการประมวลผลอีกต่อไป

นี่คือ "word-array3.sh" มันเหมือนกับสคริปต์ก่อนหน้าโดยแทนที่ด้วย break continue

 #!/bin/bash

การแจกแจง = ("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

สำหรับ distro ในการแจกจ่าย $
ทำ
  ถ้า [[ "$distro" == "Arch" ]] ;
    แล้ว
    หยุดพัก
  fi
  echo $ distro
เสร็จแล้ว

เมื่อตัววนซ้ำมี "Arch" ลูป for จะละทิ้งการประมวลผลอีกต่อไป

 ./word-array3.sh 

สำหรับลูปโดยใช้ Associative Arrays

ใน Bash 4 ขึ้นไป แอสโซซิเอทีฟอาเรย์ช่วยให้คุณสร้างรายการคู่คีย์-ค่าที่สามารถค้นหาได้ด้วยคีย์หรือตามค่า เนื่องจากความสัมพันธ์แบบสองทางระหว่างคีย์และค่า จึงเรียกว่าพจนานุกรมข้อมูล

ที่เกี่ยวข้อง พจนานุกรม Bash บน Linux คืออะไร และคุณใช้งานอย่างไร

เราสามารถวนซ้ำผ่านอาเรย์ที่เชื่อมโยงโดยใช้ for loop สคริปต์นี้คือ “associative.sh” มันกำหนดอาเรย์ที่เชื่อมโยงที่มีสี่รายการในนั้น หนึ่งรายการสำหรับ "สุนัข", "แมว", "โรบิน" และ "มนุษย์" แต่ละตัว นี่คือกุญแจ ค่าคือจำนวนขา (ค่าเริ่มต้น) ที่แต่ละขามี

 #!/bin/bash

ประกาศ -A สัตว์ = ( [สุนัข] = สี่ขา [แมว] = สี่ขา [โรบิน] = สองขา [มนุษย์] = สองขา )

สำหรับขาใน ${!animals[@]}
ทำ
  ถ้า [ ${animals[$legs]} == "สองขา" ]; แล้ว 
    เสียงสะท้อน ${legs}
  fi
เสร็จแล้ว

ตัววนซ้ำเรียกว่า legs โปรดทราบว่าส่วนหัวของลูปประกอบด้วย “ ! ” เครื่องหมายอัศเจรีย์ สิ่งนี้ไม่ได้ทำหน้าที่เป็นตัวดำเนินการ NOT แบบลอจิคัล แต่เป็นส่วนหนึ่งของไวยากรณ์อาเรย์ที่เชื่อมโยง จำเป็นต้องค้นหาผ่านอาร์เรย์

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

 ./associative.sh 

วนซ้ำผลลัพธ์ของคำสั่ง

หากคุณมีคำสั่งหรือลำดับของคำสั่งที่สร้างรายการของบางอย่าง เช่น ชื่อไฟล์ คุณสามารถวนซ้ำได้โดยใช้ for loop คุณต้องระวังการขยายชื่อไฟล์ที่ไม่คาดคิด แต่ในกรณีธรรมดาๆ ก็ไม่เป็นไร

สคริปต์นี้คือ “command.sh” มันใช้ ls และ wc เพื่อจัดเตรียมรายการชื่อไฟล์สคริปต์ที่เรียงลำดับแล้ว พร้อมกับจำนวนบรรทัด คำ และจำนวนไบต์

 #!/bin/bash

สำหรับฉันใน $(ls *.sh | sort);
ทำ 
  เสียงสะท้อน $(wc $i)
เสร็จแล้ว

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

 ./command.sh 

The Dazzling for Loop

for loop เป็นเครื่องมือสร้างสคริปต์ที่หลากหลายและเข้าใจง่าย แต่ถึงแม้จะยืดหยุ่นได้ก็ตาม อย่าลืมว่ายังมีลูปอื่นๆ อยู่ด้วยเหตุผล อย่ามัวแต่คิดว่า for loop คือสิ่งที่คุณต้องการ

ที่เกี่ยวข้อง วิธีการประมวลผลไฟล์ทีละบรรทัดใน Linux Bash Script

ตัวอย่างเช่น while loop นั้นเหมาะสมกว่าสำหรับบางสิ่งมากกว่าลูป for เช่นการอ่านบรรทัดจากไฟล์

การเขียนสคริปต์ที่ดีหมายถึงการใช้เครื่องมือที่เหมาะสมที่สุดสำหรับงานในมือ for loop เป็นเครื่องมือที่ยอดเยี่ยมที่จะมีในกล่องเครื่องมือของลูกเล่น