เอกสารสรุปนี้ครอบคลุมหัวข้อต่อไปนี้: ข้อมูลเบื้องต้นเกี่ยวกับเชลล์ การนำทาง คำสั่งพื้นฐาน ตัวแปรสภาพแวดล้อม ตัวเชื่อมต่อ ไปป์ การเปลี่ยนเส้นทาง I/O สิทธิ์ และแป้นพิมพ์ลัด

Bash Shell: บทนำ

เชลล์หรือเชลล์คือโปรแกรมในกรณีของเราที่เรียกว่า "bash" ซึ่งย่อมาจาก Bourne Again Shell เชลล์ยอมรับคำสั่งของคุณและส่งต่อไปยังระบบปฏิบัติการ ในการโต้ตอบกับระบบ เทอร์มินัลจะถูกใช้ เช่น gnome-terminal, eterm, nxterm เป็นต้น

การนำทาง

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

นโยบายความเป็นส่วนตัว

คำสั่ง pwd ย่อมาจาก พิมพ์ไดเร็กทอรีการทำงาน, แสดงผล สถานที่ปัจจุบันในโครงสร้างไดเร็กทอรี

ซีดี

คำสั่ง cd ให้คุณไปที่ แค็ตตาล็อกใหม่.

mkdir

คำสั่ง mkdir สร้างไดเร็กทอรีใหม่ในไดเร็กทอรีปัจจุบัน

คำสั่งพื้นฐาน

ผู้ชาย

คำสั่ง man แสดงคู่มือคำสั่ง ตัวอย่างเช่น คำสั่งต่อไปนี้จะแสดงข้อมูลทั้งหมดเกี่ยวกับคำสั่ง cat:

$ ผู้ชาย แมว

แมว

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

เสียงสะท้อน

คำสั่ง echo พิมพ์อาร์กิวเมนต์ไปยังเอาต์พุตมาตรฐาน

$ echo สวัสดีชาวโลก สวัสดีชาวโลก

หากคุณเรียก echo โดยไม่มีข้อโต้แย้ง มันจะพิมพ์ออกมา บรรทัดว่าง.

ศีรษะ

คำสั่ง head อ่าน 10 บรรทัดแรกของข้อความที่ส่งผ่านและส่งออกไปยังไปป์มาตรฐาน จำนวนบรรทัดที่แสดงสามารถเปลี่ยนแปลงได้:

$หัว -50 test.txt

หาง

คำสั่ง tail ทำงานคล้ายกับคำสั่ง head แต่อ่านบรรทัดจากส่วนท้าย:

$ หาง -50 test.txt

คุณยังสามารถดูบรรทัดที่ถูกเพิ่มลงในไฟล์แบบเรียลไทม์โดยใช้แฟล็ก -f:

$ หาง -f test.txt

น้อย

คำสั่ง less ช่วยให้คุณสามารถนำทางผ่านไฟล์หรือข้อความที่ถ่ายโอนได้ทั้งสองทิศทาง

$ test.txt น้อยกว่า $ ps aux | น้อย

เรียนรู้เพิ่มเติมเกี่ยวกับวัตถุประสงค์ของสัญลักษณ์ | จะกล่าวถึงด้านล่างในส่วนประวัติของคำสั่ง

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

จริง

คำสั่ง true จะคืนค่าศูนย์เป็นสถานะเอาต์พุตเสมอเพื่อบ่งชี้ความสำเร็จ

เท็จ

คำสั่ง false จะส่งคืนสถานะเอาต์พุตที่ไม่ใช่ศูนย์เสมอเพื่อบ่งชี้ถึงความล้มเหลว

$?

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

$จริง$เอคโค$? 0 $ เท็จ $ echo $? 1

เกรป

คำสั่ง grep ค้นหาสตริงที่ส่งผ่านเข้ามา ไฟล์ที่ระบุ:

$ cat users.txt ผู้ใช้: รหัสผ่านนักเรียน: 123 ผู้ใช้: รหัสผ่านครู: 321 $ grep "นักเรียน ` file1.txt ผู้ใช้: รหัสผ่านนักเรียน: 123

grep ยังสามารถรับหลายไฟล์และ การแสดงออกปกติเพื่อชี้แจงรูปแบบข้อความ

ประวัติศาสตร์

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

$ประวัติศาสตร์ | grep g++ 155 g++ file1.txt 159 g++ file2.txt

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

สิ่งนี้อาจเป็นเรื่องยากที่จะเข้าใจโดยไม่ต้องฝึกฝน ดังนั้นให้ทดลองด้วยตัวเองด้วยคำสั่ง ls , history , ps (อธิบายไว้ด้านล่าง) เพื่อเปลี่ยนเส้นทางเอาต์พุตไปที่ grep , sed หรือน้อยกว่า เป็นต้น

ส่งออก

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

$ ส่งออกชื่อ = นักเรียน

ปล

คำสั่ง PS แสดงข้อมูลเกี่ยวกับ กระบวนการทำงานอยู่.

$ ps PID TTY TIME CMD 35346 pts/2 00:00:00 ทุบตี

สี่องค์ประกอบจะถูกส่งออก:

• รหัสกระบวนการ (PID)
• ประเภทเทอร์มินัล (TTY)
• เวลาดำเนินการของกระบวนการ (TIME)
• ชื่อของคำสั่งที่เริ่มกระบวนการ (CMD)

โอเค

คำสั่ง awk ค้นหาและแทนที่ข้อความในไฟล์โดยใช้รูปแบบที่กำหนด: awk "รูปแบบ (การกระทำ)" test.txt

ตกลง

คำสั่ง wget ดาวน์โหลดไฟล์จากอินเทอร์เน็ตและวางไว้ในไดเร็กทอรีปัจจุบัน

$ wget https://github.com/mikeizbicki/ucr-cs100

nc

ปิง

คำสั่ง ping ทดสอบการเชื่อมต่อเครือข่าย

$ ping google.com PING google.com (74.125.224.34) ข้อมูล 56 (84) ไบต์ 64 ไบต์จาก lax17s01-in-f2.1e100.net (74.125.224.34): icmp_req=1 ttl=57 time=7.82 ms --- สถิติการ ping ของ google.com --- ส่ง 1 แพ็กเก็ต, 1 ได้รับ, สูญเสียแพ็กเก็ต 0% เวลา 8ms rtt ขั้นต่ำ/เฉลี่ย/สูงสุด/mdev = 7.794/8.422/10.792/0.699 ms

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

คอมไพล์

ตัวแปรสภาพแวดล้อม

ตัวแปรสภาพแวดล้อมเป็นตัวแปรที่มีชื่อซึ่งมีค่าที่ใช้โดยแอปพลิเคชันหนึ่งรายการขึ้นไป

ตัวแปร PATH ประกอบด้วยรายการไดเร็กทอรีที่ระบบค้นหาไฟล์ปฏิบัติการ

ตัวแปร HOME มีเส้นทางไปยังโฮมไดเร็กทอรีของผู้ใช้ปัจจุบัน

ขั้วต่อ

ตัวเชื่อมต่อช่วยให้คุณสามารถรันหลายคำสั่งพร้อมกันได้

$ true && echo สวัสดี สวัสดี $ false || echo สวัสดี สวัสดี $ echo สวัสดี ; ls สวัสดี test.txt file1.txt file2.txt

สายพานลำเลียง

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

$ ls -l | ศีรษะ

การเปลี่ยนเส้นทาง I/O

การเปลี่ยนเส้นทางเอาต์พุต

สัญลักษณ์ > และ >> ใช้สำหรับการเปลี่ยนทิศทางเอาต์พุตมาตรฐาน

ตัวอย่างเช่น โค้ดนี้จะไปป์ ls เอาต์พุตไปที่ไฟล์ แทนที่จะไปที่หน้าจอ:

$ ls > files.txt $ cat files.txt file1.cpp ตัวอย่าง.txt

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

การเปลี่ยนเส้นทางอินพุต

สำหรับการเปลี่ยนทิศทางเอาต์พุตมาตรฐาน จะใช้สัญลักษณ์< . В следующем примере sort берет входные данные из файла, а не с клавиатуры:

$ cat files.txt c b $ เรียงลำดับ< files.txt b c

คำสั่ง sort จะพิมพ์เนื้อหาของไฟล์ไปที่หน้าจอเนื่องจากเราไม่ได้เปลี่ยนเส้นทางเอาต์พุต ซึ่งสามารถทำได้เช่นนี้:

$เรียงลำดับ< files.txt >files_sorted.txt

การเปลี่ยนเส้นทางขั้นสูง

การเพิ่ม & to > ผลลัพธ์ในการเปลี่ยนเส้นทางเช่น กระแสมาตรฐานเอาต์พุตและการไหลของข้อผิดพลาด ตัวอย่างเช่น ไฟล์ test.cpp จะส่งออกบรรทัด stdout ไปที่ cout และบรรทัด stderr ไปที่ cerr

$ g++ test.cpp $ ./a.out >& test.txt $ cat test.txt stdout stderr

หากคุณต้องการส่งออกเฉพาะ ตัวอธิบายไฟล์คุณสามารถกำหนดหมายเลขให้กับ > ได้

ชื่อ	คำอธิบาย	คำอธิบาย
มาตรฐาน	0	อินพุตมาตรฐาน
มาตรฐาน	1	เอาต์พุตมาตรฐาน
stderr	2	เอาต์พุตข้อผิดพลาดมาตรฐาน

ตัวอย่างเช่น หากต้องการเปลี่ยนเส้นทาง stderr ไปที่ test.txt คุณจะต้องดำเนินการดังต่อไปนี้:

$ g++ test.cpp $ ./a.out 2> test.txt stdout $ cat test.txt stderr

สิทธิ์การเข้าถึง

คำสั่ง ls -l แสดงข้อมูลจำนวนมากเกี่ยวกับการอนุญาตของแต่ละไฟล์:

โครโมด

คำสั่ง chmod เปลี่ยนการอนุญาตของไฟล์ ต่อไปนี้คือชุดค่าสถานะทั่วไปสำหรับการเปลี่ยนสิทธิ์ของผู้ใช้บางราย:

คุณสามารถเรียก chmod พร้อมคำอธิบายว่าต้องทำอย่างไรกับไฟล์ใดไฟล์หนึ่ง สัญลักษณ์ - หมายถึง การลบสิทธิ์ สัญลักษณ์ + หมายถึง การบวก ตัวอย่างต่อไปนี้จะทำให้เจ้าของและกลุ่มสามารถอ่านและเขียนไฟล์ได้:

