ภาษาที่ป้อนเข้าสู่เชลล์จะต้องได้รับการตรวจสอบในระดับตัวอักษรก่อน^{[ b ]}

$ printf '<ขึ้นบรรทัดใหม่>: <%b>\n' $'\n' <ขึ้นบรรทัดใหม่>: < > $ printf '<แท็บ>: <%b>\n' $'\t' <แท็บ>: < > $ printf '<เว้นวรรค>: <%s>\n' " " <เว้นวรรค>: < > $ printf '<อักขระว่าง>: <%b>\n' $'\0' < อักขระว่าง>: <>

ชุดของอักขระใดๆ เรียกว่า "สตริง" หรือบางครั้งเรียกว่า " สตริงลิเทอรัล " ในระบบปฏิบัติการแบบยูนิกส์ อักขระทั้งหมด ทั้งที่พิมพ์ได้และพิมพ์ไม่ได้ ยกเว้นอักขระบางตัว เช่นอักขระว่างและเครื่องหมายทับ/สามารถใช้ในชื่อไฟล์ได้ นอกจากนี้ สตริงทั้งหมดจะคำนึงถึงตัวพิมพ์ ใหญ่และตัวพิมพ์เล็ก ^{[ c ]}

Bash เช่นเดียวกับภาษาโปรแกรมอื่นๆ อีกหลายภาษา ใช้ระบบการนับเลขแบบเริ่มต้นที่ศูนย์

ฟังก์ชันการกดปุ่ม Control+key นั้นมีให้ใช้งานในGNU Readlineและใช้งานได้เฉพาะในโหมดโต้ตอบเท่านั้น การกดปุ่มบางชุดจะช่วยให้ผู้ใช้สามารถใช้งาน Bash เพื่อใช้การเติมคำสั่งอัตโนมัติด้วยปุ่ม Tab และค้นหาประวัติคำสั่งได้

• Tab ↹– เปิดใช้งานการเติมแท็บอัตโนมัติ
• ↑– เลื่อนขึ้น (เช่น เลื่อนไปข้างหลัง) ในประวัติคำสั่ง
• ↓– เลื่อนลง (เช่น เลื่อนไปข้างหน้า) ในประวัติคำสั่ง
• Ctrl+r – ค้นหาประวัติคำสั่ง

การรวมปุ่มกดบางชุดยังช่วยให้ผู้ใช้สามารถใช้งานโปรแกรมจำลองเทอร์มินัลเพื่อย้ายเคอร์เซอร์ภายในหน้าต่างเทอร์มินัลและควบคุมโปรแกรมจำลองได้^{[ 10 ]} โดยค่าเริ่มต้น การรวมปุ่มกดเหล่านี้ใน Bash จะเหมือนกับของEmacs ^{[ d ]}

ปุ่มลัดเริ่มต้นสำหรับรหัสควบคุมมีดังนี้:

• Ctrl+f – เลื่อนเคอร์เซอร์ไปทางขวาหนึ่งตัวอักษร
• Ctrl+b – เลื่อนเคอร์เซอร์ไปทางซ้ายหนึ่งตัวอักษร
• Alt+f – เลื่อนเคอร์เซอร์ไปทางขวาหนึ่งคำ
• Alt+b – เลื่อนเคอร์เซอร์ไปทางซ้ายหนึ่งคำ
• Ctrl+a – ย้ายเคอร์เซอร์ไปที่จุดเริ่มต้นของบรรทัดคำสั่งปัจจุบัน
• Ctrl+c – ยกเลิกคำสั่งปัจจุบันและแสดงข้อความแจ้งเตือนใหม่
• Ctrl+d – ปิดอินสแตนซ์ Bash ปัจจุบัน ซึ่งอาจปิดโปรแกรมจำลองเทอร์มินัลด้วย
• Ctrl+e – เลื่อนเคอร์เซอร์ไปที่ท้ายบรรทัดคำสั่งปัจจุบัน
• Ctrl+q – ปลุกเครื่องเทอร์มินัล จากนั้นจึงประมวลผลการกดปุ่มที่บันทึกไว้
• Ctrl+s – ตั้งค่าเทอร์มินัลให้เข้าสู่โหมดพักเครื่อง
• Ctrl+w – ลบคำหนึ่งคำทางด้านซ้ายของเคอร์เซอร์
• Ctrl+z – หยุดกระบวนการที่ทำงานอยู่เบื้องหน้า

สามารถตั้งค่าปุ่มลัดสำหรับ Vi ได้โดยการเรียกใช้คำ สั่ง^{[ e ]}set-ovi

เมื่อ Bash อ่านบรรทัดคำสั่งทั้งหมดสตริงทั้งหมดจะถูกแบ่งออกเป็นโทเค็น "โทเค็น" จะถูกระบุโดยใช้ และคั่นออกจากกันโดยใช้เมตาแคแรคเตอร์

ใน Bash เวอร์ชัน 5.3 อักขระพิเศษ 10 ตัว ได้แก่ ช่องว่าง แท็บ และขึ้นบรรทัดใหม่ รวมถึงอักขระต่อไปนี้:|&;()<>

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

ในทางปฏิบัติ Bash จะแยกสตริงคำสั่งทั้งหมด ออก เป็นโทเค็นหรือกลุ่มของโทเค็นที่มีอักขระพิเศษ และโทเค็นหรือกลุ่มของโทเค็นที่ไม่มีอักขระพิเศษใดๆ ซึ่งเรียกว่า"คำ"จากนั้นก็จะแยกคำเหล่านั้นออกเป็นส่วนย่อยๆ ที่มีความหมายมากขึ้น เช่น ชื่อคำสั่ง คำสั่งกำหนดค่าตัวแปร เป็นต้น

ช่องว่างสองช่องนั้นคือช่องว่างธรรมดาและแท็บ

'!' '[[' '{' ']]' '}' case in esac for do done if then elif else fi ... 

$ #, , , ,, , ,, , $ if echo foo ; then bar = abc ; fi $ # ^^ ```` ``` ^^^^ ``````` ^^

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

ใน Bash ในบริบทที่ไม่เกี่ยวข้องกับการคำนวณทางคณิตศาสตร์ เราสามารถบังคับให้ใช้ซับเชลล์ได้โดยการใส่คำสั่งทั้งหมดไว้ในวงเล็บเดี่ยว

$ echo foo ; ( echo foo ) foo foo

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

• ไวยากรณ์ของซับเชลล์()เช่น จะใช้ในการเริ่มต้นซับเชลล์:

  $ ( program arga argb )

• ไวยากรณ์การส่งข้อมูลผ่านท่อ (piping syntax) A | Bจะเริ่มต้นใช้งานซับเชลล์หลายตัว โดยแต่ละตัวจะทำหน้าที่แทนคำสั่งแต่ละคำสั่งในไปป์ไลน์:

  $ program1 abc def | program2 -abc 

Bash มีตัวแปรและอาร์เรย์เป็นโครงสร้างข้อมูล และถึงแม้จะมีตัวแปรและอาร์เรย์หลายประเภทให้เลือกใช้ แต่โครงสร้างข้อมูลเหล่านี้ก็ค่อนข้างเรียบง่ายเมื่อเทียบกับภาษาอื่นๆ เช่นCหรือJavaข้อมูลทั้งหมดจะถูกจัดเก็บในหน่วยความจำในรูปแบบสตริง

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

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

"การเรียกใช้งาน" โปรแกรมเกิดขึ้นเมื่อผู้ใช้ (หรือโปรแกรมอื่น) ร้องขอให้ระบบปฏิบัติการดำเนินการตามคำสั่งที่อยู่ในโปรแกรมนั้น

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

$ foo = aa บาร์= bb quux =ซีซีzork = dd ; ตั้ง -o xtrace $ : " ${ foo } " ; : " ${ บาร์} " + : aa + : bb $ : " ${ quux } " \ > : " ${ zork } " + : cc : dd

คำแรกของบรรทัดคำสั่งเรียกว่า "ตำแหน่งคำสั่ง" ตามธรรมเนียมของ UNIX คำแรกของบรรทัดคำสั่งมักจะเป็นคำสั่งเสมอ และคำที่เหลือในสตริงบรรทัดคำสั่งจะเป็นตัวเลือกสำหรับคำสั่ง อาร์กิวเมนต์สำหรับตัวเลือก หรืออินพุตบางประเภทที่คำสั่งจะดำเนินการ "ตัวเลือก" ยังเรียกว่า "แฟล็ก" "สวิตช์" หรือเรียกอย่างเป็นทางการว่า "ตัวดำเนินการ" เมื่อ Bash พยายามค้นหาคำสั่งเพื่อดำเนินการ ไดเร็กทอรีที่มันค้นหาคือไดเร็กทอรีที่ระบุไว้ใน$PATHตัวแปรและไดเร็กทอรีการทำงานปัจจุบัน^{[ 12 ]}

$ # [ตำแหน่งคำสั่ง] [ตัวเลือก] [อาร์กิวเมนต์] $ # ,--^ ,------------^ ,----^ $ declare -p USER BASH_VERSION declare -x USER="liveuser" declare -- BASH_VERSION="5.2.37(1)-release"

สามารถสร้างบัญชีผู้ใช้ได้ทั้งสำหรับผู้ใช้ที่เป็นมนุษย์หรือผู้ใช้ที่เป็นโปรแกรม ในระบบปฏิบัติการแบบ Unix จะมีผู้ใช้สองประเภท ได้แก่ ผู้ใช้ "ระดับสูง" และผู้ใช้ "ทั่วไป" ผู้ใช้ระดับสูง เช่น root หรือเคอร์เนลของระบบปฏิบัติการ สามารถทำอะไรก็ได้บนเครื่องนั้น ส่วนผู้ใช้ทั่วไปจะมีข้อจำกัดหลายอย่าง

