9 Bash Script ตัวอย่างเพื่อให้คุณเริ่มต้นบน Linux

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

อย่าลืมทำให้สคริปต์ของคุณสามารถปฏิบัติการได้

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

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

คำสั่ง chmod ช่วยให้เราตั้งค่าการอนุญาตไฟล์ สามารถตั้งค่าการอนุญาตดำเนินการได้ด้วยแฟล็ก +x

 chmod +x script1.sh 

คุณจะต้องทำเช่นนี้กับสคริปต์แต่ละรายการของคุณ แทนที่ “script1.sh” ด้วยชื่อสคริปต์ของคุณ

1. บรรทัดแรกที่แปลกคืออะไร?

บรรทัดแรกของสคริปต์จะบอกเชลล์ว่าควรเรียกล่ามตัวใดเพื่อเรียกใช้สคริปต์นั้น บรรทัดแรกต้องขึ้นต้นด้วย shebang, “#!” หรือที่เรียกว่า hashbang “#!” บอกเชลล์ว่าบรรทัดนี้มีเส้นทางและชื่อของล่ามที่สคริปต์เขียนขึ้น

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

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

 #!/bin/bash

เสียงสะท้อนทำงานใน $SHELL

บรรทัดแรกของสคริปต์นี้สามารถอ่านได้ว่า "ใช้ล่ามที่ /bin/bash เพื่อเรียกใช้สคริปต์นี้"

บรรทัดเดียวในสคริปต์เขียนค่าที่อยู่ในตัวแปรสภาพแวดล้อม $SHELL ไปยังหน้าจอเทอร์มินัล สิ่งนี้เป็นการยืนยันว่า Bash ถูกใช้เพื่อรันสคริปต์

 ./script1.sh 

เพื่อเป็นเคล็ดลับในห้องนั่งเล่น เราสามารถแสดงให้เห็นว่าบทนี้ถูกส่งผ่านไปยังล่ามคนใดก็ได้ที่เราเลือก

 #!/bin/cat
ข้อความทั้งหมดถูกส่งผ่านไปยังคำสั่ง cat
และพิมพ์ในหน้าต่างเทอร์มินัล ซึ่งรวมถึง
สาย Shebang

 script2.sh 

สคริปต์นี้เปิดใช้โดยเชลล์ปัจจุบันและส่งผ่านไปยังคำสั่ง cat คำสั่ง cat "รัน" สคริปต์

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

 #!/usr/bin/env bash

เสียงสะท้อนทำงานใน $SHELL

 script3.sh 

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

อย่าฟังเขาโกหก!

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

หากคุณเปิดเชลล์ที่คุณต้องการรันสคริปต์และส่งสคริปต์เป็นพารามิเตอร์บรรทัดคำสั่ง เชลล์จะเปิดและรันสคริปต์ — ไม่ว่าจะเป็นไฟล์สั่งการหรือไม่ก็ตาม เนื่องจากคุณเลือกเชลล์บนบรรทัดคำสั่ง จึงไม่จำเป็นต้องมี shebang

นี่คือสคริปต์ทั้งหมด:

 echo "ฉันถูกประหารชีวิตโดย" $SHELL

เราจะใช้ ls เพื่อดูว่าสคริปต์ไม่สามารถดำเนินการได้จริง ๆ และเรียกใช้ Bash ด้วยชื่อของสคริปต์:

 ลส

 bash script4.sh 

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

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

 ซอร์ส script4.sh

 . script4.sh 

แม้ว่าจะเป็นไปได้ แต่ก็ไม่แนะนำให้ใช้เป็นวิธีแก้ปัญหาทั่วไป มีข้อเสียคือ

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

ที่เกี่ยวข้อง: บรรทัดคำสั่ง: ทำไมผู้คนถึงยังกังวลกับพวกเขา?

2. การพิมพ์ข้อความ

การเขียนข้อความไปยังเทอร์มินัลเป็นข้อกำหนดทั่วไป ข้อเสนอแนะด้วยภาพเล็กน้อยไปไกล

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

 #!/bin/bash