$ chmod ug+rw test.txt $ ls -l test.txt -rw-rw ---- กลุ่มผู้ใช้ 1 กลุ่ม 1097374 26 มกราคม 2:48 test.txt

นอกจากนี้ chmod สามารถใช้กับเลขฐานแปดได้ โดยที่ 1 ได้รับอนุญาต และ 0 ไม่ใช่:

Rwx = 111 = 7 rw- = 110 = 6 r-x = 101 = 5 r-- = 100 = 4

คำสั่งถัดไปจะทำงานเหมือนกับคำสั่งก่อนหน้า

หลังจากอ่านบทความนี้แล้วคุณจะพบว่ามันคืออะไร ทุบตี(ล่ามคำสั่ง Linux มาตรฐาน) เรียนรู้วิธีใช้คำสั่งมาตรฐาน: LS, ซีพี, MV...เข้าใจวัตถุประสงค์ของ inodes ลิงก์แบบฮาร์ดและสัญลักษณ์ และอื่นๆ อีกมากมาย

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

รู้เบื้องต้นเกี่ยวกับทุบตี

เปลือก

หากคุณใช้ Linux คุณจะรู้ว่าหลังจากเข้าสู่ระบบคุณจะได้รับการต้อนรับจากพรอมต์คำสั่งล่าม ตัวอย่างเช่น:

\$

หากโหลดเชลล์กราฟิกหลังจากเข้าสู่ระบบแล้วเพื่อไปที่ล่ามคำสั่งคุณต้องเปิดเทอร์มินัลอีมูเลเตอร์ (gnome-terminal, xfce4-terminal, konsole, xterm, rxvt...) หรือสลับไปที่เทอร์มินัลเสมือนอันใดอันหนึ่ง โดยการคลิก Ctrl–Alt–F1หรือ Ctrl–Alt–F2ฯลฯ

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

คุณกำลังทุบตีอยู่ใช่ไหม?

คุณสามารถตรวจสอบว่า bash ทำงานอยู่หรือไม่โดยใช้คำสั่งต่อไปนี้:

\$ เสียงสะท้อน \$SHELL/bin/ทุบตี

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

\$ ทุบตี

ทุบตีคืออะไร

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

การใช้ "ซีดี"

มาเริ่มใช้ bash เพื่อนำทางระบบไฟล์กันดีกว่า ในการเริ่มต้น ให้พิมพ์คำสั่งต่อไปนี้:

$ ซีดี/

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

เส้นทาง

เพื่อหาว่าอยู่ที่ไหน ระบบไฟล์ขณะนี้คุณอยู่ในประเภท (ไดเร็กทอรีการทำงานปัจจุบัน):

\$ นโยบายความเป็นส่วนตัว /

ในตัวอย่างข้างต้น / - อาร์กิวเมนต์คำสั่ง ซีดี- เรียกว่า เส้นทาง- นี่คือตำแหน่งบนระบบไฟล์ที่เราต้องการย้าย ในกรณีนี้ / - เส้นทางที่แน่นอนซึ่งหมายความว่าเส้นทางนั้นสัมพันธ์กับไดเรกทอรีราก

เส้นทางที่แน่นอน

นี่คือตัวอย่างบางส่วนของเส้นทางที่แน่นอน

/dev /usr /usr/bin /usr/local/bin

ดังที่คุณอาจสังเกตเห็นแล้วว่าเส้นทางเหล่านี้มีจุดเริ่มต้นเหมือนกัน / - โดยการระบุพาธ /usr/local/bin เป็นอาร์กิวเมนต์ของคำสั่ง ซีดีเราบอกให้เธอไปที่ไดเร็กทอรีรูท / จากนั้นไปที่ไดเร็กทอรี usr จากนั้นไปที่ local และ bin เส้นทางที่แน่นอนเริ่มต้นด้วยเสมอ /

เส้นทางสัมพัทธ์

เส้นทางประเภทที่สองเรียกว่าญาติ ทุบตี, ทีม ซีดีและคำสั่งอื่นๆ นับเส้นทางเหล่านี้สัมพันธ์กับไดเร็กทอรีปัจจุบัน เส้นทางสัมพัทธ์ไม่เคยเริ่มต้นด้วย / - เช่น ถ้าเราอยู่ใน /usr

\$ ซีดี /usr

จากนั้นเราสามารถไปที่ /usr/local/bin โดยใช้เส้นทางสัมพัทธ์

\$ ซีดีท้องถิ่น/bin \$ นโยบายความเป็นส่วนตัว/usr/local/bin

การใช้ ".."

เส้นทางสัมพัทธ์สามารถมีไดเร็กทอรีตั้งแต่หนึ่งไดเร็กทอรีขึ้นไป «..» - ".." หมายถึงไดเร็กทอรีหลักของไดเร็กทอรีการทำงานของเรา ตัวอย่าง:

\$ นโยบายความเป็นส่วนตัว/usr/local/bin\$ ซีดี.. \$ นโยบายความเป็นส่วนตัว/usr/local

อย่างที่คุณเห็นทีมงาน ซีดี..'ยกระดับเราไปสู่ระดับที่สูงขึ้น'

เพิ่มได้ .. สู่เส้นทางสัมพัทธ์ สิ่งนี้จะทำให้เราสามารถย้ายไปยังไดเร็กทอรีที่อยู่ในระดับเดียวกับไดเร็กทอรีที่เราอยู่ ตัวอย่าง:

\$ นโยบายความเป็นส่วนตัว/usr/local\$ ซีดี ../share \$ นโยบายความเป็นส่วนตัว/usr/share

ตัวอย่างการใช้เส้นทางสัมพัทธ์

เส้นทางสัมพัทธ์อาจค่อนข้างยุ่งยาก นี่คือตัวอย่างบางส่วน. ผลลัพธ์ของการดำเนินการคำสั่งไม่แสดง ลองพิจารณาว่าคุณจะใช้ไดเร็กทอรีใดโดยใช้ bash

\$ ซีดี/bin \$ ซีดี ../usr/share/zoneinfo \$ ซีดี /usr/X11R6/bin \$ ซีดี ../lib/X11 \$ ซีดี /usr/bin.cd \$ ซีดี ../bin/../bin

ไดเร็กทอรีการทำงาน "."

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

\$ ./myprog

ในตัวอย่างสุดท้าย myprog เป็นไฟล์ปฏิบัติการที่อยู่ในไดเร็กทอรีปัจจุบันที่จะเปิดตัวเพื่อดำเนินการ

cd และโฮมไดเร็กตอรี่ของผู้ใช้

เพื่อที่จะไป. โฮมไดเร็กทอรีคุณต้องโทรออก

\$ ซีดี

หากไม่มีข้อโต้แย้ง cd จะย้ายคุณไปยังโฮมไดเร็กตอรี่ของคุณ สำหรับ superuser โฮมไดเร็กตอรี่มักจะเป็น /root และสำหรับ ผู้ใช้ทั่วไป- /home/ชื่อผู้ใช้/. แต่ถ้าเราต้องการระบุไฟล์เฉพาะที่อยู่ในโฮมไดเร็กตอรี่ เช่นเป็นอาร์กิวเมนต์ของโปรแกรม 'มายโปรก'- คุณสามารถเขียน:

\$ ./myprog /home/user/myfile.txt

อย่างไรก็ตาม การใช้เส้นทางที่แน่นอนไปยังไฟล์นั้นไม่สะดวกเสมอไป การดำเนินการเดียวกันสามารถทำได้โดยใช้ ~ –ตัวหนอน:

\$ ./myprog ~/myfile.txt

~ - ชื่อพิเศษที่ชี้ไปยังโฮมไดเร็กตอรี่ของผู้ใช้ใน bash

โฮมไดเร็กทอรีของผู้ใช้รายอื่น

แต่ถ้าเราจำเป็นต้องชี้ไปที่ไฟล์ในโฮมไดเร็กตอรี่ของผู้ใช้รายอื่นล่ะ? ในการดำเนินการนี้หลังจากเครื่องหมายตัวหนอนคุณจะต้องระบุชื่อของผู้ใช้รายนี้ ตัวอย่างเช่น หากต้องการชี้ไปที่ไฟล์ fredsfile.txt ที่อยู่ในโฮมไดเร็กทอรีของผู้ใช้ fred:

\$ ./myprog ~fred/fredsfile.txt

คำสั่งลินุกซ์

ความรู้เบื้องต้นเกี่ยวกับ ls

คุณคงจะคุ้นเคยกับทีมนี้อยู่แล้ว LSซึ่งเรียกโดยไม่มีข้อโต้แย้ง แสดงรายการไฟล์ที่จัดเก็บไว้ในไดเร็กทอรีการทำงาน:

\$ ซีดี /usr \$ LS X11R6 doc i686-pc-linux-gnu lib man sbin ssl bin gentoo-x86 รวมถึง libexec portage share tmp distfiles ข้อมูล i686-linux local portage.old src

หากคุณระบุตัวเลือก -กคุณจะสามารถดูไฟล์ทั้งหมดรวมถึงไฟล์ที่ซ่อนอยู่ (ชื่อขึ้นต้นด้วยจุด)

\$ ลส -ก- bin gentoo-x86 รวม libexec portage แบ่งปัน tmp .. distfiles ข้อมูล i686-linux local portage.old src X11R6 doc i686-pc-linux-gnu lib man sbin ssl

รายการไดเรกทอรีโดยละเอียด

หลังจากออกคำสั่งนั้นเอง LSสามารถระบุไฟล์หรือไดเร็กทอรีตั้งแต่หนึ่งไฟล์ขึ้นไปเป็นอาร์กิวเมนต์ได้ หากคุณระบุชื่อไฟล์คำสั่ง LSจะแสดงเฉพาะข้อมูลเกี่ยวกับไฟล์นี้เท่านั้น และถ้าคุณระบุชื่อไดเร็กทอรี LSจะแสดงเนื้อหาทั้งหมด ตัวเลือก '-l'ทีม LSจะมีประโยชน์มากหากคุณต้องการทราบมากกว่าชื่อไฟล์ รายละเอียดข้อมูลเกี่ยวกับพวกเขา (สิทธิ์ในไฟล์, ชื่อเจ้าของ, เวลาที่แก้ไขไฟล์ครั้งล่าสุดและขนาดของไฟล์)

ตัวอย่างต่อไปนี้แสดงการใช้ตัวเลือก '-l'เพื่อแสดงข้อมูลเกี่ยวกับไฟล์ที่จัดเก็บไว้ในไดเร็กทอรี /usr