เมื่อเซสชันเชลล์แบบโต้ตอบรอรับข้อมูลจากผู้ใช้ โดยค่าเริ่มต้นจะพิมพ์สตริงอักขระเฉพาะลงบนหน้าจอ ใน Bash ค่าของสตริงที่รอรับข้อมูลนี้จะถูกเก็บไว้ในตัวแปร$PS1 เชลล์ สำหรับผู้ใช้ทั่วไป ค่าเริ่มต้นที่ใช้กันทั่วไป$PS1คือเครื่องหมายดอลลาร์ ( $ ) ^{[ j ]} สำหรับผู้ใช้ระดับสูงสุดค่าเริ่มต้นที่ใช้กันทั่วไปคือเครื่องหมายแฮช ( # )

$ sudo --login --user root [sudo] รหัสผ่านสำหรับ liveuser: # umask 077 # echo bob > /home/liveuser/names.txt # ออก$ grep -e bob ./names.txt grep: ./names.txt: การเข้าถึงถูกปฏิเสธ

แม้ว่าผู้ใช้ส่วนใหญ่จะคิดว่าเชลล์เป็นตัวแปลคำสั่งแบบโต้ตอบ แต่จริงๆ แล้วมันเป็นภาษาโปรแกรมที่แต่ละคำสั่งจะรันคำสั่ง เนื่องจากต้องตอบสนองทั้งด้านการโต้ตอบและด้านการเขียนโปรแกรมของการรันคำสั่ง จึงเป็นภาษาที่แปลกประหลาด ซึ่งได้รับอิทธิพลจากประวัติศาสตร์มากพอๆ กับการออกแบบ^{[ 13 ]}

Bash เขียนด้วยภาษา C รูปแบบโมดูลาร์สามารถประมาณได้ด้วยรูปแบบที่ดีและการออกแบบอย่างระมัดระวัง^{[ 14 ]} มักใช้ในรูปแบบคำสั่งหรือ แบบ ขั้นตอน

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

สคริปต์เชลล์เป็นไฟล์ข้อความที่ประกอบด้วยโค้ด ซึ่ง มักจะเป็นคำสั่ง ที่มีจุดประสงค์เพื่อให้ ตัวแปลภาษาเฉพาะอ่านและประมวลผลในกระบวนการแบบกลุ่มในโหมดที่ไม่ต้องมีการโต้ตอบจากผู้ใช้ และโดยไม่ต้องมีการแทรกแซงใดๆ เพิ่มเติม สคริปต์ที่ถูกแปลภาษาคือโปรแกรมที่ไม่จำเป็นต้องคอมไพล์ซอร์สโค้ด : ซอร์สโค้ดที่เกี่ยวข้องทั้งหมดอยู่ในสคริปต์แล้ว มีโปรแกรมมากมายที่สามารถทำหน้าที่เป็นตัวแปลภาษาสคริปต์ได้ เช่นPerl , AWKเป็นต้น สคริปต์ที่ถูกแปลภาษาส่วนใหญ่มักเขียนขึ้นสำหรับเชลล์ Unix

อักขระสองตัวแรกของบรรทัดแรกของสคริปต์เชลล์ (ที่สามารถเรียกใช้งานได้) ใดๆ จะเริ่มต้นด้วยสิ่งที่เรียกว่าชีแบง (shebang ) ซึ่งก็คืออักขระแฮช ( # ) และแบง ( ! ) เรียงติดกัน

$ cat ./example.sh # ! /bin/env bash echo foo

หากสคริปต์นั้นมีจุดประสงค์เพื่อให้ผู้ใช้เรียกใช้เป็นโปรแกรมแบบสแตนด์อะโลนบนบรรทัดคำสั่ง สคริปต์นั้นจะเรียกว่า"ไฟล์ปฏิบัติการ" (executable)ตามธรรมเนียมแล้ว ชื่อไฟล์ของ สคริปต์เชลล์ยูนิซ ที่เรียกใช้งานได้จะระบุด้วยคำต่อท้าย บิต.sh"เรียกใช้งานได้" สามารถเปิดใช้งานได้ในสคริปต์เชลล์โดยใช้ยูทิลิตี้chmod:

$ ls -l ./example.sh -rw-r--r--.1 liveuser liveuser 32 Aug 3 22:33 example.sh $ ./example.sh bash: ./example.sh: Permission denied $ chmod 0744 ./example.sh $ ls -l ./example.sh -rwxr--r--.1 liveuser liveuser 32 Aug 3 22:33 example.sh $ ./example.sh foo

ด้วย คำสั่ง source`read` หรือคำสั่งที่มีความหมายเหมือนกัน.Bash จะอ่านและเรียกใช้คำสั่งเชลล์จากไฟล์ข้อความใดๆ โดยใช้ชื่อไฟล์^{[ k ]}

Bash สามารถทำงานเป็นเชลล์ล็อกอินหรือ " ผู้นำเซสชัน " ได้ทั้งในโหมดโต้ตอบและไม่โต้ตอบผ่าน--loginตัวเลือก การ "ล็อกอิน" จำเป็นต้องมีการตรวจสอบสิทธิ์ ผู้ใช้ ด้วยเหตุนี้จึงมีเชลล์ล็อกอินเพียงหนึ่งเดียวต่อเซสชันของผู้ใช้ ใน GNU/Linux เชลล์ล็อกอินของผู้ใช้จะถูกระบุไว้ในไฟล์ /etc/passwd

$ awk -F ':' '$1 ~ /root/' /etc/passwd root:x:0:0:Super User:/root:/bin/bash

เมื่อผู้ใช้เริ่มเซสชันการเข้าสู่ระบบ ขั้นตอนนี้มักเกิดขึ้นในอินเทอร์เฟซผู้ใช้แบบกราฟิก (GUI) เมื่อผู้ใช้เปิดโปรแกรมจำลองเทอร์มินัลโปรแกรมจำลองจะเรียกใช้เชลล์การเข้าสู่ระบบของผู้ใช้ในโหมดที่ไม่ใช่การเข้า สู่ระบบจริง

การออกจากเซสชันเชลล์ภายในโปรแกรมจำลองเทอร์มินัลสามารถทำได้โดยใช้ คำสั่ง exitหรือโดยค่าเริ่มต้นใน Bash โดยการกดปุ่ม+ . Ctrld

เมื่อ Bash เริ่มทำงาน มันจะใช้ คำสั่งใน ไฟล์ dotfilesourceต่างๆ(ดูรายการด้านล่าง) ^{[ 15 ]} ไฟล์ dotfile เหล่านี้ ต่างจากสคริปต์เชลล์ โดยทั่วไปแล้วจะไม่มีสิทธิ์ในการเรียกใช้งานหรือhash-bangโดยค่าเริ่มต้น Bash จะเรียกใช้ชุดไฟล์ที่แตกต่างกันเล็กน้อย และในลำดับที่แตกต่างกัน ขึ้นอยู่กับ: ^{[ l ]}

• วิธีการเรียกใช้ Bash: แบบโต้ตอบ, แบบไม่โต้ตอบ, เรียกใช้โดยระบุชื่อsh
• มีการใช้ตัวเลือกใดบ้าง: --login, --rcfile, --norc,--posix
• ตัวแปรสภาพแวดล้อมใดบ้างที่ถูกกำหนดไว้: BASH_ENV, ENV, และ
• ไฟล์ใดบ้างที่มีอยู่:
  • /etc/profile
  • ~/.bash_profile
  • ~/.bash_login
  • ~/.profile
  • ~/.bash_logout, และ
  • ~/.bashrcและอื่นๆ อีกมากมาย

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

มาตรฐานPOSIX IEEE 1003.1 กำหนดชุดคำจำกัดความทั่วไปที่แอปพลิเคชันระบบ เชลล์ใดๆ (bash, dash , zsh ฯลฯ ) สามารถปฏิบัติตามได้สคริปต์ผู้ใช้./myscript.sh เชลล์ใดๆ ที่เขียนขึ้นตามแนวทางของ POSIX ควรจะสามารถเรียกใช้งานได้โดยแอปพลิเคชันระบบ เชลล์ใดๆ ที่ได้นำข้อกำหนดของ POSIX มาใช้ ดังนั้นจึงสามารถคาดหวังได้อย่างสมเหตุสมผลว่าสคริปต์ที่สอดคล้องกับ POSIX จะสามารถเรียกใช้งานได้สำเร็จบนระบบปฏิบัติการ Unix หรือระบบปฏิบัติการที่คล้าย Unix ใดๆ ที่ใช้มาตรฐาน POSIX ( Linux , OpenBSD , Oracle Linux , HP-UXฯลฯ) สคริปต์เหล่านี้ถือว่า " พกพาได้ " โดยไม่ต้องแก้ไขเพิ่มเติมใดๆ ส่วนของ POSIX ที่ใช้กับเชลล์และยูทิลิตี้บรรทัดคำสั่งเป็นส่วนย่อยของกลุ่มมาตรฐาน POSIX ที่ใหญ่กว่า ซึ่งระบุเพิ่มเติมว่าเทอร์มินัลและโปรแกรมจำลองเทอร์มินัลควรทำงานอย่างไรเพื่อให้ถือว่าพกพาได้เช่นกัน

เมื่อ Bash ทำงานในโหมด POSIX ฟีเจอร์ต่างๆ จะมีให้ใช้งานน้อยลง แต่โค้ดที่ได้จะสามารถทำงานได้บนระบบปฏิบัติการที่หลากหลายมากขึ้น

ในการเปิดใช้งานโหมด POSIX เมื่อเริ่มต้นเชลล์แบบโต้ตอบ สามารถเรียกใช้ Bash ได้โดยใช้คำสั่ง `posix` shหรือbash --posix` bash -o posixposix` ^{[ m ]}

ในการเริ่มต้นสคริปต์ในโหมด POSIX จะต้องใช้ hashbang #!/usr/bin/env shหรือวิธีที่ไม่ค่อยเหมาะกับการใช้งานหลายแพลตฟอร์ม#!/bin/shเมื่ออินสแตนซ์ของ Bash ทำงานในโหมด POSIX ตัวแปรสภาพแวดล้อม$POSIXLY_CORRECTจะถูกกำหนด และค่าของตัวแปรสภาพแวดล้อมSHELLOPTSจะรวมสตริงposix ไว้ ด้วย

$ declare -p POSIXLY_CORRECT SHLVL bash: declare: POSIXLY_CORRECT: ไม่พบdeclare -x SHLVL="1" $ bash -o posix $ declare -p POSIXLY_CORRECT SHLVL declare -- POSIXLY_CORRECT="y" declare -x SHLVL="2"

รายการคุณสมบัติทั้งหมดที่มีอยู่ใน Bash ซึ่งไม่ได้ระบุไว้ใน POSIX นั้นมีจำนวนมาก^{[ 17 ]} นี่คือรายการบางส่วน:

• อาร์เรย์ใดๆ นอกเหนือจากอาร์เรย์ของพารามิเตอร์ตำแหน่ง$@ไม่เป็นไปตามมาตรฐาน POSIX
• โครงสร้างการทดสอบแบบขยายวงเล็บคู่[[...]]ไม่ใช่มาตรฐาน POSIX
  • [...]และtestเป็นไปตามมาตรฐาน POSIX
• หนึ่งในไวยากรณ์การประเมินค่าทางคณิตศาสตร์ด้วยวงเล็บคู่((...))ไม่ใช่มาตรฐาน POSIX
  • $((...))คือ POSIX
• การขยายวงเล็บkernel{,-headers}ไม่เป็นไปตามมาตรฐาน POSIX
• การกำหนดขอบเขตพารามิเตอร์แบบไดนามิกและlocalฟังก์ชันในตัวไม่เป็นไปตามมาตรฐาน POSIX
• การแทนที่กระบวนการ<(...)ไม่เป็นไปตามมาตรฐาน POSIX
• การดำเนินการจัดการสตริงบางอย่างในการขยายพารามิเตอร์ไม่เป็นไปตามมาตรฐาน POSIX
• คำสั่งพื้นฐานส่วนใหญ่ของ Bash ไม่เป็นไปตามมาตรฐาน POSIX
  • คำสั่งนี้จะแสดงรายการฟังก์ชันในตัวพิเศษของ Bourne ซึ่งเป็นมาตรฐาน POSIXenable-s

    $ enable -s | wc --lines 16 $ enable | wc --lines 61

  • ตัวระบบภายในเอง นั้นenableไม่รองรับมาตรฐาน POSIX
  • ใน Bash ในโหมดที่ไม่ใช่ POSIX คำสั่ง `and` .และ ` sourcebuiltins` มีความหมายเหมือนกัน
    • .ฟังก์ชันในตัว (เช่น 'จุด') นั้นใช้มาตรฐาน POSIX อย่างไรก็ตาม
    • ฟังก์ชันsourceในตัวไม่รองรับมาตรฐาน POSIX
• ตัวแปรเชลล์$EPOCHSECONDSและ ตัวแปรอื่นๆ ไม่เป็นไปตามมาตรฐาน POSIX$EPOCHREALTIME

คำสั่งระบบที่มีอยู่ในระบบปฏิบัติการแบบ Unix สมัยใหม่ และที่กำหนดไว้ในมาตรฐาน POSIX อาจมีตัวเลือกหรือตัวแปรสภาพแวดล้อมที่เกี่ยวข้องน้อยกว่าภายใต้มาตรฐาน POSIX ส่วนใหญ่ (เช่นls) เป็นโปรแกรมแบบสแตนด์อโลนใน ไดเร็กทอรี /bin, /usr/bin, /sbinหรือ/usr/sbin(ใน Linux มักจัดหาโดยGNU coreutilsหรือBusyBox ) มากกว่าจะเป็นคำสั่งในตัวของ Bash

เนื่องจากความแตกต่างเหล่านี้และอื่นๆ สคริปต์ Bash shell รุ่นใหม่ (เวอร์ชัน 5) จึงไม่ค่อยสามารถรันได้ "โดยตรง" ภายใต้ตัวแปลคำสั่ง Bourne หรือ Korn shell รุ่นเก่า การเขียนสคริปต์โดยคำนึงถึงความสามารถในการพกพาได้นั้นกำลังลดน้อยลงเรื่อยๆ เมื่อ GNU/Linux แพร่หลายมากขึ้น

โค้ดที่มีไวยากรณ์ถูกต้องใน Bash แต่ไม่ได้ระบุไว้ใน POSIX เรียกว่า "bashism" โปรแกรมนี้checkbashismsสามารถใช้เพื่อให้แน่ใจว่าสคริปต์สามารถทำงานบนDebian Linux ได้ โดยไม่มีข้อผิดพลาดด้านความเข้ากันได้^{[ 18 ]} Vidar Holen shellcheckเป็นlinter แบบคงที่อีกตัวหนึ่ง ที่เขียนด้วยHaskellซึ่งสามารถวิเคราะห์ไวยากรณ์ของสคริปต์เพื่อความเข้ากันได้กับ bash, dash, ksh และ Bourne sh ทั้งหมดหรือบางส่วน^{[ 19 ]}

ข้อกำหนดด้านไวยากรณ์สำหรับแต่ละเชลล์นั้นแตกต่างกันเล็กน้อย ตัวอย่างเช่น นโยบายของ Debian อนุญาตให้ใช้ส่วนขยายบางอย่างในสคริปต์ (เช่นเดียวกับใน เชลล์ dash ) ^{[ 20 ]}ในขณะที่สคริปต์ที่ตั้งใจจะรองรับเชลล์ Bourne ก่อน POSIX เช่นconfigureของautoconfนั้นมีข้อจำกัดมากกว่าในคุณสมบัติที่สามารถใช้งานได้^{[ 21 ]}

เมื่อ เปิดใช้งาน xtraceเนื้อหาการดีบักแบบง่ายจะถูกพิมพ์ไปยังเทอร์มินัล สามารถเปิดใช้งานได้ด้วยหรือและปิดใช้งานได้ด้วยหรือตัวเลือกเหล่านี้ยังสามารถใช้ได้ที่บรรทัดคำสั่งและที่ hash-bangs ด้วยเช่น , เป็นต้นset -o xtraceset -xset +o xtraceset +xset -#!/bin/bash -x

$ bash -x $ echo $(( 2 + 2 )) + echo 4 4 $ set -- 1 2 3 + set -- 1 2 3 $ printf '<%s>\n' " $@ " + printf '<%s>\n' 1 2 3 <1> <2> <3>

การ ตั้งค่าเชลล์ xtraceถูกกำหนดโดยมาตรฐาน POSIX ดูเพิ่มเติมที่หัวข้อ§ การดีบัก 

ตัวเลือก verbose จะพิมพ์สตริงไปยังเทอร์มินัลขณะที่อ่าน และก่อนที่จะทำการขยายใดๆ ไม่ค่อยได้ใช้^{[ r ]}

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

ข้อความแสดงความคิดเห็นมาตรฐานใน Bash จะใช้เครื่องหมายแฮช ( # ) แทน ข้อความใดๆ ที่อยู่ทางขวาของเครื่องหมายแฮชไปจนถึงท้ายบรรทัดจะถูกละเว้น อนุญาตให้ใช้ข้อความแสดงความ คิดเห็นแบบแทรกในบรรทัดได้ แต่ข้อความแสดงความคิดเห็นแบบแฮชจะไม่แสดงผลระหว่างการดีบัก ดูเพิ่มเติมที่: §  xtrace

ข้อความแสดงความคิดเห็นที่คั่นด้วยเครื่องหมายโคลอน:นั้นมีต้นกำเนิดมาจากเชลล์ Thompsonอาร์กิวเมนต์ใดๆ ที่อยู่ทางขวาของเครื่องหมายโคลอน:จะถูกละเว้น ไม่สามารถแสดงข้อความแสดงความคิดเห็นแบบแทรกในบรรทัดได้ แต่ข้อความแสดงความคิดเห็นที่คั่นด้วยเครื่องหมายโคลอนจะแสดงผลระหว่างการดีบัก และพารามิเตอร์ต่างๆ จะถูกขยายความ^{[ s ]}

$ # กำหนดค่า foo $ foo = bar # คอมเมนต์แบบแฮชแทรกในบรรทัดเดียวกับคำสั่ง$ set -x $ # คอมเมนต์ปกติ (ไม่มีเอาต์พุต) $ : " ${ foo } " + : bar

เมื่อ bash ประมวลผลคำสั่ง จะมีการสร้างรหัส สถานะการออกหรือที่เรียกว่า "รหัสส่งคืน" ซึ่งสามารถให้ข้อมูลเชิงลึกเกี่ยวกับวิธีที่โปรแกรมหยุดทำงานได้ ค่าของรหัสการออกที่บันทึกไว้ล่าสุดจะถูกเก็บไว้ในพารามิเตอร์ของเชลล์ 'เครื่องหมายคำถาม:' $?ในบริบทที่ไม่เกี่ยวข้องกับการคำนวณทางคณิตศาสตร์ (เช่น ในกรณีส่วนใหญ่) ค่าตัวเลขหรือ " บูลีน " ของ "จริง" คือศูนย์ (0) และค่าของ "เท็จ" คือหนึ่ง (1)

เมื่อคำสั่งระบบทำงานเสร็จสิ้น ความหมายที่แท้จริงของสถานะการออกจากระบบมักจะพบได้ในหน้าคู่มือ (man page) โดยปกติแล้วเลขศูนย์หมายถึงความสำเร็จ และสถานะการออกจากระบบที่ไม่ใช่ศูนย์หมายถึงความล้มเหลวหรือความสำเร็จบางส่วน pingเป็นคำสั่งที่รู้จักกันดีซึ่งมีรหัสการออกจากระบบที่มีความหมายสามแบบ ได้แก่ 0, 1 และ 2

ใน Bash ภายในบริบททางคณิตศาสตร์ ค่าความจริงของตัวเลขจะกลับกัน: "จริง" คือหนึ่ง และ "เท็จ" คือศูนย์ บริบททางคณิตศาสตร์มักจะระบุได้จากไวยากรณ์ `true` ((...))หรือ ` $((...))false` หากคำสั่งทางคณิตศาสตร์ประเมินค่าได้เป็นจำนวนเต็มศูนย์ คำสั่งนั้นจะถือว่าเป็น "จริง" และรหัสการออกจะเป็นหนึ่ง หากคำสั่งนั้นประเมินค่าได้เป็นตัวเลขอื่นที่ไม่ใช่ศูนย์ คำสั่งทางคณิตศาสตร์นั้นจะถือว่าเป็น "เท็จ" และรหัสการออกจะเป็นศูนย์

คำสั่งในระบบ Linux/UNIX บางคำสั่งไม่ได้ให้รหัสการออกที่มีความหมายนอกเหนือจากศูนย์และหนึ่ง และไม่มีระบบมาตรฐานสำหรับการกำหนดรหัสการออกในระบบ Linux

$ true ; echo $? # รหัสออกหมายถึง "true" 0 $ false ; echo $? ; echo # รหัสออกหมายถึง "false" 1 $ $ bash -c 'exit 99' ; printf 'exit-code: %d\n' $? exit-code: 99 $ (( 1 - 1 )) ; printf '%d\n' $? # รหัสออกนี้หมายถึง "true" 1 $ (( 1 + 1 )) ; printf '%d\n' $? # ...และรหัสออกนี้หมายถึง "false" 0

เชลล์ Bash มีโหมดการเรียกใช้คำสั่งสองโหมด ได้แก่ แบบกลุ่ม (แบบอะซิงโครนัส) และแบบพร้อมกัน (แบบซิงโครนัส) ในการเรียกใช้คำสั่งในโหมดกลุ่ม (เช่น ตามลำดับ) คำสั่งเหล่านั้นจะต้องคั่นด้วยเครื่องหมาย;หรือเขียนไว้ในบรรทัดที่แยกกัน:

$ command1 ; command2 $ command3 

ในตัวอย่างนี้ เมื่อคำสั่ง command1เสร็จสิ้นคำสั่ง command2 จะถูกดำเนิน การ และเมื่อคำสั่ง command2เสร็จสิ้น คำ สั่ง command3จะ ถูกดำเนินการ การเรียกใช้ คำสั่ง command1 ในพื้นหลังสามารถทำได้โดยใช้สัญลักษณ์&ที่ท้ายคำสั่งการเรียกใช้ และกระบวนการจะถูกดำเนินการในพื้นหลังพร้อมกับส่งการควบคุมกลับไปยังเชลล์ทันทีและอนุญาตให้ดำเนินการคำสั่งต่อไปได้

$ command1 &

หรือหากต้องการเรียกใช้คำสั่งcommand1และcommand2 พร้อมกัน จะต้องเรียกใช้คำสั่งเหล่านั้นใน Bash shell ด้วยวิธีดังต่อไปนี้:

$ command1 & command2 

ในกรณีนี้command1จะถูกเรียกใช้ในพื้นหลังและสัญลักษณ์ & จะส่งการควบคุมกลับไปยังเชลล์ทันที ซึ่งจะเรียกใช้command2ในพื้นหน้า สามารถหยุดกระบวนการและส่งการควบคุมกลับไปยัง bash ได้โดยการพิมพ์+ในขณะที่กระบวนการกำลังทำงานอยู่ในพื้นหน้า^{[ t ]} สามารถดูรายการกระบวนการทั้งหมด ทั้งที่อยู่ในพื้นหลังและที่หยุดแล้วได้โดยการเรียกใช้jobs :Ctrlz

$ งาน[1]- กำลังเรียกใช้คำสั่ง 1 &

ในผลลัพธ์ ตัวเลขในวงเล็บหมายถึงรหัสงาน เครื่องหมายบวกหมายถึงกระบวนการเริ่มต้นสำหรับbgและfgข้อความ "กำลังทำงาน" และ "หยุดแล้ว" หมายถึงสถานะของกระบวนการและสตริงสุดท้ายคือคำสั่งที่เริ่มต้นกระบวนการ

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

$ sleep 100 & [1] 4904 $ kill %1 $ jobs [1]+ Terminated sleep 100

การควบคุมงาน หรือที่เรียกว่า "โหมดตรวจสอบ" จะเปิดใช้งานโดยค่าเริ่มต้นในเชลล์แบบโต้ตอบ และสามารถปิดใช้งานได้ด้วยคำสั่ง ` .`set+m

การส่งสัญญาณเป็นวิธีการสื่อสารระหว่างกระบวนการ (IPC) บางครั้งกระบวนการบรรทัดคำสั่งอาจดูเหมือนหยุดทำงานกลางคัน ในกรณีเช่นนี้ อาจจำเป็นต้องระบุว่ากระบวนการใดถูกบล็อกและยุติกระบวนการที่ก่อปัญหาด้วยตนเอง

ในเทอร์มินัลแบบโต้ตอบ โดยปกติแล้ว การกดปุ่ม+เพื่อยุติกระบวนการที่ทำงานอยู่เบื้องหน้าและส่งการควบคุมกลับไปยังพร้อมท์ผู้ใช้ หรือการกดปุ่ม+เพื่อระงับกระบวนการนั้น ก็เพียงพอแล้ว ในบางครั้ง การพยายามระงับกระบวนการอาจสำเร็จเมื่อการพยายามยกเลิกกระบวนการดูเหมือนจะไม่ตอบสนอง ในกรณีอื่นๆ อาจจำเป็นต้องใช้ โปรแกรม killเพื่อส่งสัญญาณ IPC ในตัวอย่างนี้ เราใช้ คำสั่ง killจากหน้าจอเทอร์มินัลที่สองเพื่อยุติกระบวนการที่มี PID 4331 Ctrlc Ctrlz

$ tty # เทอร์มินัลหนึ่ง/dev/pts/0 $ whoami liveuser $ sleep 1000 # คำสั่งค้าง

$ tty # เทอร์มินัลสอง/dev/pts/1 $ whoami liveuser $ ps aux | grep -e sleep -e PID USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND liveuser 4331 0.0 0.0 230336 2312 pts/1 S+ 11:19 0:00 sleep 1000 liveuser 4333 0.0 0.0 231248 2516 pts/0 S+ 11:19 0:00 grep --color=auto -e sleep -e PID $ kill 4331 $ ps aux | grep -e sleep -e PID # กระบวนการ sleep สิ้นสุดลงแล้วUSER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND liveuser 4333 0.0 0.0 231248 2516 pts/0 S+ 11:19 0:00 grep --color=auto -e sleep -e PID

$ tty # เทอร์มินัลอีกครั้ง/dev/pts/0 $ whoami liveuser $ sleep 1000 Terminated

ในระบบปฏิบัติการที่คล้าย Unix ผู้ใช้สามารถสั่งการเคอร์เนลให้ส่งสัญญาณไปยังกระบวนการที่เป็นของผู้ใช้นั้นได้ ผู้ใช้ทั่วไปไม่สามารถส่งสัญญาณไปยังกระบวนการที่มีสิทธิ์พิเศษได้ สามารถส่งสัญญาณไปยังกระบวนการได้โดยใช้ คำสั่ง killหรือใช้ไบนารีของระบบที่มีชื่อเดียวกัน

$ whoami liveuser $ ps aux | awk '$2 == "1"' # มาดูข้อมูลบางอย่างเกี่ยวกับกระบวนการเคอร์เนล กระบวนการ 1 root 1 0.0 0.2 37140 20440 ? Ss 04:44 0:18 /usr/lib/systemd/systemd --switched-root --system --deserialize=53 rhgb $ kill -s SIGKILL 1 bash: kill: (1) - การดำเนินการไม่ได้รับอนุญาต$ type -a kill kill เป็นคำสั่งภายในของเชลล์kill คือ /usr/bin/kill $ /usr/bin/kill -s SIGKILL 1 kill: การส่งสัญญาณไปยัง 1 ล้มเหลว: การดำเนินการไม่ได้รับอนุญาต

สัญญาณที่ใช้บ่อยที่สุดสามารถดูได้ด้วยkill -L | head -n 4แต่ละสัญญาณ IPC จะเชื่อมโยงกับหมายเลขสัญญาณ แต่รหัสออกและรหัสสัญญาณนั้นแตกต่างกัน แม้ว่าการส่งสัญญาณ IPC หมายเลข 9 (สัญญาณ "ฆ่า") ไปยังกระบวนการหนึ่งจะทำให้กระบวนการนั้นยุติลงทันที แต่ก็มีโอกาสสูงที่กระบวนการนั้นจะไม่ส่งรหัสออก 9 กลับมา

โดยค่าเริ่มต้นใน Bash คำสั่ง kill ในตัวจะส่งสัญญาณ TERM ("terminate") เป็นเรื่องปกติที่ยูทิลิตี้บรรทัดคำสั่งจะตอบสนองต่อSIGTERMโดยการปิดระบบและออกจากโปรแกรมอย่างสะอาด (TERM และSIGTERMเหมือนกัน คำนำหน้า SIG- ในชื่อสัญญาณทั้งหมดสามารถละเว้นได้) ลำดับ + ใน Bash ส่ง สัญญาณ SIGINTซึ่งเป็นสัญญาณขัดจังหวะไปยังกระบวนการเบื้องหน้า ลำดับ+ส่ง สัญญาณ SIGSTOPซึ่งเป็นสัญญาณหยุด^{[ u ]} เมื่อกระบวนการได้รับSIGKILLกระบวนการจะยุติลงทันทีและไม่เป็นระเบียบ ขอแนะนำให้ใช้SIGKILLเป็นทางเลือกสุดท้ายเท่านั้น^{[ 23 ]} สัญญาณSIGKILLไม่สามารถถูกบล็อกหรือจัดการได้CtrlcCtrlz

กระบวนการต่างๆ สามารถ "ดักจับ" และ "จัดการ" สัญญาณ IPC ที่ได้รับ ผู้ใช้สามารถใช้คำสั่ง kill ในตัวเพื่อ "ส่ง" สัญญาณ IPC ไปยังกระบวนการอื่น กระบวนการเป้าหมายนั้นสามารถตั้งค่ากลไกหรือวางแผนล่วงหน้าไว้ว่าจะตอบสนองอย่างไรเมื่อได้รับหรือ "ดักจับ" สัญญาณใดๆ ก็ตาม วิธีที่โปรแกรมเป้าหมายตอบสนองนั้นเรียกว่าวิธีที่โปรแกรม "จัดการ" การรับสัญญาณ ในหน้าคู่มือจะเห็นได้ว่าคำสั่งระบบบางคำสั่งจะพิมพ์ข้อมูลบางอย่างไปยังเทอร์มินัลเมื่อได้รับSIGHUPเช่นคำสั่งdd ^{[ 24 ]}

เมื่อ bash เป็นแบบโต้ตอบ ในกรณีที่ไม่มีกับดักใดๆ bash จะไม่สนใจSIGTERM (เพื่อไม่ให้เชลล์แบบโต้ตอบหยุดทำงาน) และจะดักจับและจัดการSIGINT (เพื่อให้ สามารถขัดจังหวะคำสั่ง waitได้) เมื่อ bash ได้รับSIGINT มัน ^จะออกจากลูปการทำงานใดๆ ในทุกกรณี bash จะไม่สนใจSIGQUITหากมีการควบคุมงาน bash จะไม่สนใจSIGTTIN , SIGTTOUและSIGTSTP [ ^{25 ]}kill0

โดยค่าเริ่มต้น สคริปต์เชลล์ Bash จะรับและตอบสนองต่อสัญญาณ IPC ทั้งหมดที่ส่งไปยังสคริปต์เหล่านั้น อย่างไรก็ตาม สคริปต์ Bash สามารถใช้ฟังก์ชันtrapในตัวเพื่อดักจับและจัดการสัญญาณได้^{[ 26 ]}

$ cat ./trap-example.sh # ! /usr/bin/env bash trap umask EXIT echo bar exit 0 $ chmod 0700 trap-example.sh $ ./trap-example.sh bar 0077

มีสัญญาณบางอย่างที่ใช้งานได้เฉพาะภายใน Bash เท่านั้น ซึ่งเป็นส่วนขยายของ GNU ได้แก่ERR , EXIT , RETURNและDEBUGสัญญาณเหล่านี้มีประโยชน์ในการดีบัก และสามารถส่งและจัดการได้โดยฟังก์ชันภายในของเชลล์เท่านั้น ดูเพิ่มเติมที่§ การดีบัก 

มีการใช้งานคำสั่งecho หลายรูปแบบ บางรูปแบบมีตัวเลือก และบางรูปแบบไม่มี^{[ v ]} รายการตัวเลือกไม่สม่ำเสมอในแต่ละรูปแบบการใช้งาน แม้ว่าทั้ง echoและprintf จะ ถูกกำหนดโดย POSIX ก็ตาม หากผู้เขียนสคริปต์ต้องการทราบค่าที่แน่นอนของสตริงที่อยู่ในตัวแปร วิธีที่สอดคล้องกันมากที่สุดคือการใช้printf-e

สำหรับสตริงใดๆ ที่มีอักขระใดๆ (ยกเว้นค่าว่าง?) รวมถึงตัวเลข ตัวระบุรูปแบบคือ% s

$ foo = abc bar = 123 $ printf '<%s>\n' " ${ foo } " " ${ bar } " <abc> <123>

สำหรับตัวเลขเท่านั้น ตัวระบุรูปแบบคือ% d

$ printf '<%d>\n' " ${ foo } " " ${ bar } " bash: printf: abc: ตัวเลขไม่ถูกต้อง<0> <123>

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

$ printf '<%s>' " ${ foo } " " ${ bar } " <abc><123>$

อีกวิธีหนึ่งที่สม่ำเสมอมากคือการใช้ผลลัพธ์ของสามารถนำกลับมาใช้เป็นอินพุตได้ อย่างไรก็ตาม ไม่ใช่ทุกตัวแปรและพารามิเตอร์ที่จะสามารถพิมพ์ได้โดยใช้เช่น ค่าของพารามิเตอร์พิเศษ แฮชแท็กพารามิเตอร์พิเศษจะรายงานจำนวนพารามิเตอร์ตำแหน่งที่ถูกกำหนดไว้ในปัจจุบันdeclare-pdeclare-pdeclare-p"$#"

$ declare -p foo bar declare -- foo="abc" declare -- bar="123" $ set -- $ declare -p " $# " bash: declare: 0: not found

สำหรับการป้อนข้อมูลแบบเต็มในเชลล์แบบโต้ตอบ...

$ declare -p #

...แฮชจะตีความแฮชแท็กนี้ว่าเป็นความคิดเห็นแบบแทรกในบรรทัด เมื่อลบความคิดเห็นและข้อความทั้งหมดทางด้านขวาออกแล้ว คำสั่งที่บาชจะดำเนินการคือ `npm run name` คำสั่งนี้ตามที่ระบุไว้ จะ"แสดงค่าและแอตทริบิวต์ของแต่ละ NAME" กล่าวคือ แต่ละตัวแปร และ "หากไม่มีการระบุ NAME จะแสดงค่าและแอตทริบิวต์และค่าของตัวแปรทั้งหมด" ซึ่งอาจมีผลลัพธ์มากกว่า 100 บรรทัดdeclare-phelp declare

ในทางกลับกันคำสั่ง printfไม่สามารถแสดงคุณสมบัติของตัวแปรได้ โปรดดูเพิ่มเติมที่§ การแก้ไขข้อผิดพลาด 

$ readonly foo $ declare -p foo declare -r foo="abc" $ printf '<%s>' " ${ foo } " <abc>$

สภาพแวดล้อมการทำงานที่กำหนดค่าได้: ^{[ w ]}

• ไฟล์เริ่มต้น เชลล์และเซสชันเช่น~/.bashrcและ~/.profile(เช่นไฟล์ dotfiles );
• การตั้งค่า ( set built-in ) และตัวเลือกเชลล์ ( shopt built-in ) ที่เปลี่ยนแปลงพฤติกรรมของเชลล์

ไฟล์เริ่มต้นเชลล์และเซสชัน (หรือที่เรียกว่า "ไฟล์ดอท")

เมื่อ Bash เริ่มทำงาน มันจะเรียกใช้คำสั่งในไฟล์ dotต่างๆ^{[ 15 ]} ต่างจากสคริปต์เชลล์ Bash ไฟล์ dot โดยทั่วไปจะไม่มีสิทธิ์ในการเรียกใช้หรือคำสั่งตัวแปลเช่น#!/bin/bash.

• ตัวอย่างการเริ่มต้นใช้งาน Bash ที่เข้ากันได้กับเวอร์ชันเก่า

ตัวอย่าง~/.bash_profileด้านล่างนี้ใช้งานได้กับ Bourne shell และให้ความหมายคล้ายกับ csh สำหรับ~/.bashrcและ~/.bash_loginเป็นการประเมินแบบลัดวงจรที่ทดสอบว่าไฟล์ชื่อมีอยู่และอ่านได้หรือไม่ โดยจะข้ามส่วนหลังหากไม่ใช่[ -r filename ] && cmd&&

[ -r ~/.profile ] && ~/.profile # ตั้งค่าสภาพแวดล้อมเพียงครั้งเดียว ใช้ไวยากรณ์ Bourne-sh เท่านั้นถ้า[ -n " ​​$PS1 " ] ; แล้ว# เรากำลังใช้งานแบบโต้ตอบอยู่หรือไม่? [ -r ~/.bashrc ] && ~/.bashrc # การตั้งค่า tty/prompt/ฟังก์ชันสำหรับเชลล์แบบโต้ตอบ[ -r ~/.bash_login ] && ~/.bash_login # งานใดๆ ที่เกี่ยวข้องกับการเข้าสู่ระบบสำหรับเชลล์ล็อกอินเท่านั้นfi # สิ้นสุดบล็อก "if"

• ปัญหาเกี่ยวกับระบบปฏิบัติการในการเริ่มต้น Bash

ระบบปฏิบัติการ UnixและLinuxบางเวอร์ชันมีสคริปต์ เริ่มต้น ระบบ/etc Bash ซึ่ง โดยทั่วไป จะอยู่ในไดเร็กทอรี` / etc / bash ...~/.xsession~/.xprofile~/.profile

สตรีมมาตรฐาน - STDIN, STDOUT และ STDERR

ชื่อแทน (Aliases) ช่วยให้สามารถใช้สตริงแทนคำที่อยู่ในตำแหน่งในข้อมูลป้อนเข้าซึ่งสามารถเป็นคำแรกของคำสั่งง่ายๆ ได้ ชื่อแทนมีชื่อและค่าที่สอดคล้องกัน ซึ่งสามารถตั้งค่าและยกเลิกได้โดยใช้คำสั่ง alias และ unalias ในตัว^{[ x ]}

• function
  • การประกาศฟังก์ชัน Bash ที่มีคีย์เวิร์ดเฉพาะนี้จะไม่สามารถใช้งานร่วมกับสคริปต์ Bourne/Korn/POSIX ได้ อย่างไรก็ตาม Bash ยอมรับไวยากรณ์การประกาศฟังก์ชันที่ใช้โดยเชลล์ Bourne, Korn และ POSIX

ฟังก์ชันเชลล์เป็นวิธีการจัดกลุ่มคำสั่งเพื่อเรียกใช้งานในภายหลัง โดยใช้ชื่อเดียวสำหรับกลุ่มคำสั่งนั้น ฟังก์ชันเหล่านี้จะถูกเรียกใช้งานเหมือนกับคำสั่งธรรมดาทั่วไป เมื่อใช้ชื่อของฟังก์ชันเชลล์เป็นชื่อคำสั่งธรรมดา เชลล์จะเรียกใช้งานรายการคำสั่งที่เกี่ยวข้องกับชื่อฟังก์ชันนั้น ฟังก์ชันเชลล์จะถูกเรียกใช้งานในบริบทของเชลล์ปัจจุบัน โดยไม่มีการสร้างกระบวนการใหม่เพื่อตีความฟังก์ชันเหล่านั้น^{[ y ]}

• คำสั่งในตัวต่างๆ:
  • ฟังก์ชันในตัวพิเศษของ POSIX: ^{[ z ]}
    • ซีดี , รหัสผ่าน , ฯลฯ
  • ตั้งค่า^{[ o ]}
    • Xtrace: [ | ]. เครื่องมือหลักในการดีบักของเชลล์ สามารถปิดทั้ง xtrace และ verbose พร้อมกันได้ด้วยคำสั่ง.set-xset-oxtraceset-
    • ละเอียด: [ | ] พิมพ์คำสั่งไปยังเทอร์มินัลตามที่ Bash อ่าน Bash อ่านโครงสร้างทั้งหมดพร้อมกัน เช่น คำสั่งประกอบที่รวมบล็อก if-fi และ case-esac หากมีการรวม a ไว้ในคำสั่งประกอบ "ละเอียด" จะถูกเปิดใช้งานในครั้งถัดไปที่ Bash อ่านโค้ดเป็นอินพุต กล่าวคือ หลังจากสิ้นสุดโครงสร้างที่กำลังทำงานอยู่^{[ 27 ]}set-vset-overboseset-v
    • สามารถปิดทั้ง xtrace และ verbose พร้อมกันได้ด้วยคำสั่ง.set-
  • ร้านค้า^{[ 28 ]}
    • expand-aliases: เปิดใช้งานโดยค่าเริ่มต้นในเชลล์แบบโต้ตอบ นักพัฒนาบางรายไม่แนะนำให้ใช้ในสคริปต์

เมื่อเชลล์ค้นหาคำสั่งภายนอก มันจะอาศัยตัวแปรเชลล์ Bourne $PATHซึ่ง$PATHประกอบด้วยรายการของไดเร็กทอรีที่คั่นด้วยเครื่องหมายโคลอน:โดยเริ่มจากไดเร็กทอรีซ้ายสุดและเลือกไดเร็กทอรีจากซ้ายไปขวา แต่ละไดเร็กทอรีจะถูกค้นหาจนกว่าจะพบคำสั่งที่ตรงกัน ในลินุกซ์ เพื่อให้ผู้ใช้สามารถค้นหาคำสั่งเพิ่มเติมได้ เป็นเรื่องปกติที่ผู้ดูแลระบบการแจกจ่ายและนักพัฒนาแพ็กเกจจะแก้ไขค่าของตัวแปรเชลล์ Bourne ของผู้ใช้ปลายทาง$PATHโดยการรวมไฟล์ต้นฉบับไว้ใน ไดเร็กทอรี `.bourne.js` /etc/profile.dและตำแหน่งอื่นๆ

เมื่อค้นหาคำสั่งchmodเช่น หลังจากพิจารณาคำสั่งภายในแล้วไม่พบอะไรเลย Bash จะค้นหาไดเร็กทอรีใน$PATHและจะเลือกเส้นทางสัมบูรณ์ของไฟล์ปฏิบัติการแรกที่พบซึ่งมีชื่อพื้นฐานที่ตรงกับสตริงการค้นหา^{[ 12 ]}

หากมีคำสั่งมากกว่าหนึ่งคำสั่งechoในไดเร็กทอรีที่ระบุไว้$PATHในระหว่างกระบวนการวิเคราะห์และเรียกใช้คำสั่งบรรทัดคำสั่ง โดยค่าเริ่มต้นจะเลือกเฉพาะคำสั่งแรกที่พบเท่านั้น $PATHการค้นหาใช้เวลานาน เชลล์จะเร่งความเร็วในการดำเนินการคำสั่งบรรทัดคำสั่งโดยการจดจำตำแหน่งคำสั่งในตารางแฮช หากต้องการค้นหาแบบเต็ม$PATHโดยไม่มีการแทรกแซงจากตารางแฮช ให้ลบตารางปัจจุบันด้วยและค้นหาคำสั่งทุกประเภทด้วยhash-rtype-a

$ # บังคับค้นหาเส้นทางแบบเต็ม$ PATH = ${ PATH } : ${ HOME } $ printf 'echo script_file: "$@"\n' > ./echo $ chmod 0700 ./echo $ hash -r ; type -a echo echo เป็นคำสั่งภายในของเชลล์echo คือ /usr/bin/echo echo คือ /home/liveuser/echo

ในการเรียกใช้คำสั่งจากบรรทัดคำสั่งที่ปรากฏอยู่ถัดไปใน$PATHสตริง คุณสามารถระบุพาธแบบสัมบูรณ์ หรือกำหนดให้การแก้ไขพาธสัมพันธ์กับไดเร็กทอรีการทำงานปัจจุบันได้

$ /home/liveuser/echo foo script_file: foo $ ./echo bar script_file: bar

เพื่อความปลอดภัย ควรตรวจสอบให้แน่ใจว่าไดเร็กทอรีใน PATH ไม่สามารถเข้าถึงได้โดยทุกคน หรือสามารถเข้าถึงได้เฉพาะผู้ใช้ root และผู้ใช้ที่เชื่อถือได้เท่านั้น

• ตำแหน่งคำสั่ง: หลังจากการขยายความแล้ว จะเป็นคำแรกของข้อความคำสั่งทั้งหมด
• การค้นหาชื่อคำสั่งจะดำเนินการตามลำดับดังต่อไปนี้:
  • คำสั่งภายในเชลล์ :
    • ชื่อเรียกแทน ของเชลล์
    • คำสงวนของเชลล์
    • ฟังก์ชันเชลล์และ
    • คำสั่งในตัวของเชลล์ ;
  • คำสั่งภายนอกเชลล์ โดยใช้ตัวแปรเชลล์ PATH:
    • แยก โปรแกรมแบบ UNIXเช่นlsหรือlnออกจากกัน
    • สคริปต์เชลล์ซึ่งเป็นไฟล์ที่มีคำสั่งที่สามารถเรียกใช้งานได้^{[ aa ]}

ซับเชลล์ : (...);

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

• และ ( &&)
• หรือ ( ||)
• ไม่ ( !)

Bash supplies "conditional execution" command separators that make execution of a command contingent on the exit code set by a precedent command. For example:

$ cd"$SOMEWHERE"&&./do_something||echo"An error occurred">&2

Where ./do_something is only executed if the cd (change directory) command was "successful" (returned an exit status of zero) and the echo command would only be executed if either the cd or the ./do_something command return an "error" (non-zero exit status).

ITERATION: Sometimes programs are repeated indefinitely or until a specific outcome is reached. Each execution of the instructions is an "iteration."^[29]

• while, until, and select loop compound commands;
• Arithmetic C-style and list-enumerating for loop compound commands; and
• continue, break, return, and exit flow control commands;

compound: something formed by a union of elements or parts.^[30]

Bash also supports if...fi and case...esac forms of conditional command evaluation.^[ab]

Built in commands for testing file attributes, comparing string and integer values, etc.:

• Traditional test command,
• Traditional single bracket test: [,
• Modern double bracket test: [[...]], which includes advanced features:
  • Extended regular expression and extglob matching
  • Lexicographic comparisons with < and >;
• ((...)) numeric evaluation and testing; this includes almost all "C" language operators for arithmetic and numeric comparison;

For all commands the exit status is stored in the special variable $?.

Bash 3.0 supports in-process regular expression matching using a syntax reminiscent of Perl.^[32] Regexp matching is limited to strings on the right side of the =~ operator in the [[..]] extended test construct.^[ac]

[[${line}=~[[:space:]]*(a)?b]] means values for line like 'aab', ' aaaaaab', 'xaby', and ' ab' will all match, as will a line containing a 'b' anywhere in its value.

โคโปรเซส (Coprocess) คือคำสั่งเชลล์ที่นำหน้าด้วยคำสงวน coproc โคโปรเซสจะถูกดำเนินการแบบอะซิงโครนัสในซับเชลล์ ราวกับว่าคำสั่งนั้นถูกยุติด้วยตัวดำเนินการควบคุม '&' โดยมีการสร้างไปป์แบบสองทางระหว่างเชลล์ที่กำลังทำงานและโคโปรเซส^{[โฆษณา]}

แยกออกเป็นคำ (เช่นการแยกคำ )

เมื่อไม่แน่ใจ ให้อ้างอิง! ^{[ 33 ]}

Bash มีกฎการอ้างอิง บางอย่าง: การใช้งานของ

• เครื่องหมายอัญประกาศเดี่ยว'...'
• เครื่องหมายอัญประกาศคู่"..."
• เครื่องหมายแบ็กสแลช\และ
• $'...'การอ้างอิงแบบ ANSI-C

ดูเพิ่มเติมที่§ สถาน ที่ตั้ง$"..."

ดูเพิ่มเติมที่เครื่องหมายแบ็กติ๊ก`...`: §  ไวยากรณ์ที่เลิกใช้แล้ว

รองรับ การเขียนข้อความอ้างอิง ด้วยUnicodeและ ANSI-Cecho-e

$ echo kernel { ,-headers } kernel kernel-headers

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

$ echo a { p,c,d,b } e ape ace ade abe $ echo { a,b,c }{ d,e,f } ad ae af bd be bf cd ce cf

ผู้ใช้ไม่ควรใช้การขยายวงเล็บปีกกาในสคริปต์เชลล์แบบพกพา เนื่องจากเชลล์ Bourneไม่ได้สร้างเอาต์พุตแบบเดียวกัน

$ # เชลล์ bash $ /bin/bash -c 'echo a{p,c,d,b}e' ape ace ade abe $ # เชลล์แบบดั้งเดิมจะไม่แสดงผลลัพธ์เดียวกัน$ /bin/sh -c 'echo a{p,c,d,b}e' a{p,c,d,b}e

เมื่อขยายวงเล็บปีกกาพร้อมกับใช้สัญลักษณ์ตัวแทน (wildcard) วงเล็บปีกกาจะถูกขยายก่อน จากนั้นสัญลักษณ์ตัวแทนที่ได้จะถูกแทนที่ตามปกติ ดังนั้น การแสดงรายการภาพ JPEG และ PNG ในไดเร็กทอรีปัจจุบันจึงสามารถทำได้โดยใช้:

ls *. { jpg,jpeg,png } # ขยายเป็น *.jpg *.jpeg *.png – หลังจากนั้น# จะประมวลผลสัญลักษณ์ตัวแทนecho *. { png,jp { e, } g } # echo แสดงเฉพาะผลลัพธ์การขยาย – # และสามารถใช้เครื่องหมายวงเล็บปีกกาซ้อนกันได้

In addition to alternation, brace expansion can be used for sequential ranges between two integers or characters separated by double dots. Newer versions of Bash allow a third integer to specify the increment.

$ echo{1..10}1 2 3 4 5 6 7 8 9 10$ echo{01..10}01 02 03 04 05 06 07 08 09 10$ echofile{1..4}.txt file1.txt file2.txt file3.txt file4.txt$ echo{a..e}a b c d e$ echo{1..10..3}1 4 7 10$ echo{a..j..3}a d g j

When brace expansion is combined with variable expansion (a.k.a., parameter expansion and parameter substitution) the variable expansion is performed after the brace expansion, which in some cases may necessitate the use of the eval built-in, thus:

$ start=1;end=10$ echo{$start..$end}# fails to expand due to the evaluation order{1..10}$ evalecho{$start..$end}# variable expansion occurs then resulting string is evaluated1 2 3 4 5 6 7 8 9 10

• Type
• Shell parameters
• Environment variables
• User variables
• Scope
• Arrays
  • Indexed arrays: size is unlimited.
  • Associative arrays: via declare-A. In February 2009, Bash 4.0 introduced support for associative arrays. Associative array indices are strings, in a manner similar to AWK or Tcl. They can be used to emulate multidimensional arrays.^[h]
• Parameter Expansion

  Expansion syntaxes which can perform some tasks more quickly than external utilities, including, among others:

  • Pattern Substitution
    • ${foo//x/y} for sed 's/x/y/g',
  • Remove Matching Prefix or Suffix Pattern
    • ${bar##[a-zA-Z0-9]*} for cut -c8-,
  • Enumerate Array Keys
    • ${!array[@]}, and
  • Display Error if Null or Unset
    • ${var:?error message},

Pathname expansion, i.e., shell-style globbing and pattern matching using *, ?, [...].^[af]

Locale-specific translation via $"..." quoting syntax.^[ag]

การแทนที่คำสั่ง : ,$(...)

การทดแทนกระบวนการหรือเมื่อระบบรองรับ:<()>()

Bash รองรับการแทนที่กระบวนการโดยใช้ ไวยากรณ์ `and` ซึ่งจะแทนที่เอาต์พุตของ (หรืออินพุตของ) คำสั่งในตำแหน่งที่ปกติแล้วจะใช้ชื่อไฟล์ (โดยจะดำเนินการผ่านทาง ไปป์ที่ไม่มีชื่อ `/proc/fd/`บนระบบที่รองรับ หรือผ่านไปป์ที่มีชื่อ ชั่วคราว เมื่อจำเป็น)<(command)>(command)

การขยายเลขคณิต((...))หรือรวมถึง$((...))

• การคำนวณเลขจำนวนเต็มในฐาน ใดๆ ตั้งแต่สองถึงหกสิบสี่ แม้ว่า
• การคำนวณเลขทศนิยมไม่สามารถใช้งานได้ภายในเชลล์โดยตรง (หากต้องการใช้งานฟังก์ชันนี้ โปรดดูเวอร์ชันปัจจุบันของbcและawkเป็นต้น)

Bash สามารถทำการคำนวณจำนวนเต็ม ("การประเมินค่าทางคณิตศาสตร์") โดยไม่ต้องสร้างกระบวนการภายนอก โดยใช้ ไวยากรณ์ ((...))คำสั่งและตัวแปรเพื่อจุดประสงค์นี้$((...))

มีการดำเนิน การเปลี่ยนเส้นทาง ของ สตรีมข้อมูลอินพุตมาตรฐาน เอาต์พุตมาตรฐาน และข้อผิดพลาดมาตรฐานรวมถึง:

• การเขียนไฟล์>, และการเพิ่มไฟล์>>,
• เอกสารเหล่า<<นี้...
• ในที่นี้มีสตริง<<<ซึ่งอนุญาตให้ใช้พารามิเตอร์เป็นอินพุตได้ และ
• ตัวดำเนินการเปลี่ยนเส้นทาง>|ซึ่งสามารถบังคับให้เขียนทับไฟล์ได้เมื่อเปิดใช้งานการตั้งค่าnoclobber ของเชลล์

ไวยากรณ์ของมันทำให้ การเปลี่ยน เส้นทางการรับส่งข้อมูล (I/O redirection ) ง่ายขึ้น ตัวอย่างเช่น มันสามารถเปลี่ยนเส้นทางการรับส่งข้อมูลมาตรฐาน (stdout) และข้อผิดพลาดมาตรฐาน (stderr) พร้อมกันได้โดยใช้&>ตัวดำเนินการ `@directory` ซึ่งพิมพ์ง่ายกว่าคำสั่ง `@directory` ใน Bourne shell Bash รองรับเอกสาร here documentตั้งแต่เวอร์ชัน 2.05b เป็นต้นไป Bash สามารถเปลี่ยนเส้นทางการรับข้อมูลมาตรฐาน (stdin) จาก "here string" โดยใช้ตัวดำเนินการ `@directory` ได้command>file2>&1<<<

ประวัติคำสั่งไม่จำกัดขนาดคุณสมบัตินี้ใช้งานได้เฉพาะในโหมดโต้ตอบเท่านั้น^{[ ai ]}

คุณสมบัติ การจัดเรียงไดเร็กทอรี ( pushdและpopdคุณสมบัติในตัว) สามารถใช้งานได้เฉพาะในโหมดโต้ตอบเท่านั้น

หรือที่รู้จักกันในชื่อ "การเติมคำอัตโนมัติด้วยแท็บ" หรือ " การเติมคำอัตโนมัติในบรรทัดคำสั่ง " เมื่อผู้ใช้กดปุ่ม Tab ภายในเชลล์คำสั่งแบบโต้ตอบ Bash จะใช้สคริปต์การเติมคำอัตโนมัติที่มีอยู่เพื่อแนะนำชื่อโปรแกรม ชื่อไฟล์ และชื่อตัวแปรที่พิมพ์ไว้บางส่วนโดยอัตโนมัติ^{[ aj ]} ระบบการเติมคำอัตโนมัติในบรรทัดคำสั่งของ Bash มีความยืดหยุ่นและปรับแต่งได้สูง และมักจะมาพร้อมกับฟังก์ชันที่เติมอาร์กิวเมนต์และชื่อไฟล์สำหรับโปรแกรมและงานเฉพาะTab ↹

Bash รองรับการเติมข้อความ อัตโนมัติแบบโปรแกรมได้ผ่าน คำสั่งในตัวcomplete, compopt, และ^{[ 36 ]} คุณสมบัตินี้มีให้ใช้งานตั้งแต่เวอร์ชันเบต้า 2.04 ที่วางจำหน่ายในปี 2000compgen

คำสั่งเหล่านี้ช่วยให้สามารถระบุคำสั่ง (เช่น โปรแกรมที่ติดตั้ง) ฟังก์ชัน ตัวแปร และชื่อไฟล์ได้อย่างละเอียดและชาญฉลาด^{[ 37 ]}

คำ สั่ง completeและcompoptสองคำสั่งระบุวิธีการแสดงรายการอาร์กิวเมนต์ของคำสั่งหรือตัวเลือกที่มีอยู่บางรายการใน อินพุต readlineตั้งแต่เวอร์ชัน 5.1 การเติมคำสั่งหรือตัวเลือกมักจะเปิดใช้งานโดยการกดแป้นพิมพ์หลังจากพิมพ์ชื่อ^{[ 37 ]} คุณสมบัตินี้มีให้ใช้งานในโหมดโต้ตอบเท่านั้น Tab

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

โครงการ GNU จัดเตรียม " คู่มือผู้ใช้" ^{[ 11 ]}สำหรับ Bash ไว้ บางครั้งถือว่าเป็นเอกสารที่เป็นมิตรกับผู้ใช้มากกว่าหน้า man page "คุณอาจค้นหาข้อมูลเกี่ยวกับ Bash ... โดยการดูที่/usr/share/doc/bash, /usr/local/share/doc/bash, หรือไดเร็กทอรีที่คล้ายกันในระบบของคุณ" ^{[ 38 ]} บนระบบ GNU/Linux หาก มีโปรแกรม info เวอร์ชันคู่มือ GNU ที่เกี่ยวข้องกับการ ^ติดตั้งของคุณควรมีอยู่ที่[ ^{11 ] [ 39 ]}info bash

คู่มือทางเทคนิคฉบับล่าสุด หรือ"man page"นั้นมีจุดประสงค์เพื่อเป็นเอกสารทางเทคนิคที่อธิบายวิธีการทำงานของ bash อย่างมีอำนาจ บนระบบ GNU/Linux เวอร์ชันที่เกี่ยวข้องกับการติดตั้งของคุณมักจะสามารถเข้าถึงได้ผ่านโปรแกรมmanที่^{[ 25 ]}manbash

ใน Bash เวอร์ชันล่าสุด ข้อมูลเกี่ยวกับคำสั่งในตัวของเชลล์สามารถค้นหาได้โดยการเรียกใช้คำสั่งhelpหรือที่พรอมต์เทอร์มินัลที่มีการติดตั้ง Bash ไว้help[nameofbuiltin]man builtins

คำ สั่ง printfสามารถเรียกใช้ผ่านenvเพื่อให้แน่ใจว่าคุณเรียกใช้โปรแกรมที่พบผ่านเส้นทางการค้นหาของเชลล์ ไม่ใช่นามแฝงของเชลล์หรือฟังก์ชันในตัว: . ^{[ 40 ]}envprintf--help

เพื่อจุดประสงค์ในการอนุญาตให้โปรแกรมเชลล์ต่างๆ ที่ทำงานบนระบบปฏิบัติการที่แตกต่างกันสามารถทำงานร่วมกันได้"ข้อกำหนด POSIX" ^{[ 8 ]}มีอิทธิพลต่อวิธีการเขียนเชลล์แบบ UNIX สมัยใหม่ Bash "มีจุดประสงค์เพื่อเป็นการใช้งานที่สอดคล้องกับ ส่วน "เชลล์และยูทิลิตี้"ของข้อกำหนด IEEE POSIX (มาตรฐาน IEEE 1003.1)" ^{[ ak ]} เอกสารเผยแพร่ล่าสุดของมาตรฐาน (2024) มีให้บริการทางออนไลน์

มาตรฐาน POSIX หรือ IEEE Std 1003.1 ซึ่งเป็นมาตรฐานพื้นฐานของ bash นั้นให้ข้อมูลที่เป็นประโยชน์อย่างยิ่ง

"ผู้ดูแลโครงการยังมีหน้า Bash ซึ่งรวมถึงคำถามที่พบบ่อย" ^{[ 38 ] [ 41 ] [ 42 ]} FAQ นี้เป็นปัจจุบัน ณ เวอร์ชัน bash 5.1 และไม่ได้รับการอัปเดตอีกต่อไป

ช่องทางการสนับสนุนแบบไม่เป็นทางการมีให้บริการผ่าน IRC ที่ libera.chat ในช่อง #bash และมีรายชื่อผู้รับจดหมายให้บริการ^{[ 7 ]}

การเรียกใช้สคริปต์เชลล์ใดๆ ในฐานะผู้ใช้ root นั้นถูกวิพากษ์วิจารณ์อย่างกว้างขวางมานานหลายปีแล้วว่าเป็นแนวทางปฏิบัติที่ไม่ปลอดภัย เหตุผลหนึ่งที่มักถูกกล่าวถึงคือ เมื่อสคริปต์ถูกเรียกใช้ในฐานะ root ผลกระทบเชิงลบของข้อผิดพลาดใดๆ ในสคริปต์จะถูกขยายให้ใหญ่ขึ้นเนื่องจากสิทธิ์ระดับสูงของ root

ตัวอย่างที่พบได้ทั่วไป: สคริปต์มีคำสั่งแต่ตัวแปรไม่ได้ถูกกำหนดค่าไว้ ในลินุกซ์ หากสคริปต์ถูกเรียกใช้โดยผู้ใช้ทั่วไป เชลล์จะพยายามเรียกใช้คำสั่งในฐานะผู้ใช้ทั่วไป และคำสั่งนั้นจะล้มเหลว อย่างไรก็ตาม หากสคริปต์ถูกเรียกใช้โดยผู้ใช้ root คำสั่งนั้นก็มีแนวโน้มที่จะสำเร็จและระบบไฟล์จะถูกลบrm-rf${dir}/$dirrm -rf /

ขอแนะนำให้ใช้คำสั่ง sudoในแต่ละคำสั่งแทน

สคริปต์ CGI เป็นแหล่งที่มาของช่องโหว่ที่สำคัญ^{[ 43 ] [ 44 ] [ 45 ]}

"คำสั่ง eval มีประสิทธิภาพอย่างมากและง่ายต่อการนำไปใช้ในทางที่ผิดอย่างมาก" ^{[ 46 ]}

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

การตรวจสอบความถูกต้องของข้อมูลขาเข้าจะดำเนินการเพื่อให้แน่ใจว่ามีเพียงข้อมูลที่มีรูปแบบถูกต้องเท่านั้นที่เข้าสู่เวิร์กโฟลว์ในระบบสารสนเทศ ป้องกันไม่ให้ข้อมูลที่มีรูปแบบไม่ถูกต้องคงอยู่ในฐานข้อมูลและทำให้ส่วนประกอบปลายทางต่างๆ ทำงานผิดปกติ การตรวจสอบความถูกต้องของข้อมูลขาเข้าควรเกิดขึ้นโดยเร็วที่สุดเท่าที่จะเป็นไปได้ในกระแสข้อมูล โดยควรทำทันทีที่ได้รับข้อมูลจากฝ่ายภายนอก^{[ 47 ]}

ในเดือนกันยายน พ.ศ. 2557 มีการค้นพบ ช่องโหว่ด้านความปลอดภัยในโปรแกรม ช่องโหว่นี้ถูกตั้งชื่อว่า " Shellshock "การเปิดเผยต่อสาธารณะอย่างรวดเร็วทำให้เกิดการโจมตี ต่างๆ ทั่วอินเทอร์เน็ต^{[ 48 ] [ 49 ] [ 50 ]}

การใช้ประโยชน์จากช่องโหว่นี้อาจทำให้สามารถเรียกใช้โค้ดตามอำเภอใจใน สคริปต์ CGIที่สามารถเรียกใช้งานได้โดย Bash บางเวอร์ชัน ข้อบกพร่องนี้เกี่ยวข้องกับวิธีที่ Bash ส่งผ่านคำจำกัดความของฟังก์ชันไปยังซับเชลล์ผ่าน^{ตัวแปร}สภาพแวดล้อม [ ^{51 ]} ข้อบกพร่องนี้มีอยู่ในซอร์สโค้ดตั้งแต่เดือนสิงหาคม พ.ศ. 2532 (เวอร์ชัน 1.03) ^{[ 52 ]}และได้รับการแก้ไขในเดือนกันยายน พ.ศ. 2557 (เวอร์ชัน 4.3)

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

ช่องโหว่นี้ได้รับการกำหนดรหัสช่องโหว่ทั่วไป ( CVE) ได้แก่ CVE -2014-6271 , CVE- 2014-6277 และCVE- 2014-7169เป็นต้น ภายใต้เกณฑ์ CVSS Metrics 2.x และ 3.x ช่องโหว่นี้ถูกจัดอยู่ในระดับ "สูง" และ "วิกฤต" ตามลำดับ

• คุณสมบัติของเชลล์ที่กำหนดโดยPOSIX :
  • การขยายพารามิเตอร์เชลล์^{[ ar ]}
  • พารามิเตอร์พิเศษ: ^{[ as ]}
  • ชุดยูทิลิตี้ในตัวพิเศษ: ^{[ o ]}
  • กับดักอเนกประสงค์แบบติดตั้งในตัวพิเศษ: ^[ที่]
    • มาตรฐาน POSIX กำหนดการใช้งาน ฟังก์ชัน trap ไว้บางประการ : ...
  • ยูทิลิตี้printf : วิธีการพิมพ์เนื้อหาของตัวแปรอย่างน่าเชื่อถือ:
• คุณสมบัติของ Bash ที่ไม่ได้ระบุไว้ในมาตรฐาน POSIX:
  • ตัวแปร Bash: ^{[ au ]}
  • ชุด Shell Builtin : ^{[ o ]}
  • ร้านค้า Shell Builtin : ^{[ av ]}
  • กับดักในตัวของเชลล์: ^{[ aw ]}
    • แม้ว่ามาตรฐาน POSIX จะระบุการใช้งาน ฟังก์ชัน trap ไว้ บางประการ แต่ข้อกำหนดสัญญาณต่อไปนี้เป็นส่วนขยายของ Bash: ...
• เครื่องมือช่วยแก้ไขข้อผิดพลาดจากผู้พัฒนาภายนอก:
  • ShellCheck: เครื่องมือวิเคราะห์สคริปต์ Shell; ^{[ 69 ] [ 70 ]}

^{[ 19 ]}

• • devscripts-checkbashisms: ตรวจสอบว่าสคริปต์ /bin/sh มีโครงสร้างเฉพาะของ bash ทั่วไปหรือไม่^{[ 71 ] [ 18 ]}
  • kcov: เครื่องมือวัดความครอบคลุมของโค้ดโดยไม่มีตัวเลือกการคอมไพล์พิเศษ; ^{[ 72 ]}
  • Bashdb: ตัวดีบักเกอร์เชิงสัญลักษณ์ของ Bash ^{[ 22 ] [ 73 ]}

คำสั่งภายนอกที่เรียกว่าbashbugจะรายงานข้อบกพร่องของเชลล์ Bash เมื่อเรียกใช้คำสั่งนี้ จะแสดงตัวแก้ไขเริ่มต้นของผู้ใช้พร้อมแบบฟอร์มให้กรอก แบบฟอร์มนี้จะถูกส่งทางอีเมลไปยังผู้ดูแล Bash (หรืออาจส่งไปยังที่อยู่อีเมลอื่นก็ได้) ^{[ 74 ]}

เหตุการณ์สำคัญในประวัติศาสตร์ของ Bash มีดังต่อไปนี้: ^{[ 78 ]}

• เปลือกหอยอัลมควิสต์ (เถ้า)
  • เชลล์ Debian-Almquist (แดช)
• บอร์นเชลล์ (sh)
• บัสซี่บ็อกซ์
• ซีเชลล์ (csh)
• ปลา (เปลือกหอยที่เป็นมิตรและโต้ตอบได้)
  • nsh – เชลล์บรรทัดคำสั่งเหมือน fish แต่เข้ากันได้กับ POSIX ^{[ 116 ]}
• Google Shell (goosh) – ส่วนติดต่อผู้ใช้แบบ UNIX สำหรับการค้นหาของ Google
• KornShell (ksh) – มีหลายรูปแบบ
• osh (Oil Shell) – เชลล์บรรทัดคำสั่ง UNIX ที่ใช้งานร่วมกับ Bash ได้ มีให้ใช้งานบนArch Linux
• เปลือกแผงวงจรพิมพ์ (เปลือก Mashey หรือ Programmer's Workbench)
• Qshell – สำหรับ IBM i
• rc – จากPlan 9
• รันคอม
• rush (Restricted User Shell) – มีให้บริการบนDebian ^{[ 92 ]}
• บานหน้าต่าง (กรอบหน้าต่าง) แบบตั้งเดี่ยว
• scsh (The Scheme Shell)
• tcsh (TENEX C shell)
• เปลือกหอยทอมป์สัน (tsh)
• กล่องของเล่น
• yash (Yet Another Shell) – มีเป้าหมาย "ที่จะเป็นเชลล์ที่สอดคล้องกับมาตรฐาน POSIX มากที่สุดในโลก" สามารถใช้งานได้บนArch Linux
• Z shell (zsh)

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

• curses - curses เป็นไลบรารีควบคุมเทอร์มินัลสำหรับระบบปฏิบัติการที่คล้าย Unix ซึ่งช่วยให้สามารถสร้างแอปพลิเคชันส่วนติดต่อผู้ใช้แบบข้อความ (TUI) ได้
• dialog - เป็นยูทิลิตี้ที่ช่วยให้คุณสร้างกล่องโต้ตอบในคอนโซล โดยใช้ไลบรารีcursesและncurses
• gtkdialog - เป็นยูทิลิตี้ที่มีฟังก์ชันการทำงานมากที่สุดสำหรับการสร้างแอปพลิเคชันกราฟิกบนสคริปต์ bash ^{[ 117 ]}

• kdialog - เทียบเท่ากับ KDE ของ zenity ^{[ 118 ]}

• ncurses - ไลบรารีการเขียนโปรแกรมสำหรับสร้างส่วนติดต่อผู้ใช้แบบข้อความ (TUI) ที่ใช้งานได้กับเทอร์มินัลหลากหลายประเภท
• whiptail - เป็นอนาล็อกของยูทิลิตี้ dialog โดยใช้ไลบรารีnewt ^{[ 119 ]}

• xdialog - เป็นโปรแกรมทดแทนdialogที่ออกแบบมาเพื่อให้โปรแกรมที่เรียกใช้งานจากเทอร์มินัลมีอินเทอร์เฟซระบบ X Window System
• yad - เป็นเวอร์ชันแยกของ zenity ที่มีคุณสมบัติเพิ่มเติม^{[ 120 ]}

• Zenityเป็นแอปพลิเคชันที่ได้รับความนิยมมากที่สุดสำหรับการสร้างอินเทอร์เฟซกราฟิกสำหรับสคริปต์^{[ 121 ]}