echo นี่เป็นสตริงธรรมดา
echo "นี่คือสตริงที่มี 'เครื่องหมายคำพูดเดียว' ดังนั้นจึงถูกห่อด้วยเครื่องหมายคำพูดคู่"
echo "นี่พิมพ์ชื่อผู้ใช้:" $USER
echo -e "ตัวเลือก -e ช่วยให้เราใช้\nการจัดรูปแบบคำสั่ง\nเพื่อแยกสตริง"

 ./script5.sh 

คำสั่ง printf ทำให้เรามีความยืดหยุ่นและความสามารถในการจัดรูปแบบที่ดีขึ้น รวมถึงการแปลงตัวเลข

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

 #!/bin/bash

printf "ทศนิยม: %d, เลขฐานแปด: %o, เลขฐานสิบหก: %03X\n" 32 32 32

 ./script6.sh 

โปรดทราบว่าไม่เหมือนกับ echo คุณต้องบอกให้ printf เริ่มบรรทัดใหม่ด้วยโทเค็น “ \n ”

3. การสร้างและการใช้ตัวแปร

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

 #!/bin/bash

millennium_text="ปีตั้งแต่สหัสวรรษ:"

current_time=$( วันที่ '+%H:%M:%S' )
todays_date=$( วันที่ '+%F' )
ปี=$( วันที่ '+%Y' )

echo "เวลาปัจจุบัน:" $current_time
echo "วันที่ของวันนี้:" $todays_date

years_since_Y2K=$(( ปี - 2000 ))

echo $millennium_text $years_since_Y2K . สะท้อน

สคริปต์นี้สร้างตัวแปรสตริงชื่อ millennium_text มีบรรทัดข้อความ

จากนั้นจะสร้างตัวแปรตัวเลขสามตัว

• ตัวแปร current_time ถูกเตรียมใช้งานตามเวลาที่สคริปต์ถูกเรียกใช้งาน
• ตัวแปร todays_date ถูกตั้งค่าเป็นวันที่ที่รันสคริปต์
• ตัวแปร year ถือปีปัจจุบัน

ในการเข้าถึง ค่า ที่เก็บไว้ในตัวแปร ให้นำหน้าชื่อด้วยเครื่องหมายดอลลาร์ “$”

 ./script7.sh 

สคริปต์จะพิมพ์เวลาและวันที่ จากนั้นคำนวณจำนวนปีที่ผ่านไปนับตั้งแต่สหัสวรรษ และเก็บไว้ในตัวแปร years_since_Y2K

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

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

4. การจัดการอินพุตของผู้ใช้

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

 #!/bin/bash

echo "ใส่ตัวเลขแล้วกด \"Enter\""
อ่าน user_number1;
echo "ป้อนหมายเลขอื่นแล้วกด \"Enter\""
อ่าน user_number2;

printf "คุณป้อน: %d และ %d\n" $user_number1 $user_number2
printf "รวมเข้าด้วยกันทำให้: %d\n" $(( user_number1 + user_number2))

สคริปต์พร้อมท์ให้ใส่ตัวเลขสองตัว พวกเขาอ่านจากแป้นพิมพ์และเก็บไว้ในสองตัวแปร user_number1 และ user_number2

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

 ./script8.sh 

เราสามารถรวมพรอมต์ไว้ในคำสั่ง read โดยใช้ตัวเลือก -p (พร้อมท์)

 #!/bin/bash

อ่าน -p "ป้อนตัวเลขแล้วกด \"Enter\"" user_number1;
อ่าน -p "ป้อนหมายเลขอื่นแล้วกด \"Enter\"" user_number2;

printf "คุณป้อน: %d และ %d\n" $user_number1 $user_number2
printf "รวมเข้าด้วยกันทำให้: %d\n" $(( user_number1 + user_number2))

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

 ./script9.sh 

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