\$ ls -l /usr drwxr-xr-x 7 รูทรูท 168 24 พ.ย. 14:02 X11R6 รูท drwxr-xr-x 2 รูท 14576 27 ธ.ค. 08:56 bin drwxr-xr-x 2 รูทรูท 8856 26 ธ.ค. 12:47 distfiles lrwxrwxrwx 1 รูทรูท 9 22 ธ.ค. 20:57 น. doc -> share / doc drwxr-xr-x 62 รูทรูท 1856 27 ธ.ค. 15:54 gentoo-x86 drwxr-xr-x 4 รูทรูท 152 12 ธ.ค. 23:10 i686-linux drwxr-xr-x 4 รูทรูท 96 พ.ย. 24 เวลา 13:17 น. i686-pc-linux-gnu drwxr-xr-x 54 รูทรูท 5992 24 ธ.ค. 22:30 น. รวม lrwxrwxrwx 1 รูทรูท 10 ธ.ค. 22 20:57 ข้อมูล -> แบ่งปัน / ข้อมูล drwxr-xr -x 28 รูท 13552 26 ธันวาคม 00:31 lib drwxr-xr-x 3 รูท 72 25 พ.ย. 00:34 libexec drwxr-xr-x 8 รูท 240 22 ธ.ค. 20:57 โลคัล lrwxrwxrwx 1 รูทรูต 9 22 ธ.ค. 20 :57 man -> share/man lrwxrwxrwx 1 root root 11 ธันวาคม 8 07:59 portage -> gentoo-x86/ drwxr-xr-x 60 root root 1864 8 ธันวาคม 07:55 portage.old drwxr-xr-x 3 root root 3096 22 ธันวาคม 20:57 sbin drwxr-xr-x 46 รูทรูท 1144 24 ธันวาคม 15:32 แบ่งปัน drwxr-xr-x 8 รูทรูท 328 26 ธันวาคม 00:07 src drwxr-xr-x 6 รูทรูท 176 24 พ.ย. 14: 25 ssl lrwxrwxrwx 1 รูทรูท 10 ธันวาคม 22 เวลา 20:57 น. tmp -> ../var/tmp

คอลัมน์แรกแสดงข้อมูลเกี่ยวกับสิทธิ์การเข้าถึงของแต่ละไฟล์ในรายการ (อีกไม่นานฉันจะอธิบายว่าตัวอักษรใดหมายถึงอะไร) คอลัมน์ถัดไปจะแสดงจำนวนลิงก์ไปยังแต่ละองค์ประกอบของรายการ คอลัมน์ที่สามและสี่คือเจ้าของและกลุ่มของไฟล์ตามลำดับ คอลัมน์ที่ห้าคือขนาด ครั้งที่หกคือเวลาที่ไฟล์ถูกแก้ไขครั้งล่าสุด ('เวลาที่แก้ไขล่าสุด' หรือ mtime) คอลัมน์สุดท้ายคือชื่อของไฟล์หรือไดเร็กทอรี (หากเป็นลิงก์ ให้อยู่หลังเครื่องหมาย ' –> ' ย่อมาจากชื่อของวัตถุที่อ้างถึง)

วิธีดูเฉพาะไดเร็กทอรี

บางครั้งจำเป็นต้องดูข้อมูลเฉพาะเกี่ยวกับไดเร็กทอรีเท่านั้น ไม่ใช่เกี่ยวกับเนื้อหาทั้งหมด ตัวเลือกนี้จะช่วยให้คุณรับมือกับงานนี้ได้ '-d'ซึ่งบอกให้คำสั่งแสดงข้อมูลเกี่ยวกับไดเร็กทอรีเท่านั้น ตัวอย่าง:

\$ ls -dl /usr /usr/bin /usr/X11R6/bin ../แชร์ drwxr-xr-x 4 รูท 96 ธ.ค. 18 18:17 ../share drwxr-xr-x 17 รูท 576 24 ธ.ค. 09:03 /usr drwxr-xr-x 2 รูท 3192 26 ธ.ค. 12:52 /usr /X11R6/bin drwxr-xr-x 2 รูทรูท 14576 27 ธ.ค. 08:56 /usr/bin

รายการแบบเรียกซ้ำและข้อมูลไอโหนด

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

และสุดท้ายก็ทางเลือก '-ฉัน'ใช้ในการพิมพ์ inodes ของแต่ละอ็อบเจ็กต์ระบบไฟล์

\$ ls -i /usr 1409 X11R6 314258 i686-linux 43090 libexec 13394 sbin 1417 bin 1513 i686-pc-linux-gnu 5120 local 13408 แบ่งปัน 8316 distfiles 1517 รวม 776 man 23779 src 43 doc 1386 ข้อมูล 92 พอร์ต 36737 ssl 70744 gentoo-x86 1585 lib 5132 portage.old 784 ตันต่อนาที

ไอโหนดคืออะไร?

แต่ละอ็อบเจ็กต์ระบบไฟล์ (ไฟล์, ไดเร็กทอรี...) มีหมายเลขเฉพาะของตัวเองที่เรียกว่า ไอโหนด(หมายเลขไอโหนด) ข้อมูลนี้อาจดูเหมือนไม่มีนัยสำคัญ แต่การทำความเข้าใจฟังก์ชันของ inode จะช่วยให้คุณเข้าใจการทำงานของระบบไฟล์ต่างๆ ยกตัวอย่างมาดูกัน «.» และ «..» เหมือนลิงค์ที่ปรากฏในแต่ละไดเร็กทอรี เพื่อทำความเข้าใจว่าไดเร็กทอรีคืออะไร «..» ค้นหา inode ของไดเร็กทอรี /use/local

\$ ls -id /usr/local 5120 /usr/local

ดังที่เราเห็น inode ของไดเร็กทอรี /usr/local คือ 5120 ตอนนี้เรามาดูกันว่า inode ของไดเร็กทอรี /usr/local/bin/.. มีอะไรบ้าง:

\$ ls -id /usr/local/bin/.. 5120 /usr/local/bin/..

ปรากฎว่า inodes ของไดเร็กทอรี /usr/local และ /usr/local/bin/.. เหมือนกัน! ซึ่งหมายความว่า inode 5120 ถูกอ้างอิงด้วยสองชื่อ: /usr/local และ /usr/local/bin/.. นั่นคือสองชื่อที่แตกต่างกันสำหรับไดเร็กทอรีเดียวกัน แต่ละไอโหนดชี้ไปยังตำแหน่งเฉพาะบนดิสก์

แต่ละ inode สามารถมีชื่ออ็อบเจ็กต์ระบบไฟล์ได้หลายชื่อที่เชื่อมโยงอยู่ จำนวนไฟล์ 'คำพ้องความหมาย' (ออบเจ็กต์ระบบไฟล์ที่อ้างอิงถึงไอโหนดเดียวกัน) จะแสดงเป็นตัวเลขในคอลัมน์ที่สองของเอาต์พุตคำสั่ง ' ลส -ล‘.

\$ ls -dl /usr/local drwxr-xr-x 8 รูท 240 22 ธันวาคม 20:57 /usr/local

ตัวอย่างนี้แสดง (คอลัมน์ที่สอง) ว่าไดเร็กทอรี /usr/local ถูกอ้างอิงโดยอ็อบเจ็กต์ระบบไฟล์ที่แตกต่างกัน 8 รายการ นี่คือชื่อของพวกเขา:

/usr/local /usr/local/. /usr/local/bin/.. /usr/local/games/.. /usr/local/lib/.. /usr/local/sbin/.. /usr/local/share/.. /usr/local/ สอาร์/..

mkdir

มาดูคำสั่งกัน mkdir- มันถูกใช้เพื่อสร้างไดเร็กทอรีใหม่ ตัวอย่างต่อไปนี้สาธิตการสร้างไดเร็กทอรีใหม่สามไดเร็กทอรี (tic, tac, toe) ในไดเร็กทอรี /tmp

\$ ซีดี /tmp $ mkdir ทิก แทค โท

คำสั่งเริ่มต้น mkdirไม่สามารถสร้างโครงสร้างไดเร็กทอรีแบบซ้อนได้ ดังนั้น หากคุณต้องการสร้างไดเรกทอรีที่ซ้อนกันหลายรายการ ( มหัศจรรย์) จากนั้นคุณจะต้องเรียกใช้คำสั่งนี้สามครั้งตามลำดับ:

\$ mkdir วอน/เดอร์/ฟูล mkdir: ไม่สามารถสร้างไดเรกทอรี "won/der/ful": ไม่มีไฟล์หรือไดเรกทอรีดังกล่าว \$ mkdir ชนะแล้ว \$ mkdir วอน/เดอร์ \$ mkdir วอน/เดอร์/ฟูล

คุณสามารถทำให้การดำเนินการนี้ง่ายขึ้นได้โดยการเพิ่มตัวเลือก '-พี'ไปที่คำสั่ง mkdir ตัวเลือกนี้ช่วยให้คุณสร้างโครงสร้างไดเร็กทอรีแบบซ้อนได้:

\$ mkdir -p ง่าย / as / pie

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับความสามารถของยูทิลิตี้นี้ โปรดอ่านวิธีใช้ซึ่งเรียกใช้โดยคำสั่ง แมน mkdir- มีความช่วยเหลือสำหรับคำสั่งเกือบทั้งหมดในคู่มือเล่มนี้ (เช่น ผู้ชาย LS), ยกเว้น ซีดี, เพราะ มันถูกสร้างขึ้นใน bash (สำหรับคำสั่งดังกล่าว help จะถูกเรียกดังนี้: ช่วยซีดี)

สัมผัส

เรามาศึกษาคำสั่งกันดีกว่า ซีพีและ MVใช้ในการคัดลอก เปลี่ยนชื่อ และย้ายไฟล์และไดเร็กทอรี แต่ก่อนหน้านั้น มาสร้างไฟล์ว่างในไดเร็กทอรี /tmp โดยใช้คำสั่ง สัมผัส:

\$ ซีดี /tmp \$ แตะคัดลอก

ทีม สัมผัสเวลาอัปเดต การเข้าถึงครั้งสุดท้ายไปยังไฟล์ (คอลัมน์ที่หกของเอาต์พุตคำสั่ง ลส -ล) หากมีอยู่แล้วหรือสร้างไฟล์ว่างใหม่หากยังไม่มี หลังจากการดำเนินการนี้เราควรจะมีไฟล์เปล่า /tmp/copyme.

เสียงสะท้อน

ตอนนี้เรามีไฟล์ว่างแล้ว มาเขียนมันกันดีกว่า สตริงข้อความโดยใช้คำสั่ง เสียงสะท้อนซึ่งส่งออกอาร์กิวเมนต์ที่ส่งไปให้ อุปกรณ์มาตรฐานเอาต์พุต (เทอร์มินัลข้อความในกรณีของเรา)

