วิธีดำเนินการคำสั่งจากภายในเชลล์สคริปต์

ใน bash การรันคำสั่งจากเชลล์สคริปต์อาจดูน่ากลัวเล็กน้อยในตอนแรกและอาจต้องใช้ศรัทธาอย่างก้าวกระโดด ท้ายที่สุด คำสั่งที่ดำเนินการภายในสคริปต์ทุบตีจะไม่โต้ตอบ ที่นี่เราจะวางรากฐานเพื่อรันคำสั่งจากภายในเชลล์สคริปต์โดยตอบคำถามต่อไปนี้เกี่ยวกับคำสั่ง: พวกมันมาจากไหน? พวกเขาคืออะไร? เราจะใช้ในสคริปต์ได้อย่างไร

คำสั่งมาจากไหน?

คำสั่งใน bash มาจากหมวดหมู่ใด ๆ ต่อไปนี้:

ทุบตีตัวเอง (ดูบิวด์อิน)

Bash มาพร้อมกับชุดคำสั่งของตัวเองเพื่ออนุญาตให้เข้าถึงคุณสมบัติในตัว เช่น การประกาศอาร์เรย์ การอ่านบรรทัดจากไฟล์ และคุณสมบัติอื่นๆ ในตัวเพื่อทุบตี เราเรียกคำสั่งของหมวดหมู่นี้ คำสั่ง bash builtin หรือเรียกสั้นๆ ว่า buildins

ปฏิบัติการในสภาพแวดล้อมของคุณ (ดูคำสั่งภายนอก)

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

ฟังก์ชันที่ผู้ใช้กำหนด (ดูฟังก์ชัน)

ก่อนดำเนินการคำสั่งภายนอกและบิวด์อิน ทุบตีตรวจสอบว่ามีการกำหนดฟังก์ชันหรือไม่ หากเป็นฟังก์ชันจะถูกดำเนินการตามคำสั่ง หากไม่เป็นเช่นนั้น จะดำเนินการตามลำดับความสำคัญของคำสั่ง ในการเรียกใช้ฟังก์ชันที่กำหนดไว้นอกสคริปต์ จะต้องประกาศด้วยแอตทริบิวต์ -x; มิฉะนั้น อาจรวมไว้โดยใช้ . สั่งการ. เราเรียกคำสั่งของหมวดหมู่นี้โดยผู้ใช้กำหนดฟังก์ชันหรือฟังก์ชันสั้นๆ

คำสั่งคืออะไร

คำสั่งคือคำใดๆ ที่ถือว่าเป็นจุดเข้าใช้งานโปรแกรมเดียวภายในสภาวะแวดล้อมเชลล์ ในกรณีที่คำสั่งถูกดำเนินการ คำสั่งเองและอาร์กิวเมนต์ทางเลือกจะถูกส่งผ่านเป็นพารามิเตอร์ตำแหน่ง ${0}, ${1}, ${2}, … พารามิเตอร์ตำแหน่งที่ศูนย์ (${0}) กำหนด คำสั่งเองและจะไม่เปลี่ยนแปลงในบริบท ซึ่งแตกต่างจากพารามิเตอร์ตำแหน่งในฟังก์ชัน ${1}, ${2}, ... ที่อาจเปลี่ยนแปลงขึ้นอยู่กับบริบท ${0} จะไม่เปลี่ยนแปลงระหว่างการเรียกใช้ฟังก์ชัน

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

นี่คือรายการประเภทคำสั่งที่ควรรู้

คำสั่งในตัว

เหล่านี้เป็นพลเมืองชั้นหนึ่งของ bash Universe รวมถึงอักขระเช่น '.' ':' '[' ']' และคำสงวนเช่นประกาศใน bash คุณวางใจในคำสั่งเหล่านี้ ซึ่งอยู่ในรายการคำสั่งในตัวของ bash เพื่อให้พร้อมใช้งานภายในสคริปต์ทุบตีของคุณ

ขึ้นอยู่กับการกำหนดและหมายเลขเวอร์ชันของตัวแปล bash ของคุณ คำสั่งบางคำสั่งอาจไม่สามารถใช้ได้

คำสั่งภายนอก

คำสั่งภายนอกสามารถเรียกใช้งานได้ภายนอกสคริปต์ทุบตีเช่น curl คำสั่งภายนอกจะไม่ถูกจัดเก็บเป็นตัวแปรต่างจากฟังก์ชัน

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

bash: คำสั่งที่ไม่รู้จัก:สั่งการไม่พบ