ในการจับภาพอินพุตของแป้นพิมพ์โดยไม่ให้สะท้อนไปยังหน้าต่างเทอร์มินัล ให้ใช้ตัวเลือก -s (เงียบ)

 #!/bin/bash

อ่าน -s -p "ป้อน PIN ลับของคุณและกด \"Enter\" " secret_PIN;

printf "\nShhh ... มันคือ %d\n" $secret_PIN

 ./script10.sh 

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

5. การยอมรับพารามิเตอร์

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

พารามิเตอร์แรกกลายเป็นตัวแปร $1 พารามิเตอร์ที่สองกลายเป็นตัวแปร $2 เป็นต้น ตัวแปร $0 จะเก็บชื่อของสคริปต์ไว้เสมอ และตัวแปร $# จะเก็บจำนวนพารามิเตอร์ที่ระบุไว้ในบรรทัดคำสั่ง ตัวแปร $@ เป็นสตริงที่มีพารามิเตอร์บรรทัดคำสั่งทั้งหมด

 #!/bin/bash

printf "สคริปต์นี้ชื่อ: %s\n" $0
printf "คุณใช้ %d พารามิเตอร์บรรทัดคำสั่ง\n" $#

# วนซ้ำตัวแปร
สำหรับพารามิเตอร์ใน "$@"; ทำ
  เสียงสะท้อน "$param"
เสร็จแล้ว

echo "Parameter 2 คือ:" $2

สคริปต์นี้ใช้ $0 และ $# เพื่อพิมพ์ข้อมูลบางอย่าง จากนั้นใช้ ?@ เพื่อวนรอบพารามิเตอร์บรรทัดคำสั่งทั้งหมด ใช้ $2 เพื่อแสดงวิธีเข้าถึงค่าพารามิเตอร์เฉพาะค่าเดียว

 ./script11.sh 

การใส่คำหลายคำในเครื่องหมายคำพูด “” จะรวมคำเหล่านั้นเป็นพารามิเตอร์เดียว

6. การอ่านข้อมูลจากไฟล์

การรู้วิธีอ่านข้อมูลจากไฟล์ถือเป็นทักษะที่ยอดเยี่ยม เราสามารถทำได้ใน Bash ด้วย a while loop

 #!/bin/bash

LineCount=0

ในขณะที่ IFS='' อ่าน -r LinefromFile || [[ -n "${LinefromFile}" ]]; ทำ

  ((LineCount++))
  echo "กำลังอ่านบรรทัด $LineCount: ${LinefromFile}"

เสร็จสิ้น < "$1"

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

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

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

ส่วนคำสั่ง [[ -n "${LinefromFile}" ]] ใช้สำหรับความเป็นไปได้ที่บรรทัดสุดท้ายในไฟล์ไม่ได้ลงท้ายด้วยการขึ้นบรรทัดใหม่ แม้ว่าจะไม่เป็นเช่นนั้น บรรทัดสุดท้ายนั้นจะได้รับการจัดการอย่างถูกต้องและถือเป็นบรรทัดที่สอดคล้องกับ POSIX ปกติ

 ./script12.sh twinkle.txt 

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

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

 #!/bin/bash

ราคา=$1

ถ้า [[ ราคา -ge 15 ]];
แล้ว
  เสียงสะท้อน "ราคาแพงเกินไป"
อื่น
  เสียงสะท้อน "ซื้อเลย!"
fi

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

นอกจากนี้ยังมีการทดสอบเชิงตัวเลขสำหรับ equals -qe , มากกว่า -gt , less than or equal -le เป็นต้น แม้ว่าคุณจะสามารถใช้เครื่องหมาย == , >= , <= ที่คุ้นเคยได้

 ./script13.sh 13

 ./script13.sh 14

 ./script13.sh 15

 ./script13.sh 16 

8. พลังแห่งลูป