\$ สะท้อน "ไฟล์แรก"ไฟล์แรก

หากต้องการเขียนบรรทัดไปยังไฟล์ของเรา ให้เปลี่ยนทิศทางเอาต์พุตคำสั่งไปที่ไฟล์นั้น เสียงสะท้อน:

\$ เสียงสะท้อน "firstfile"> copyme

เข้าสู่ระบบ > (เพิ่มเติม) บอกให้เชลล์เปลี่ยนเส้นทางเอาต์พุตของคำสั่งทางด้านซ้ายไปยังไฟล์ที่มีชื่ออยู่ทางด้านขวา หากไม่มีไฟล์ชื่อเดียวกัน ไฟล์นั้นจะถูกสร้างขึ้นโดยอัตโนมัติ และหากไฟล์ดังกล่าวมีอยู่แล้วไฟล์นั้นจะถูกเขียนทับ (เนื้อหาทั้งหมดจะถูกลบก่อนที่จะเขียนบรรทัดของเรา) ทีม 'ฉัน - ฉัน'จะแสดงว่าขนาดไฟล์ของเราตอนนี้คือ 10 ไบต์ - เก้าไบต์ถูกครอบครองโดยคำว่า 'firstfile' และหนึ่งไบต์โดยอักขระป้อนบรรทัด

\$ ls -l คัดลอก-rw-r ---r-- 1 รูทรูท 10 28 ธันวาคม 14:13 copyme

แมวและซีพี

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

\$ สำเนาแมวไฟล์แรก

ตอนนี้เราสามารถเริ่มวิเคราะห์การทำงานพื้นฐานของคำสั่งได้แล้ว ซีพี- คำสั่งนี้รับสองอาร์กิวเมนต์ อันแรกคือชื่อของไฟล์ที่มีอยู่ ('copyme') ส่วนที่สองคือชื่อของสำเนาใหม่ที่เราต้องการสร้าง ('copiedme')

\$ cp copyme คัดลอกฉัน

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

\$ ls -i copyme คัดลอกฉัน 648284 คัดลอกฉัน 650704 คัดลอกฉัน

MV

ตอนนี้เรามาใช้คำสั่งกัน MVเพื่อเปลี่ยนชื่อไฟล์ (“copyedme” -> “movedme”) หมายเลขไอโหนดจะไม่เปลี่ยนแปลงหลังจากการดำเนินการนี้ เฉพาะชื่อไฟล์เท่านั้นที่เปลี่ยนแปลง

\$ mv คัดลอกฉัน ย้ายฉัน \$ ls -ฉันย้ายฉัน 648284 ย้ายฉัน

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

ทีม MVช่วยให้คุณไม่เพียงเปลี่ยนชื่อไฟล์ แต่ยังย้ายไฟล์เหล่านั้นด้วย เช่น การย้ายไฟล์ /var/tmp/myfile.txtไปยังไดเร็กทอรี /home/userคุณต้องให้คำสั่ง:

\$ mv /var/tmp/myfile.txt /home/user.mv

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

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

หากต้องการย้ายหลายไฟล์พร้อมกันไปยังไดเร็กทอรีเดียว คุณต้องเขียน:

\$ mv /var/tmp/myfile1.txt /var/tmp/myfile2.txt /home/ผู้ใช้ \$ mv -t /home/user /var/tmp/myfile1.txt /var/tmp/myfile2.txt

หากคุณเพิ่มตัวเลือก '-วี'รายงานการดำเนินการที่ดำเนินการจะแสดงบนหน้าจอ:

\$ mv -vt /home/ผู้ใช้ /var/tmp/myfile1.txt /var/tmp/myfile2.txt"/var/tmp/myfile1.txt" -> "/home/user/myfile1.txt" "/var/tmp/myfile2.txt" -> "/home/user/myfile2.txt"

บนระบบปฏิบัติการ Linux ส่วนใหญ่ bash จะเป็นล่ามบรรทัดคำสั่งเริ่มต้น หากต้องการกำหนดล่ามปัจจุบัน ให้ป้อนคำสั่งต่อไปนี้:

$ ก้อง $SHELL
/bin/ทุบตี

ตัวอย่างนี้ใช้ล่ามบรรทัดคำสั่ง ทุบตี. มีล่ามคำสั่งอื่นๆ อีกมากมาย หากต้องการเปิดใช้งานล่ามอื่น คุณสามารถป้อนชื่อของมันที่บรรทัดคำสั่ง (ksh, tcsh, csh, sh, bash ฯลฯ)

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

การตรวจสอบความพร้อมของสินค้าที่คุณสนใจล่ามบรรทัดคำสั่ง

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

มีสาเหตุหลายประการในการเลือกกระสุนสำรอง

• มีประสบการณ์การทำงานบนระบบ UNIX System V (หลายระบบใช้ ksh เป็นค่าเริ่มต้น) หรือ Sun Microsystems และระบบ Berkeley UNIX อื่นๆ (ซึ่งมักใช้ csh) ในกรณีนี้การใช้ล่ามเหล่านี้บรรทัดคำสั่งจะสะดวกยิ่งขึ้น
• ความจำเป็นในการเรียกใช้สคริปต์ที่สร้างขึ้นสำหรับล่ามคำสั่งเฉพาะ
• ความสามารถของล่ามคำสั่งทางเลือกอาจจะดีกว่า ตัวอย่างเช่น สมาชิกคนหนึ่งของกลุ่มผู้ใช้ Linux ชอบที่จะใช้ ksh เพราะเขาไม่พอใจกับวิธีที่ bash สร้างนามแฝง

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

ใช้ Bash และ ch

ชื่อ bash เป็นตัวย่อสำหรับ Bourne Again SHell ตัวย่อนี้บ่งชี้ว่า bash สืบทอดล่าม Bourneshell (คำสั่ง sh) ซึ่งสร้างโดย Steve Bourne จาก AT&TBell Labs ไบรอัน ฟ็อกซ์ จาก Free มูลนิธิซอฟต์แวร์สร้าง bash โดยเป็นส่วนหนึ่งของโครงการ GNU ต่อมาการพัฒนาก็ตกไปอยู่ในมือของ Chet Ramey ที่ Case Western Reserve University

ล่าม bash มีคุณสมบัติที่พัฒนาขึ้นสำหรับล่าม sh และ ksh ในระหว่าง รุ่นก่อนหน้า UNIX รวมถึงคุณสมบัติหลายประการของล่าม csh

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

ตัวอย่างส่วนใหญ่ในเรื่องนี้บทความออกแบบมาเพื่อใช้ทุบตี

ล่าม bash สามารถทำงานในโหมดความเข้ากันได้ต่างๆ โดยจำลองพฤติกรรมของเชลล์อื่นๆ มันสามารถเลียนแบบพฤติกรรมของเชลล์เป้าหมาย (sh) หรือเชลล์ที่เป็นไปตามมาตรฐาน POSK (bash -โพซิกส์)

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

ระบบปฏิบัติการ Linux ที่ให้มาทั้งหมดใช้ตัวแปล bash เป็นค่าเริ่มต้น ยกเว้นระบบปฏิบัติการที่บูตมา สื่อที่ถอดออกได้ซึ่งใช้ตัวแปล ash เป็นค่าเริ่มต้น

การใช้ tcsh (และล่าม csh รุ่นก่อนหน้า)

ล่ามคำสั่ง tcsh เป็นการใช้งานโอเพ่นซอร์สของล่าม Cshell (csh) ล่าม csh ถูกสร้างขึ้นโดย Bill Joy และใช้เป็นค่าเริ่มต้นบนระบบ Berkeley UNIX เกือบทั้งหมด (ระบบดังกล่าวเผยแพร่โดย Sun Microsystems)

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

การใช้ล่ามเถ้า

Ash Interpreter เป็นเวอร์ชันน้ำหนักเบาของ Berkeley UNIX sh libre ไม่มีคุณสมบัติพื้นฐานมากมาย และไม่มีคุณสมบัติเช่น ประวัติคำสั่ง

Ash Interpreter เหมาะอย่างยิ่งสำหรับใช้ในระบบฝังตัวที่มีทรัพยากรระบบจำกัด บนระบบปฏิบัติการ FedoraCore 4 ตัวแปล ash จะมีลำดับความสำคัญที่เล็กกว่าตัวแปล bash

การใช้ zsh

ล่าม zsh เป็นอีกหนึ่งโคลนของล่าม sh เป็นไปตาม POSIX (เช่น bash) แต่มีคุณสมบัติอื่นๆ รวมถึงการตรวจสอบการสะกดคำและแนวทางที่แตกต่างในการแก้ไขบรรทัดคำสั่ง ล่าม zsh เป็นค่าเริ่มต้นในระบบปฏิบัติการยุคแรก ระบบแมคโอเอส X แต่เข้า ระบบที่ทันสมัยล่ามเริ่มต้นคือทุบตี

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

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

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

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

Linux เป็นระบบปฏิบัติการที่มีลักษณะคล้าย Unix เดิมที Linux ได้รับการพัฒนาโดย Linus Torvalds ที่มหาวิทยาลัยเฮลซิงกิ (ฟินแลนด์) โดยใช้ Minix ซึ่งเป็นระบบ UNIX ขนาดเล็กที่สร้างโดย Andry Tanenbaum การพัฒนาในช่วงต้น Linux กังวลเป็นหลักกับปัญหาการสลับงานโหมดป้องกันสำหรับ 80386 และ Linus "เริ่มคิดอย่างจริงจังเกี่ยวกับแนวคิดที่คลั่งไคล้ว่าจะทำให้ Minix ดีกว่าตัวมันเองได้อย่างไร"

เชลล์คำสั่งมีอยู่แล้วในระบบ UNIX มันคือ "เชลล์เป้าหมาย" (บอร์นเชลล์หรือเพียงแค่เชลล์) หลังจากนั้นไม่นาน ระบบ UNIX ก็ได้พัฒนา C เชลล์ ซึ่งใช้ไวยากรณ์ที่แตกต่างกัน ซึ่งค่อนข้างชวนให้นึกถึงไวยากรณ์ของภาษาการเขียนโปรแกรม C

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

อย่างไรก็ตาม ควรสังเกตว่า Linux OS ไม่ใช่ระบบ UNIX เนื่องจากโค้ดของมันถูกเขียนใหม่ทั้งหมด เริ่มแรกโดย Linus ต่อมาด้วยความช่วยเหลือจากโปรแกรมเมอร์ UNIX และผู้ที่ชื่นชอบจากอินเทอร์เน็ต ผู้ที่มีทักษะและความสามารถเพียงพอที่จะพัฒนา ระบบ.

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