ในสคริปต์ทุบตี ฟังก์ชันอาจแทนที่การทำงานของคำสั่งภายนอก หากใช้ชื่อเดียวกันเช่นที่เราเคยเห็นในตัวอย่าง curl bash ตัวอย่างของคำสั่งภายนอกที่กำหนดเองโดยใช้ฟังก์ชันดังต่อไปนี้

curl() {
สั่งการ ${FUNCNAME}...
}

ใช้งานได้เพราะฟังก์ชั่นมีความสำคัญสูงกว่าคำสั่งภายนอกและแม้แต่ bash buildins ข้อจำกัดคืออักขระที่ได้รับอนุญาตในชื่อฟังก์ชัน

โปรดทราบว่าตัวอย่างข้างต้นสามารถทำได้โดยใช้นามแฝงดังต่อไปนี้

นามแฝง curl= '
{
ขด ...
}
'

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

ฟังก์ชั่น

ฟังก์ชั่นกฎในทุบตี ก่อนที่จะดูคำสั่งในตัวและคำสั่งภายนอก bash จะตรวจสอบว่าฟังก์ชันที่กำหนดโดยชื่อฟังก์ชันตัวเลือก คำแรกที่ปรากฏในบรรทัดหรือหลัง ; อักขระที่กำหนดส่วนท้ายของบรรทัดคำสั่ง ข้อยกเว้นเพียงอย่างเดียวคือตัวแปร bash ที่เขียนด้วยตัวพิมพ์ใหญ่ทั้งหมด เช่น ${FUNCNAME}

นามแฝง() { FUNCNAME=asdf ;โยนออก $ {@ ,,};}
นามแฝง curl='TEST CURL นามแฝง' #?

คำสั่งง่ายๆ

คำสั่งง่าย ๆ ถูกกำหนดในหน้า bash man เป็นคำตามด้วยอาร์กิวเมนต์ที่เป็นทางเลือก ในบริบท คำสั่งอย่างง่ายอาจเป็นคำสั่งในตัว คำสั่งภายนอก หรือฟังก์ชันก็ได้

วิธีรันคำสั่งจากภายในสคริปต์ทุบตี

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

ต่อไปนี้เป็นวิธีควบคุมลำดับความสำคัญในสคริปต์ทุบตี

ให้ทุบตีตัดสินใจ

command_name

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

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

สั่งการcommand_name

สมมติว่ามีคำสั่งภายนอก command_name ที่พร้อมใช้งานในโหมดโต้ตอบและคุณต้องการใช้ในสคริปต์ทุบตี เราสามารถบอก bash ได้อย่างชัดเจนว่า command_name เป็นคำสั่งภายนอกโดยใช้คำสั่ง builtin

ตัวอย่างคำสั่งภายนอก

ตัวอย่างคำสั่งภายนอก สมมติว่ามีการติดตั้งสิ่งต่อไปนี้:

ไฟล์
ไป
ฟิกเล็ต

ตัวอย่าง: รับประเภทไฟล์และข้อมูล

{ # รับประเภทไฟล์และข้อมูล
ไฟล์ ${infile} # (1,2)
}
# (1) คำสั่งไฟล์
# (2) infile={เส้นทางไปยังไฟล์}

ตัวอย่าง: สเตจที่แก้ไขและไฟล์ใหม่ใน git

{ # ไฟล์สเตจใน git
git add.# (1)
}
# (1) คำสั่ง git

ตัวอย่าง: สร้าง ascii art โดยใช้ figlet

{ #สร้างงานศิลปะ ascii
ฟิกเล็ต${ข้อความ} # (1,2)
}
# (1) คำสั่ง figlet
# (2) message={ข้อความที่จะแสดงเป็น ascii art}

ดำเนินการคำสั่งในตัว

ในตัวcommand_name

สมมติว่า command_name เป็นหนึ่งในคำสั่งที่กำหนดให้เป็นบิวด์อินในทุบตี เพื่อให้ bash รู้ว่าเราต้องการเรียกใช้ command_name เป็นบิวด์อิน เราใช้บิวด์อินบิวด์อิน

ตัวอย่างคำสั่งในตัว

ตัวอย่าง: บิวอินกี่ตัว?

ในตัว{,}{,,}{,,,} #บิวอินกี่ตัว?

ตัวอย่าง: Phantom ประกาศ

{
ประกาศ() { โยนออกอ๊ะ!;}
ประกาศ–xfประกาศ #?
}

บทสรุป

มันค่อนข้างง่ายที่จะรันคำสั่งจากภายใน bash shell script มีสามประเภทคำสั่งหลัก การรู้ว่าคำสั่งง่ายๆ ถูกตีความใน bash อย่างไรสามารถนำไปสู่การควบคุมที่ดีขึ้นเกี่ยวกับประเภทของคำสั่งที่ดำเนินการในรันไทม์