การกระทำซ้ำแล้วซ้ำอีกทำได้ดีที่สุดโดยใช้การวนซ้ำ A for loop ให้คุณเรียกใช้การวนซ้ำได้หลายครั้ง ซึ่งอาจขึ้นอยู่กับจำนวนเฉพาะ หรืออาจเป็นจนกว่าการวนซ้ำจะทำงานผ่านรายการ

 #!/bin/bash

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

สำหรับฉันใน {1..4}
ทำ
  echo "สำหรับลูปที่มีช่วง:" $i
เสร็จแล้ว

สำหรับฉันใน "ศูนย์" "หนึ่ง" "สอง" "สาม"
ทำ
  echo "สำหรับลูปที่มีรายการคำ:" $i
เสร็จแล้ว

เว็บไซต์="How To Geek"

สำหรับฉันใน $website
ทำ
  echo "สำหรับการวนซ้ำชุดคำ:" $i
เสร็จแล้ว

ลูปทั้งหมดเหล่านี้มี for ลูป แต่กำลังทำงานกับคำสั่งและข้อมูลลูปประเภทต่างๆ

 ./script14.sh 3 

ลูปแรกเป็นแบบ C แบบคลาสสิก for ลูป ตัวนับลูป i ถูกตั้งค่าเริ่มต้นเป็นศูนย์ และเพิ่มขึ้นตามแต่ละรอบของลูป แม้ว่าค่าของ i จะน้อยกว่าหรือเท่ากับค่าที่ถือไว้ใน $1 การวนซ้ำจะยังคงทำงานต่อไป

วงที่สองทำงานผ่านช่วงของตัวเลขตั้งแต่ 1 ถึง 4 วงที่สามทำงานผ่านรายการคำ แม้ว่าจะมีคำที่ต้องประมวลผลมากขึ้น แต่การวนซ้ำยังคงวนซ้ำ

ลูปสุดท้ายทำงานผ่านรายการคำในตัวแปรสตริง

9. ฟังก์ชั่น

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

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

 #!/bin/bash

LineCount=0

ฟังก์ชั่น count_words() {
  printf "%d คำในบรรทัด %d\n" $(echo $1 | wc -w) $2
}

ในขณะที่ IFS='' อ่าน -r LinefromFile || [[ -n "${LinefromFile}" ]]; ทำ

  ((LineCount++))
  count_words "$LinefromFile" $LineCount

เสร็จสิ้น < "$1"

count_words "ไม่อยู่ในวง" 99

เราได้แก้ไขโปรแกรมอ่านไฟล์โดยเพิ่มฟังก์ชันที่เรียกว่า count_words มันถูกกำหนดไว้ ก่อนที่ เราจะต้องใช้มัน

นิยามฟังก์ชันเริ่มต้นด้วยคำว่า function ตามด้วยชื่อเฉพาะสำหรับฟังก์ชันของเรา ตามด้วยวงเล็บ “ () .” เนื้อหาของฟังก์ชันอยู่ในวงเล็บปีกกา “{}”

คำจำกัดความของฟังก์ชันไม่ได้ทำให้โค้ดทำงานใดๆ ไม่มีสิ่งใดในฟังก์ชันทำงานจนกว่าจะมีการเรียกใช้ฟังก์ชัน

ฟังก์ชัน count_words พิมพ์จำนวนคำในบรรทัดข้อความและหมายเลขบรรทัด พารามิเตอร์ทั้งสองนี้ถูกส่งผ่านไปยังฟังก์ชันเช่นเดียวกับพารามิเตอร์ที่ถูกส่งผ่านไปยังสคริปต์ พารามิเตอร์แรกกลายเป็น ฟังก์ชัน variable $1 และพารามิเตอร์ที่สองกลายเป็น function variable $2 เป็นต้น

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

 ./script15.sh twinkle.txt 

อย่ากลัวเส้นโค้งการเรียนรู้

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

เดินก่อนที่จะวิ่งได้ และใช้เวลาเพลิดเพลินไปกับการเดินทาง

ที่เกี่ยวข้อง: 10 คำสั่ง Linux พื้นฐานสำหรับผู้เริ่มต้น