นี่คือเชลล์ Linux ที่พบบ่อยที่สุด:

• บอร์นเชลล์ - บอร์นเชลล์ มาตรฐานสำหรับระบบที่คล้าย UNIX หลายระบบ;
• bash - เชลล์ Bourne Again, "เชลล์ Bourne ใหม่" (ใช้เป็นค่าเริ่มต้นบน Linux);
• csh - C เชลล์, เชลล์ C: ไวยากรณ์ของภาษาคำสั่งนั้นคล้ายกับไวยากรณ์ของภาษา C;
• tcsh - เชลล์ C เล็ก ๆ , เชลล์ C ขั้นต่ำ;
• pdksh - โดเมนสาธารณะ Korn เชลล์, Korn เชลล์สาธารณะ;
• sash - เชลล์แบบสแตนด์อโลนสามารถใช้ได้เมื่อไม่มีไลบรารีซอฟต์แวร์

รายการโปรแกรมเชลล์ทั้งหมดที่ติดตั้งบนระบบจะอยู่ในไฟล์ /etc/shells

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

หากต้องการแก้ไขไฟล์ /etc/passwd ใน Linux มีอยู่ ทีมพิเศษ vipw ซึ่งตรวจสอบความถูกต้องของการแก้ไข (คำสั่งมีให้เฉพาะผู้ดูแลระบบเท่านั้น)

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

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

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

2. การแยกวิเคราะห์บรรทัดคำสั่ง ฟังก์ชันทุบตีที่เลือก

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

1. ขยายนามแฝงสำหรับ โทรด่วนคำสั่งที่ใช้บ่อยที่สุด
2. ขยายอักขระเมตาหรือไวด์การ์ด (*, ?, [, ], ~, (, )) เพื่อค้นหาไฟล์โดยใช้รูปแบบชื่อ
3. ทดแทนตัวแปรที่เชลล์สามารถใช้ได้
4. เปลี่ยนเส้นทางเอาต์พุตของคำสั่งหนึ่งเป็นอินพุตไปยังคำสั่งอื่นโดยใช้ไปป์
5. ดำเนินการรวมคำสั่ง
6. ดำเนินการคำสั่งหากเป็นคำสั่งล่ามในตัว หรือเริ่มกระบวนการหากคำสั่งนั้นเป็นคำสั่งภายนอก
7. เปลี่ยนเส้นทาง อินพุตมาตรฐาน/บทสรุป.

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

2.1. ชื่อเล่น

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

ตัวอย่างเช่น:

$export HELLO="Hello from Environmental! " # space must be Escape with quotes

ตัวแปรสภาพแวดล้อม

สภาพแวดล้อมคือชุดของตัวแปรที่มีค่าที่สามารถเปลี่ยนพฤติกรรมของเชลล์ได้

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

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

ไฟล์การกำหนดค่า	คำอธิบาย
/etc/profile	กำหนดตัวแปรสภาพแวดล้อมสำหรับผู้ใช้ทั้งหมดบนระบบ ไฟล์นี้จะดำเนินการเมื่อเข้าสู่ระบบครั้งแรกและมีตัวแปรสภาพแวดล้อมพื้นฐาน เช่น ตัวแปรค้นหาตำแหน่งคำสั่ง PATH ตัวแปรชื่อโฮสต์ HOSTNAME และตัวแปรขนาดประวัติคำสั่ง HISTSIZE นอกจากนี้ ไฟล์นี้สร้างตัวแปรสภาพแวดล้อมเพิ่มเติมจากไฟล์คอนฟิกูเรชันที่อยู่ในไดเร็กทอรี /etc/profile.d
/etc/bashrc	ดำเนินการสำหรับผู้ใช้ทุกคนทุกครั้งที่เริ่ม bash shell ไฟล์นี้กำหนดค่าของตัวแปร PS1 รวมถึงนามแฝงของคำสั่งเพิ่มเติม นามแฝงคือชื่อคำสั่งหรือลำดับของคำสั่งที่กำหนดให้สั้นลงและกำหนดโดยพลการ ซึ่งช่วยให้คุณสามารถดำเนินการลำดับคำสั่งที่ซับซ้อนได้โดยไม่ต้องป้อนคำสั่งจากแป้นพิมพ์ แต่โดยการเรียกคำสั่งเหล่านั้นโดยการเรียกนามแฝงที่เกี่ยวข้อง ตัวแปรที่กำหนดในไฟล์นี้สามารถกำหนดใหม่ได้โดยไฟล์ที่ผู้ใช้กำหนดที่คล้ายกัน -/.bashrc ซึ่งมีลำดับความสำคัญสูงกว่า
-/.bashprofile	ใช้เป็นไฟล์ที่มีการตั้งค่าผู้ใช้แต่ละราย ดำเนินการเพียงครั้งเดียวเมื่อผู้ใช้เข้าสู่ระบบ นอกจากนี้ ไฟล์นี้ยังรันไฟล์ -/.bashrc
~/.bashrc	ไฟล์นี้มีตัวแปรสภาพแวดล้อมและนามแฝง ผู้ใช้ติดตั้งแล้ว- จะดำเนินการทุกครั้งที่ผู้ใช้เข้าสู่ระบบหรือเมื่อมีการเปิดเซสชันทุบตีใหม่ ไฟล์นี้เหมาะที่สุดสำหรับการกำหนดตัวแปรผู้ใช้และนามแฝง
~/.bash_logout	ไฟล์นี้จะถูกดำเนินการทุกครั้งที่คุณออกจากระบบหรือสิ้นสุดเซสชันล่าสุดของล่ามทุบตี ตามค่าเริ่มต้น ไฟล์นี้มีคำสั่งให้ล้างหน้าจอเทอร์มินัล
/etc/inputrc	ไฟล์นี้มีคำอธิบายการตีความการใช้คีย์ผสมต่างๆ และยังมีคีย์ผสมพิเศษ การกดที่ทำให้เกิดการดำเนินการตามคำสั่งที่ระบุ

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

ส่งออก AB=/usr/dog/contagious/ringbearer/grind

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

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

หากต้องการเปลี่ยนไฟล์คอนฟิกูเรชัน /etc/profile และ /etc/bashrc คุณต้องเป็น root

ผู้ใช้ทั่วไปสามารถแก้ไขไฟล์คอนฟิกูเรชัน ~/.bash_profile, ~/.bashrc และ ~/.bash_Iogout ที่อยู่ในโฮมไดเร็กทอรีของตนได้ ไฟล์การกำหนดค่าเหล่านี้สามารถกำหนดค่าเพื่อตั้งค่าตัวแปรสภาพแวดล้อมของคุณโดยใช้คำสั่งส่งออก และสามารถใช้ได้ในเซสชันใดก็ได้

ตัวแปรสภาพแวดล้อมที่เปลี่ยนแปลงบ่อยที่สุดตัวหนึ่งคือตัวแปร PATH คุณยังสามารถแทนที่หรือเสริมตัวแปรสภาพแวดล้อม PATH ได้ด้วย ไฟล์การกำหนดค่า~/.bashrc.

ในตัวอย่างนี้ ตัวแปร PATH จะมีค่าปัจจุบันบวกโฮมไดเร็กตอรี่เป็นพาธการค้นหาสำหรับไฟล์ที่ปฏิบัติการได้

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

ตัวแปรสภาพแวดล้อมของเชลล์ที่พบบ่อยที่สุดคือ:

• ทุบตี - ประกอบด้วย เส้นทางเต็มถึง คำสั่งทุบตี(โดยทั่วไปค่าของตัวแปรนี้คือ /bin/bash)
• BASH_VERSION - หมายเลขเวอร์ชัน Bash
• DIRSTACK - อาร์เรย์ที่มีค่าสแต็กไดเร็กทอรีปัจจุบัน
• EDITOR คือโปรแกรมแก้ไขข้อความเริ่มต้น
• EUID - ตัวระบุที่มีประสิทธิภาพที่เป็นตัวเลขของผู้ใช้ปัจจุบัน
• FUNCNAME - ชื่อ ฟังก์ชั่นปัจจุบันในสคริปต์
• GROUPS - อาร์เรย์ที่มีรายการกลุ่มที่ผู้ใช้ปัจจุบันเป็นสมาชิก
• HISTFILE - ตำแหน่งของไฟล์ประวัติคำสั่ง โดยทั่วไป ประวัติคำสั่งจะถูกจัดเก็บไว้ในไฟล์ ~/.bash_history
• HISTFILESIZE - จำนวนบรรทัดคำสั่งที่สามารถจัดเก็บไว้ในไฟล์ประวัติ หลังจากถึงจำนวนนี้แล้ว บรรทัดคำสั่งใหม่จะถูกป้อนลงในประวัติโดยการลบบรรทัดคำสั่งที่เก่าที่สุด ตามค่าเริ่มต้น ขนาดของรายการคำสั่งที่ใช้ล่าสุดคือ 1,000 บรรทัด
• HOME - โฮมไดเร็กตอรี่ของผู้ใช้
• ชื่อโฮสต์ - ชื่อ ของคอมพิวเตอร์เครื่องนี้(โหนด)
• HOSTTYPE - ประเภทคอมพิวเตอร์
• LANG - ภาษาเริ่มต้นปัจจุบัน
• LC_CTYPE เป็นตัวแปรภายในที่กำหนดการเข้ารหัสอักขระ
• MAIL - ตำแหน่งไฟล์กล่องจดหมาย อีเมลผู้ใช้ โดยทั่วไป ไฟล์นี้จะอยู่ในไดเร็กทอรี /var/spool/mail ซึ่งมีชื่อเหมือนกับชื่อล็อกอินของผู้ใช้
• MAILCHECK - ช่วงเวลาเป็นนาทีระหว่างการตรวจสอบเมล
• OLDPWD - ไดเร็กทอรีที่เป็นปัจจุบันจนกระทั่งไดเร็กทอรีถูกแก้ไขครั้งล่าสุด
• OSTYPE - ระบบปฏิบัติการปัจจุบัน
• PATH - รายการไดเร็กทอรีที่คั่นด้วยโคลอนเพื่อค้นหาไฟล์ปฏิบัติการ ลำดับการค้นหาชื่อไดเร็กทอรีมีความสำคัญอย่างยิ่ง เมื่อดำเนินการคำสั่ง ไดเร็กทอรีที่อยู่ในตัวแปรนี้จะถูกตรวจสอบตามลำดับจากซ้ายไปขวา ดังนั้น เมื่อดำเนินการคำสั่ง foo ที่อยู่ในไดเร็กทอรี /bin และ /usr/bin คำสั่งที่อยู่ในไดเร็กทอรี /bin จะถูกดำเนินการ หากต้องการรันคำสั่ง foo ที่อยู่ในไดเร็กทอรี /usr/bin ในสถานการณ์ที่คล้ายกัน คุณต้องระบุพาธแบบเต็มไปยังคำสั่งนี้ หรือเปลี่ยนลำดับของชื่อไดเร็กทอรีในตัวแปรสภาพแวดล้อม PATH ต้องระบุไดเร็กทอรีการค้นหาปัจจุบันอย่างชัดเจน ("."); เชลล์ไม่ค้นหาไดเร็กทอรีปัจจุบันตามค่าเริ่มต้น การค้นหาโปรแกรมเริ่มต้นในไดเร็กทอรีปัจจุบันอาจเป็นอันตรายได้เนื่องจากมีความเป็นไปได้ที่จะเกิดการดำเนินการโดยไม่ได้ตั้งใจ โปรแกรมอันตรายดังนั้นตัวแปร PATH มักจะถูกเตรียมใช้งานโดยไม่มี "." หากต้องการเพิ่มเส้นทางไปยังคำสั่งของคุณเองหรือเชลล์สคริปต์ไปยังตัวแปร PATH คุณควรวางไว้ในไดเร็กทอรีย่อย /bin ของโฮมไดเร็กตอรี่ของคุณ ซึ่งจะถูกเพิ่มลงในตัวแปร PATH โดยอัตโนมัติ ไม่ทั้งหมด คำสั่งปฏิบัติการตั้งอยู่ในไดเร็กทอรีที่แสดงอยู่ในตัวแปรสภาพแวดล้อม PATH คำสั่งบางคำสั่งถูกสร้างขึ้นโดยตรงในเชลล์ คำสั่งอื่นๆ สามารถกำหนดใหม่ได้โดยใช้นามแฝง โดยอนุญาตให้แทนที่คำสั่งที่มีพารามิเตอร์ที่มีความซับซ้อนแทบใดๆ (ในแง่ของไวยากรณ์) ด้วยชื่อง่ายๆ เพียงชื่อเดียว นอกจากนี้ยังสามารถสร้างฟังก์ชันที่เก็บลำดับคำสั่งทั้งหมดได้อีกด้วย
• พีไอดี หมายเลขประจำตัวกระบวนการที่สอดคล้องกับคำสั่งที่เรียกใช้เชลล์ปัจจุบัน (เช่น กระบวนการที่สร้างเชลล์)
• PS1, PS2, PS3, PS4 - ตัวแปรที่กำหนดประเภทของเชลล์พร้อมต์

  ตัวแปร PS1 และ PS2 ตั้งค่าพรอมต์เชลล์หลักและรอง

  ข้อความแจ้งรอง (PS2) จะปรากฏขึ้นหากคุณกด ใส่รหัสโดยไม่ต้องป้อนข้อมูลคำสั่งให้เสร็จสิ้นทางวากยสัมพันธ์

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

  พีเอส3. ตัวแปรนี้มีพรอมต์ปรากฏอยู่ เลือกคำสั่งใช้เพื่อจัดระเบียบเมนูคอนโซลแบบโต้ตอบ ตามค่าเริ่มต้น พรอมต์ PS3 ในคำสั่ง select คือ #?

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

  เช่น การรันคำสั่ง get ข้อมูล DNS:

  #nslookup >

• PWD - ไดเร็กทอรีการทำงานปัจจุบันของผู้ใช้ ค่านี้จะเปลี่ยนแปลงทุกครั้งที่คุณเปลี่ยนเป็นไดเร็กทอรีอื่นโดยใช้คำสั่ง cd
• SECONDS - เวลารันสคริปต์ (เป็นวินาที)
• SHELL - ล่ามคำสั่งปัจจุบัน
• SHELLOPTS - รายการตัวเลือกล่ามที่เปิดใช้งาน
• SHLVL - จำนวนครั้งที่สำเนาใหม่ของตัวแปลคำสั่งถูกเรียกใช้
• UID - ตัวระบุที่เป็นตัวเลขของผู้ใช้ปัจจุบัน
• USER - ชื่อผู้ใช้ปัจจุบัน
• $# - จำนวนพารามิเตอร์ทั้งหมดที่ส่งไปยังสคริปต์
• $* - อาร์กิวเมนต์ทั้งหมดจะไม่ถูกส่งไปยังสคริปต์ (ส่งออกเป็นบรรทัด)
• $@ - เหมือนกับอันก่อนหน้า แต่พารามิเตอร์จะแสดงในคอลัมน์
• - - PID ของกระบวนการสุดท้ายที่ทำงานอยู่เบื้องหลัง
• $$ - PID ของสคริปต์นั้นเอง

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

คุณสามารถลบตัวแปรด้วยคำสั่ง unset

2.4. การทดแทนและการจัดระเบียบปฏิสัมพันธ์ระหว่างคำสั่ง

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

การแทนที่ผลลัพธ์ของนิพจน์ทางคณิตศาสตร์

มีรูปแบบวากยสัมพันธ์สองรูปแบบสำหรับการแทนที่ผลลัพธ์ของนิพจน์ทางคณิตศาสตร์: $[expression] และ $((expression)) ตัวอย่างเช่น,

echo "ฉันอายุ $ ปี"

การทดแทนคำสั่ง

การทดแทนคำสั่งช่วยให้คุณใช้เอาต์พุตของคำสั่งหนึ่งบนบรรทัดคำสั่งที่มีคำสั่งอื่นได้ สามารถใช้รูปแบบการแทนที่ทางเลือกได้สองรูปแบบ: $(command) หรือ `command` (backquotes เดียว) ตัวอย่างเช่น,

การขยายอักขระตัวหนอน

อักขระตัวหนอน (~) ช่วยให้คุณป้อนชื่อไดเร็กทอรีได้อย่างรวดเร็ว

~ ชื่อของโฮมไดเร็กตอรี่ของผู้ใช้ ~/subdirectory ชื่อของหนึ่งในไดเร็กทอรีย่อยใน โฮมไดเร็กทอรีผู้ใช้ ~+ ชื่อไดเรกทอรีปัจจุบัน ~- ชื่อไดเรกทอรีก่อนหน้า

ขยายวงเล็บปีกกา

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

ค่าใช้จ่าย mkdir/(ม.ค.,ก.พ.,มี.ค.) เท่ากับ ค่าใช้จ่าย mkdir/ม.ค. ค่าใช้จ่าย mkdir/ก.พ. ค่าใช้จ่าย mkdir/มี.ค.

ช่อง

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

แมว /etc/passwd | เรียงลำดับ | หัว -3

ลำดับและกลุ่มคำสั่ง

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

command1;command2 ดำเนินการคำสั่ง 1 ก่อน จากนั้นจึงคำสั่ง 2 (command1;command2) Run สำเนาแยกต่างหากล่ามที่จะรันคำสั่ง 1 และ 2 ตามลำดับ ( command1;command2) รันคำสั่ง 1 และ 2 ตามลำดับในล่ามปัจจุบัน command1 && command2 รันคำสั่ง 2 เฉพาะเมื่อคำสั่ง 1 ดำเนินการสำเร็จ command1 || command2 ดำเนินการคำสั่ง 2 เฉพาะเมื่อคำสั่ง 1 ล้มเหลว

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

ดำเนินการคำสั่งอีกครั้ง

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

หลังจากที่คุณป้อนบรรทัดคำสั่งแล้ว เชลล์จะวางไว้ในประวัติคำสั่ง รายการคำสั่งที่ใช้ก่อนหน้านี้จะถูกเก็บไว้ในไฟล์ซึ่งช่วยให้คุณสามารถเรียกใช้บรรทัดคำสั่งที่ต้องการได้ตลอดเวลาเพื่อดำเนินการใหม่ หลังจากเรียก command line อีกครั้งก็สามารถแก้ไขได้ ประวัติคำสั่งจะถูกจัดเก็บไว้ในไฟล์ .bash_history ซึ่งอยู่ในโฮมไดเร็กตอรี่ของผู้ใช้ ตามค่าเริ่มต้น เชลล์คำสั่งสามารถ "จดจำ" ได้สูงสุด 1,000 บรรทัดคำสั่ง

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

ไวยากรณ์การขยายประวัติ: !n ดำเนินการตามหมายเลขคำสั่งที่กำหนด!! ดำเนินการคำสั่งก่อนหน้า!string ดำเนินการคำสั่งล่าสุดที่เริ่มต้นด้วยสตริงที่กำหนด!?string? ดำเนินการคำสั่งล่าสุดที่มีสตริงที่กำหนด

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

3. ทุบตีในตัว

รายการคำสั่งในตัว เปลือกทุบตีสามารถรับได้โดยใช้คำสั่ง help หรือพบได้ในหน้า man ในส่วนคำสั่ง SHELL BUILTIN

ต่อไปนี้เป็นคำสั่งในตัวที่มีประโยชน์:

• echo [ข้อโต้แย้ง] - พิมพ์ข้อโต้แย้งไปที่หน้าจอ
• เปิดใช้งาน - ทำให้เชลล์เรียกใช้งานไฟล์ปฏิบัติการที่มีชื่อเดียวกันแทนที่จะเป็นคำสั่งบิวด์อิน มีประโยชน์ถ้าคุณมีสคริปต์ของคุณเองชื่อเหมือน echo
• eval [อาร์กิวเมนต์] - สร้างคำสั่งได้ทันทีจากอาร์กิวเมนต์ที่ระบุและส่งไปดำเนินการ
• ให้ - ประเมินการแสดงออก
• - อ่านและรันคำสั่งที่มีอยู่ในไฟล์ ใช้เพื่อกำหนดตัวแปรผู้ใช้ และฟังก์ชั่น
• basename - เน้นชื่อท้องถิ่น
• expr - การประเมินนิพจน์
• อ่าน - ป้อนค่าของตัวแปร
• shift - เลื่อนรายการพารามิเตอร์
• ทดสอบ - ทดสอบสภาพ

คำสั่งในตัวอื่นๆ ทำหน้าที่เป็นคำแนะนำในภาษาคำสั่ง bash

สถาบันเทคโนโลยีอิเล็กทรอนิกส์แห่งรัฐมอสโก

(มหาวิทยาลัยเทคนิค)

ภาควิชาอิเล็กทรอนิกส์บูรณาการและไมโครซิสเต็มส์

ปฏิบัติการห้องปฏิบัติการ

ตามหลักสูตร:

“ระบบปฏิบัติการลินุกซ์”

เรียบเรียงโดย: ผู้ช่วยแผนก. IEMS Kozlov A.V.

มอสโก 2550

การประชุมเชิงปฏิบัติการในห้องปฏิบัติการมีไว้สำหรับผู้เชี่ยวชาญด้านวิศวกรรมศาสตร์และเทคโนโลยีที่กำลังศึกษาอยู่ในโปรแกรม Synopsys ปีแรกในทิศทาง 210100.68 เพื่อเชี่ยวชาญระบบปฏิบัติการ Red Hat Enterprise Linux (RHEL) 4.0 นอกจากนี้ยังออกแบบมาสำหรับนักเรียน FreeScale และผู้ใช้ทุกคนที่มีประสบการณ์ระดับเริ่มต้นหรือไม่มี Linux ที่ต้องการเรียนรู้สภาพแวดล้อมคำสั่ง Linux และแอปพลิเคชันหลักที่ผู้ใช้ต้องการเมื่อทำงานกับระบบการออกแบบที่ใช้คอมพิวเตอร์ช่วย

เวิร์กช็อปนี้ประกอบด้วยงานในห้องปฏิบัติการแปดงานที่ช่วยให้ผู้ใช้สามารถเชี่ยวชาญคำสั่งของล่ามคำสั่งได้อย่างมีประสิทธิภาพ ตลอดจนเรียนรู้การเขียนไฟล์แบบค่อยเป็นค่อยไป - สคริปต์ Shell, Gawk, Perl และ Tcl งานในห้องปฏิบัติการแต่ละงานประกอบด้วยส่วนต่างๆ ดังต่อไปนี้: ชื่อ งาน และวัตถุประสงค์ของงาน ข้อมูลทางทฤษฎีมีคำถามควบคุม ตัวอย่างงานห้องปฏิบัติการ ขั้นตอนการปฏิบัติงานในห้องปฏิบัติการ แบบรายงานผลการปฏิบัติงานและรายงานผลการปฏิบัติงานในห้องปฏิบัติการ ไวยากรณ์สำหรับการเขียนคำสั่งในเชลล์ พร้อมด้วยตัวเลือก พารามิเตอร์ การดำเนินการ นิพจน์ และเส้นทางอ็อบเจ็กต์ ได้รับการออกแบบมาสำหรับสภาพแวดล้อมคำสั่ง BASH รายการข้อมูลอ้างอิงมีให้ไว้ในตอนท้ายของการประชุมเชิงปฏิบัติการในห้องปฏิบัติการ

สถาบันวิศวกรรมอิเล็กทรอนิกส์แห่งรัฐมอสโก (มหาวิทยาลัยเทคนิค)

งานห้องปฏิบัติการหมายเลข 1

ในหลักสูตร “ระบบปฏิบัติการ Linux”

การเรียนรู้คำสั่ง bash บน Linux

คำอธิบายเสร็จสมบูรณ์: โคซลอฟ เอ.วี.

มอสโก 2550

งานห้องปฏิบัติการหมายเลข 1 การศึกษาคำสั่งทุบตีบน Linux

เป้าหมายของการทำงาน : ใช้ล่ามคำสั่ง BASH ฝึกฝนทักษะการทำงานกับคำสั่งในระบบปฏิบัติการ Red Hat Enterprise Linux 4.0

ระยะเวลาการทำงาน - 4 ชั่วโมง

ข้อมูลทางทฤษฎี

ระบบปฏิบัติการ ลินุกซ์ เดิมทีได้รับการพัฒนาให้เป็นแพลตฟอร์มประสิทธิภาพสูงฟรี ยืดหยุ่น มีคุณสมบัติหลากหลาย มีผู้ใช้หลายราย และมีประสิทธิภาพสูง ออกแบบมาเพื่อให้บริการและแก้ไขปัญหาของนักวิทยาศาสตร์ทั่วโลก เนื่องจาก "การมุ่งเน้นทางวิทยาศาสตร์" ในตอนแรกแพลตฟอร์มดังกล่าวจึงไม่มีส่วนต่อประสานกราฟิกขั้นสูงซึ่งใช้กันอย่างแพร่หลายในการแก้ปัญหาในครัวเรือน - เกมส์คอมพิวเตอร์, อินเทอร์เน็ต, โปรแกรมเชิงโต้ตอบสำหรับการเชื่อมต่อผู้ใช้ตลอดจนการแก้ปัญหาในสำนักงาน - การทำงานกับระบบฐานข้อมูล, การสร้างกราฟและฮิสโตแกรม บ่อยครั้งที่งานของนักวิทยาศาสตร์ที่มีระบบปฏิบัติการ Linux ลดลงเหลือเพียงการโต้ตอบตามปกติของผู้ใช้ (บุคคลที่ทำงานบนคอมพิวเตอร์) กับคอนโซล (หน้าต่างเทอร์มินัลบนหน้าจอมอนิเตอร์พร้อมข้อมูลข้อความ) เพื่อทำความเข้าใจคำสั่งที่ผู้ใช้ป้อนใน Linux จึงได้มีการพัฒนาตัวแปลคำสั่ง ซึ่งเป็นตัวแปลคำสั่งที่มนุษย์เข้าใจได้เป็นสัญญาณควบคุมที่เคอร์เนลของระบบปฏิบัติการเข้าใจได้ ภารกิจหลักของระบบปฏิบัติการคือการเป็นสื่อกลางในการส่งคำสั่งจากบุคคลไปยังคอมพิวเตอร์ และแม้ว่าในปัจจุบันระบบปฏิบัติการ Linux จะถูกนำมาใช้ทุกที่ไม่เพียง แต่ในสถาบัน, ศูนย์การออกแบบ, ศูนย์คอมพิวเตอร์เท่านั้น แต่ยังรวมถึงที่บ้านและที่ทำงานด้วย แต่คอนโซล (เทอร์มินัล windows) ยังคงใช้กันอย่างแพร่หลายและสำหรับหลาย ๆ คนดูเหมือนว่ามีมากกว่านั้น สะดวกเมื่อเทียบกับการทำงานด้วยเมาส์และไอคอน (ไอคอนใน Linux) ในสภาพแวดล้อมแบบกราฟิก

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

ล่ามคำสั่งจำนวนมากได้รับการพัฒนาสำหรับ Linux: เชลล์ Bourne Again (BASH), เชลล์โดเมนสาธารณะ (PDKSH), ล่าม TCSH และ Z-shell แม้ว่า BASH จะเป็นล่ามเริ่มต้น แต่คุณสามารถใช้สภาพแวดล้อมอื่นได้ เพื่อความสะดวกในการทำงานในแต่ละวัน ล่ามคำสั่งเพียงตัวเดียวก็เพียงพอแล้ว Red Hal Linux มีเชลล์หลักทั้งหมด แต่มีการติดตั้งและใช้งานเชลล์ BASH เป็นค่าเริ่มต้น ซึ่งหมายความว่าระบบปฏิบัติการนี้ใช้ BASH เพื่อทำงานที่บรรทัดคำสั่งเว้นแต่จะระบุไว้เป็นอย่างอื่น

บรรทัดคำสั่ง. อินเตอร์เฟซคำสั่ง สตริงลินุกซ์ประกอบด้วยหนึ่งบรรทัดที่ป้อนคำสั่งพร้อมตัวเลือกและพารามิเตอร์ ในเชลล์ BASH มักจะทำเครื่องหมายจุดเริ่มต้นของบรรทัดคำสั่ง การเชิญในรูปแบบของเครื่องหมายดอลลาร์ ($); เชลล์ Linux อื่นๆ อาจใช้รูปแบบการแจ้งเตือนที่แตกต่างออกไป เมื่อได้รับแจ้ง ผู้ใช้สามารถป้อนคำสั่งเดียวหรือคำสั่งพร้อมตัวเลือกและพารามิเตอร์ได้ หากผู้ใช้มีขนาดไม่เพียงพอสำหรับพรอมต์คำสั่ง คุณสามารถจำกัดขนาดด้วยอักขระ “/” ได้ ป้อนคำสั่งจากแป้นพิมพ์และป้อนโดยใช้ปุ่ม เช่น เพื่อส่งออก วันที่ของระบบและเวลาของระบบที่ผู้ใช้สามารถใช้คำสั่งได้ วันที่ .

$วันที่

ศุกร์ที่ 8 มิ.ย. 15:42:35 น. MSD 2550

หรือตัวอย่างเช่น หากต้องการแสดงปฏิทินพร้อมเดือนปัจจุบัน ให้ใช้คำสั่ง cal

$แคล

กรกฎาคม 2550

ซู โม ตู เรา Th Fr Sa

1 2 3 4 5 6 7

8 9 10 11 12 13 14

15 16 17 18 19 20 21

22 23 24 25 26 27 28

29 30 31

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

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

$ ลส์ -ล

รวม 28

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

$ ls -อัล

รวม 40

พารามิเตอร์ คือคำที่ป้อนในบรรทัดคำสั่งหลังตัวเลือก คำสั่งการจัดการไฟล์โดยทั่วไปจะใช้ชื่อไฟล์เป็นพารามิเตอร์ ตัวอย่างเช่น หากคุณต้องการข้อมูลเกี่ยวกับไฟล์เดียวเท่านั้น gauss.plx ให้ระบุชื่อไฟล์หลังตัวเลือก -l:

$ ls -l gauss.plx

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

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

การสร้างไฟล์และไดเร็กทอรี ใน Linux ไฟล์และไดเร็กทอรีเป็นข้อมูลสองประเภท ดังนั้นการสร้างมันจึงเสร็จสิ้นโดยใช้ ทีมที่แตกต่างกัน- ในการสร้างไดเร็กทอรี (ไดเร็กทอรี, โฟลเดอร์) ให้ใช้คำสั่งที่สงวนไว้ใน Linux mkdir (“make directory” - สร้างไดเร็กทอรี) ในตัวอย่างต่อไปนี้ เราจะสร้างไดเร็กทอรีใหม่ในไดเร็กทอรีปัจจุบัน เมื่อต้องการทำเช่นนี้ ให้ใช้คำสั่ง mkdir และชื่อของไดเร็กทอรีใหม่ โดยคั่นด้วยช่องว่าง

$ mkdir ใหม่

สร้างไดเร็กทอรีแล้ว อย่างไรก็ตาม บางครั้งคุณจำเป็นต้องสร้างโครงสร้างที่ซ้อนกันทั้งหมด เมื่อภายในโฟลเดอร์ที่สร้างไว้แล้ว ควรมีอีกโฟลเดอร์หนึ่ง และในนั้นอีกโฟลเดอร์หนึ่ง และอื่นๆ เพื่อวัตถุประสงค์เหล่านี้ ตัวเลือกไฟล์แนบ –p จะถูกใช้เป็นส่วนหนึ่งของคำสั่ง mkdir ตัวอย่างต่อไปนี้ใช้คำสั่งเดียวเพื่อสร้างโฟลเดอร์ย่อย: โฟลเดอร์แรก 1 โฟลเดอร์ภายใน 2 และโฟลเดอร์ภายใน 3

$ mkdir -p 1/2/3

คุณสามารถสร้างไฟล์โดยใช้คำสั่งหรือใช้โปรแกรมแก้ไขข้อความ Linux ในตัวและภายนอก เช่น kedit, nedit, gedit และอื่นๆ อย่างไรก็ตาม ตัวแก้ไขที่อยู่ในรายการต้องการการทำงานของเชลล์แบบกราฟิก ซึ่งหมายถึงการทำงานของระบบกราฟิก หากคุณไม่มี คุณสามารถใช้โปรแกรมแก้ไขข้อความได้ เป็นกลุ่มหรือแอนะล็อกที่ไม่ต้องการการทำงานของระบบกราฟิก คุณยังสามารถสร้างไฟล์โดยใช้ตัวจัดการไฟล์ข้อความ เช่น Midnight Commander (คำสั่ง mc) ผู้ใช้ (นักออกแบบ) มักต้องการ ไฟล์ข้อความบันทึกข้อมูลข้อความที่มาพร้อมกับกระบวนการคำนวณวงจรรวมหรือตัวอย่างเช่นพารามิเตอร์ทางไฟฟ้าของอุปกรณ์เซมิคอนดักเตอร์จำลอง นอกจากนี้ยังจำเป็นต้องประมวลผล (ลบ เพิ่ม จัดเรียง แยก) ข้อมูลที่ได้รับ การดำเนินการดังกล่าวดำเนินการโดยใช้คำสั่ง Linux เช่นกัน คำสั่งที่ง่ายที่สุดในการสร้างไฟล์ข้อความคือคำสั่ง แมว.

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

$ แมว > ใหม่ _ ไฟล์

ไฟล์ผลลัพธ์จะถูกดูโดยใช้คำสั่ง cat และชื่อไฟล์ที่คั่นด้วยช่องว่าง

$ แมว ใหม่ _ ไฟล์

หรือ ตัวอย่างเช่น การบันทึกข้อมูลข้อความจากคอนโซลเมื่อคำสั่งรัน LSด้วยตัวเลือก -a ในไฟล์ r คุณสามารถใช้ฟังก์ชันการเปลี่ยนเส้นทางข้อมูล (ดูด้านล่าง) และคำสั่งได้ ทีด้วยตัวเลือก -a

$ ls -l | ที-อา อาร์

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

$ ซีพี เกาส์ . ได้โปรด 1

หากคุณมีสิทธิ์เข้าถึงอ็อบเจ็กต์ Linux (งานห้องปฏิบัติการหมายเลข 2) คุณยังสามารถคัดลอกไฟล์นี้ไปยังผู้ใช้ Alex ซึ่งมีไดเร็กทอรีการทำงานซึ่งมีพาธสัมบูรณ์ /home/alex ต่อไปนี้ โดยใช้คำสั่งต่อไปนี้

$ ซีพี เกาส์ . ได้โปรด / บ้าน / อเล็กซ์

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

$ cp -i gauss.plx /home/alex

ไดเร็กทอรีจะถูกคัดลอกในลักษณะเดียวกับไฟล์ อย่างไรก็ตาม เมื่อคัดลอกไดเร็กทอรีด้วยไฟล์และไดเร็กทอรีย่อย ตัวเลือก –R จะถูกใช้เป็นส่วนหนึ่งของคำสั่ง cp เมื่ออยู่ในไดเร็กทอรี /home/antonk/111 ให้คัดลอกไดเร็กทอรี laba2 ไปยังระดับที่สูงกว่า เช่น ไปยังไดเร็กทอรี /home/antonk จุดสองจุดบ่งบอกถึงระดับลำดับชั้นที่สูงขึ้นไปหนึ่งขั้น

$ ซีพี - ร ลาบา 2 ..

การเปลี่ยนชื่อและการย้ายไฟล์และไดเร็กทอรีการเปลี่ยนชื่อไฟล์และไดเร็กทอรีดำเนินการโดยใช้คำสั่ง mv หลังจากนั้นระบุวัตถุที่จะเปลี่ยนชื่อโดยคั่นด้วยช่องว่าง และชื่อใหม่ของวัตถุโดยคั่นด้วยช่องว่าง การเปลี่ยนชื่อไดเร็กทอรีเกิดขึ้นในลักษณะเดียวกับไฟล์ มาเปลี่ยนชื่อไฟล์ gauss.plx เป็นไฟล์ใหม่ชื่อ gauss2.plx หากไฟล์ที่มีชื่อเดียวกันกับชื่อใหม่ของไฟล์ที่เปลี่ยนชื่อมีอยู่แล้วในไดเร็กทอรีนี้ ไฟล์นั้นจะถูกเขียนทับด้วยเนื้อหาของไฟล์ที่เปลี่ยนชื่อ เพื่อป้องกันสิ่งนี้ ให้ใช้ตัวเลือก –i ด้วย อย่างไรก็ตามบน Linux ไม่จำเป็นต้องใช้ส่วนขยาย ใช้เพื่อเชื่อมโยงไฟล์และโปรแกรมปฏิบัติการเท่านั้น

$ mv –i gauss.plx gauss2.plx

การลบไฟล์และไดเร็กทอรีการลบไฟล์และไดเร็กทอรีใน Linux ทำได้โดยใช้คำสั่ง rm โดยระบุชื่อของไฟล์ที่จะลบ โดยคั่นด้วยช่องว่าง - ระวังเมื่อใช้งานคำสั่งนี้คุณอาจลบข้อมูลที่จำเป็นได้ เช่นเดียวกับคำสั่ง cp ให้ใช้ตัวเลือก –i ร่วมกับคำสั่ง rm คำสั่งที่มีตัวเลือกนี้จะขอการยืนยันเพื่อลบแต่ละไฟล์และไดเร็กทอรี ในตัวอย่างต่อไปนี้ เราจะลบไฟล์ เกาส์ 2. ได้โปรด , ขอคำยืนยันการลบ .

RM –ฉัน gauss2.plx

สัญลักษณ์แทน บางครั้งเมื่อทำงานกับตัวแปลคำสั่ง คุณจำเป็นต้องค้นหาหรือจับคู่ไฟล์โดยใช้รูปแบบ ตัวอย่างเช่น คุณทราบเพียงอักษรตัวแรกของชื่อไฟล์ และต้องการค้นหาไฟล์ทั้งหมดในไดเร็กทอรีการทำงานที่ขึ้นต้นด้วยตัวอักษรนั้น หรือคุณทราบลำดับของตัวอักษรหลายตัวในชื่อหรือนามสกุลของไฟล์ และคุณจำเป็นต้องค้นหามันจากไฟล์อื่นๆ หลายร้อยไฟล์ ในกรณีนี้ คุณต้องใช้อักขระพิเศษของ Linux ล่ามคำสั่งใช้ชุดข้อมูล อักขระพิเศษเรียกว่าไวด์การ์ด ซึ่งสามารถใช้ค้นหาไฟล์ จับคู่ไฟล์ และสร้างรายการชื่อไฟล์ได้ อักขระเหล่านี้ ได้แก่ เครื่องหมายดอกจัน เครื่องหมายคำถาม และวงเล็บเหลี่ยม (*, ?, ) เมื่อได้รับชื่อไฟล์บางส่วนแล้ว ตัวแปลคำสั่งจะใช้อักขระเหล่านี้เป็นเทมเพลตเพื่อค้นหาและสร้างรายชื่อไฟล์ที่ตรวจพบ พารามิเตอร์ที่มีชื่อไฟล์ที่ไม่เข้าเกณฑ์จะถูกแทนที่ด้วยรายการชื่อไฟล์ที่ตรงกัน รายชื่อนี้สามารถใช้เป็นพารามิเตอร์ในคำสั่งที่ทำงานบนหลายไฟล์ได้ (เช่น LS- ไวด์การ์ดตัวแปลคำสั่งแสดงอยู่ในตาราง 1.

ตารางที่ 1. อักขระพิเศษของเชลล์

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

ตัวอย่างเช่น เครื่องหมายดอกจัน (*) สามารถใช้เพื่ออ้างถึงไฟล์ที่ชื่อขึ้นต้นหรือลงท้ายด้วยอักขระเฉพาะเจาะจง ตัวอย่างนี้แสดงวิธีการใช้เครื่องหมายดอกจัน (*) ร่วมกับอักขระใดๆ

$ls

docl doc2 เอกสาร เอกสาร mydoc วันจันทร์ วันอังคาร

แสดงรายการไฟล์ทั้งหมดในไดเร็กทอรีการทำงาน

$ ls เอกสาร*

เอกสาร docl doc2

ตัวอย่างนี้แสดงให้เห็นว่าเราใช้เครื่องหมายดอกจันเพื่อ "กรอง" ชื่อไฟล์ที่ไม่ได้ขึ้นต้นด้วยตัวอักษรผสม "doc" เฉพาะชื่อไฟล์ที่มีคำว่า “doc” รวมกันเท่านั้นที่จะแสดง ในกรณีนี้ ไฟล์ที่เหลือจะไม่ถูกลบ แต่จะไม่แสดงให้ผู้ใช้เห็น

$ ls *วัน

วันจันทร์ ที วันอังคาร

ที่นี่เราได้แสดงชื่อไฟล์ที่ลงท้ายด้วยการรวม "วัน"

$ LS [ ภูเขา ] * ง *

วันจันทร์ วันอังคาร

และที่นี่เราได้แสดงชื่อของไฟล์ที่มีอักขระตัวแรกคือตัวอักษร "m" หรือ "t" อักขระที่ตามมาจะเป็นตัวอักษรที่กำหนดเองจากนั้นตัวอักษร "d" และอักขระที่กำหนดเองอีกครั้ง

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

RM *

$ ls *วัน

docl doc2 เอกสาร

เครื่องหมายคำถาม (?) หมายถึงอักขระที่ไม่ระบุเพียงตัวเดียวในชื่อไฟล์