สคริปต์ทุบตี: จุดเริ่มต้น

สคริปต์ทุบตี: จุดเริ่มต้น
Bash Scripts ตอนที่ 2: ลูป
Bash Scripts ตอนที่ 3: ตัวเลือกบรรทัดคำสั่งและสวิตช์
Bash Scripts ตอนที่ 4: อินพุตและเอาต์พุต
Bash Scripts ตอนที่ 5: สัญญาณ งานเบื้องหลัง การจัดการสคริปต์
Bash Scripts ตอนที่ 6: ฟังก์ชั่นและการพัฒนาห้องสมุด
Bash Scripts ตอนที่ 7: sed และการประมวลผลคำ
สคริปต์ทุบตีตอนที่ 8: ภาษาการประมวลผลข้อมูล awk
Bash Scripts ตอนที่ 9: นิพจน์ทั่วไป
Bash Scripts ตอนที่ 10: ตัวอย่างที่ใช้งานได้จริง
สคริปต์ทุบตีตอนที่ 11: คาดหวังและเป็นอัตโนมัติของยูทิลิตี้เชิงโต้ตอบ

วันนี้เราจะพูดถึงสคริปต์ทุบตี นี้ - สคริปต์บรรทัดคำสั่งเขียนขึ้นสำหรับ bash shell มีเชลล์อื่น ๆ เช่น zsh, tcsh, ksh แต่เราจะเน้นที่ bash เนื้อหานี้มีไว้สำหรับทุกคน เงื่อนไขเดียวคือความสามารถในการทำงาน บรรทัดคำสั่ง ลินุกซ์

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

ดังนั้น หากเราพูดถึงบรรทัดคำสั่ง จะช่วยให้คุณสามารถรันคำสั่งหลายคำพร้อมกันได้โดยการป้อนคำสั่งเหล่านั้นโดยคั่นด้วยเครื่องหมายอัฒภาค:

pwd ; whoami

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

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

getconf ARG_MAX

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

สคริปต์ทุบตีทำงานอย่างไร

สร้างไฟล์เปล่าโดยใช้คำสั่ง touch. บรรทัดแรกต้องระบุว่าเราจะใช้เชลล์ใด เรามีความสนใจ bashดังนั้นบรรทัดแรกของไฟล์จะเป็น:

#!/bin/bash

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

คำสั่งเชลล์จะถูกคั่นด้วยการป้อนบรรทัด ความคิดเห็นจะถูกคั่นด้วยเครื่องหมายแฮช นี่คือสิ่งที่ดูเหมือน:

#!/bin/bash
# This is a comment
pwd
whoami

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

การตั้งค่าการอนุญาตไฟล์สคริปต์

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

กำลังพยายามเรียกใช้ไฟล์สคริปต์โดยมีสิทธิ์ที่กำหนดค่าไม่ถูกต้อง

มาทำให้ไฟล์ปฏิบัติการได้:

chmod +x ./myscript

ตอนนี้เรามาลองดำเนินการดู:

./myscript

หลังจากตั้งค่าการอนุญาตทุกอย่างทำงานได้ตามปกติ

เรียกใช้สคริปต์ทุบตีสำเร็จ

เอาต์พุตข้อความ

หากต้องการส่งข้อความไปยังคอนโซล Linux ให้ใช้คำสั่ง echo. ลองใช้ความรู้เกี่ยวกับข้อเท็จจริงนี้และแก้ไขสคริปต์ของเรา โดยเพิ่มคำอธิบายให้กับข้อมูลที่ส่งออกโดยคำสั่งที่มีอยู่แล้ว:

#!/bin/bash
# our comment is here
echo "The current directory is:"
pwd
echo "The user logged in is:"
whoami

นี่คือสิ่งที่เกิดขึ้นหลังจากการรันสคริปต์ที่อัปเดต

ส่งออกข้อความจากสคริปต์

ตอนนี้เราสามารถแสดงบันทึกอธิบายได้โดยใช้คำสั่ง echo. หากคุณไม่ทราบวิธีแก้ไขไฟล์โดยใช้เครื่องมือ Linux หรือไม่เคยเห็นคำสั่งนี้มาก่อน echoลองดูที่ นี้ วัสดุ

การใช้ตัวแปร

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

ไม่มีอะไรผิดปกติกับการดำเนินการคำสั่งแต่ละคำสั่งโดยไม่จัดเก็บผลลัพธ์ แต่ความสามารถของวิธีนี้มีจำกัดมาก

มีตัวแปรสองประเภทที่สามารถใช้ในสคริปต์ทุบตี:

• ตัวแปรสภาพแวดล้อม
• ตัวแปรผู้ใช้

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

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

#!/bin/bash
# display user home
echo "Home for the current user is: $HOME"

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

การใช้ตัวแปรสภาพแวดล้อมในสคริปต์

จะทำอย่างไรถ้าคุณต้องการแสดงเครื่องหมายดอลลาร์บนหน้าจอ? มาลองสิ่งนี้กัน:

echo "I have $1 in my pocket"

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

ในสถานการณ์เช่นนี้ การใช้อักขระหลีก เครื่องหมายแบ็กสแลช ก่อนเครื่องหมายดอลลาร์จะช่วยได้:

echo "I have $1 in my pocket"

สคริปต์จะแสดงผลลัพธ์ตามที่คาดไว้ทุกประการ

การใช้ลำดับหลีกเพื่อพิมพ์เครื่องหมายดอลลาร์

ตัวแปรผู้ใช้

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

เช่นเดียวกับตัวแปรระบบ ตัวแปรผู้ใช้สามารถเข้าถึงได้โดยใช้เครื่องหมายดอลลาร์:
TNW-CUS-FMP - รหัสโปรโมชั่นเพื่อรับส่วนลด 10% สำหรับบริการของเรา เปิดใช้งานได้ภายใน 7 วัน

#!/bin/bash
# testing variables
grade=5
person="Adam"
echo "$person is a good boy, he is in grade $grade"

นี่คือสิ่งที่เกิดขึ้นหลังจากการรันสคริปต์ดังกล่าว

ตัวแปรที่กำหนดเองในสคริปต์

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

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

สามารถทำได้สองวิธี

• การใช้เครื่องหมายย้อนกลับ "`"
• โดยการออกแบบ $()

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

mydir=`pwd`

ในแนวทางที่สอง สิ่งเดียวกันนี้เขียนดังนี้:

mydir=$(pwd)

และสคริปต์อาจมีลักษณะดังนี้:

#!/bin/bash
mydir=$(pwd)
echo $mydir

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

สคริปต์ที่บันทึกผลลัพธ์ของคำสั่งในตัวแปร

การดำเนินการทางคณิตศาสตร์

ในการดำเนินการทางคณิตศาสตร์ในไฟล์สคริปต์ คุณสามารถใช้โครงสร้างที่คล้ายกันได้ $((a+b)):

#!/bin/bash
var1=$(( 5 + 5 ))
echo $var1
var2=$(( $var1 * 2 ))
echo $var2

การดำเนินการทางคณิตศาสตร์ในสคริปต์

โครงสร้างการควบคุมแบบ if-then

ในบางสถานการณ์ คุณจำเป็นต้องควบคุมโฟลว์การดำเนินการคำสั่ง ตัวอย่างเช่น หากค่าบางอย่างมากกว่าห้า คุณจะต้องดำเนินการอย่างใดอย่างหนึ่ง ไม่เช่นนั้นก็ต้องดำเนินการอีกอย่างหนึ่ง สิ่งนี้ใช้ได้กับหลายสถานการณ์ และโครงสร้างการควบคุมจะช่วยเราได้ที่นี่ if-then. ในรูปแบบที่ง่ายที่สุดมีลักษณะดังนี้:

if команда
then
команды
fi

นี่คือตัวอย่างการทำงาน:

#!/bin/bash
if pwd
then
echo "It works"
fi

ในกรณีนี้หากดำเนินการตามคำสั่ง pwdจะเสร็จสมบูรณ์ ข้อความ "ใช้งานได้" จะปรากฏบนคอนโซล

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

#!/bin/bash
user=likegeeks
if grep $user /etc/passwd
then
echo "The user $user Exists"
fi

นี่คือสิ่งที่เกิดขึ้นหลังจากการรันสคริปต์นี้

ค้นหาผู้ใช้

ที่นี่เราใช้คำสั่ง grepเพื่อค้นหาผู้ใช้ในไฟล์ /etc/passwd. หากทีม grepไม่คุ้นเคยกับคุณ สามารถพบคำอธิบายได้ ที่นี่.

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

โครงสร้างการควบคุมแบบ if-then-else

เพื่อให้โปรแกรมสามารถรายงานทั้งผลลัพธ์ของการค้นหาที่สำเร็จและความล้มเหลว เราจะใช้โครงสร้าง if-then-else. นี่คือวิธีการทำงาน:

if команда
then
команды
else
команды
fi

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

มาเขียนสคริปต์ต่อไปนี้:

#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
else
echo "The user $user doesn’t exist"
fi

การประหารชีวิตของเขาลงท่อระบายน้ำ else.

การรันสคริปต์ด้วยโครงสร้างแบบ if-then-else

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

if команда1
then
команды
elif команда2
then
команды
fi

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

#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
elif ls /home
then
echo "The user doesn’t exist but anyway there is a directory under /home"
fi

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

การเปรียบเทียบตัวเลข

ในสคริปต์คุณสามารถเปรียบเทียบค่าตัวเลขได้ ด้านล่างนี้เป็นรายการคำสั่งที่เกี่ยวข้อง

n1 -eq n2คืนค่าจริงถ้า n1 เป็น n2.
n1 -ge n2 คืนค่าจริงถ้า n1มากกว่าหรือเท่ากัน n2.
n1 -gt n2คืนค่าจริงถ้า n1 ขึ้น n2.
n1 -le n2คืนค่าจริงถ้า n1น้อยกว่าหรือเท่ากัน n2.
n1 -lt n2คืนค่าเป็นจริงถ้า n1 น้อยกว่า n2.
n1 -ne n2คืนค่าจริงถ้า n1ไม่เท่ากัน n2.

เป็นตัวอย่าง ลองใช้ตัวดำเนินการเปรียบเทียบตัวใดตัวหนึ่ง โปรดทราบว่านิพจน์จะอยู่ในวงเล็บเหลี่ยม

#!/bin/bash
val1=6
if [ $val1 -gt 5 ]
then
echo "The test value $val1 is greater than 5"
else
echo "The test value $val1 is not greater than 5"
fi

นี่คือสิ่งที่คำสั่งนี้จะส่งออก

การเปรียบเทียบตัวเลขในสคริปต์

ค่าตัวแปร val1มากกว่า 5 แบรนช์จะถูกดำเนินการในที่สุด thenตัวดำเนินการเปรียบเทียบและข้อความที่เกี่ยวข้องจะแสดงในคอนโซล

การเปรียบเทียบสตริง

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

str1 = str2 ทดสอบสตริงเพื่อความเท่าเทียมกัน โดยคืนค่าเป็นจริงหากสตริงเหมือนกัน
str1 != str2คืนค่าเป็นจริงหากสตริงไม่เหมือนกัน
str1 < str2คืนค่าจริงถ้า str1น้อยกว่า str2.
str1 > str2 คืนค่าจริงถ้า str1มากกว่า str2.
-n str1 ส่งคืนค่าจริงหากมีความยาว str1เหนือศูนย์
-z str1ส่งคืนค่าจริงหากมีความยาว str1เท่ากับศูนย์

นี่คือตัวอย่างการเปรียบเทียบสตริงในสคริปต์:

#!/bin/bash
user ="likegeeks"
if [$user = $USER]
then
echo "The user $user  is the current logged in user"
fi

จากการรันสคริปต์เราได้รับสิ่งต่อไปนี้

การเปรียบเทียบสตริงในสคริปต์

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

นี่คือลักษณะการทำงานกับโอเปอเรเตอร์เหล่านี้ในโค้ด:

#!/bin/bash
val1=text
val2="another text"
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

นี่คือผลลัพธ์ของสคริปต์

การเปรียบเทียบสตริง ให้คำเตือน

โปรดทราบว่าสคริปต์แม้จะดำเนินการแล้ว แต่ก็มีคำเตือน:

./myscript: line 5: [: too many arguments

เพื่อกำจัดคำเตือนนี้ เราจึงสรุป $val2 ในเครื่องหมายคำพูดคู่:

#!/bin/bash
val1=text
val2="another text"
if [ $val1 > "$val2" ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

ตอนนี้ทุกอย่างทำงานได้ตามปกติ

การเปรียบเทียบสตริง

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

Likegeeks
likegeeks

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

sort myfile

มันจะเรียงลำดับบรรทัดจากไฟล์ดังนี้:

likegeeks
Likegeeks

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

#!/bin/bash
val1=Likegeeks
val2=likegeeks
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fi

หากคุณเรียกใช้ปรากฎว่าทุกอย่างกลับกัน - ตอนนี้ตัวพิมพ์เล็กมีขนาดใหญ่กว่าตัวพิมพ์ใหญ่

คำสั่ง sort และการเปรียบเทียบสตริงในไฟล์สคริปต์

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

ทีม sortในทางกลับกัน จะใช้ลำดับการจัดเรียงที่ระบุในการตั้งค่าภาษาของระบบ

การตรวจสอบไฟล์

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

-d fileตรวจสอบว่ามีไฟล์อยู่และเป็นไดเร็กทอรีหรือไม่
-e fileตรวจสอบว่ามีไฟล์อยู่หรือไม่
-f file ตรวจสอบว่ามีไฟล์อยู่และเป็นไฟล์หรือไม่
-r fileตรวจสอบว่ามีไฟล์อยู่และสามารถอ่านได้หรือไม่
-s file Пตรวจสอบว่าไฟล์มีอยู่และไม่ว่างเปล่า
-w fileตรวจสอบว่ามีไฟล์อยู่และสามารถเขียนได้
-x fileตรวจสอบว่ามีไฟล์อยู่และสามารถเรียกใช้งานได้หรือไม่
file1 -nt file2 ตรวจสอบว่าใหม่กว่าหรือไม่ file1กว่า file2.
file1 -ot file2ตรวจสอบว่าเก่าหรือไม่ file1กว่า file2.
-O file ตรวจสอบว่าไฟล์มีอยู่และเป็นของผู้ใช้ปัจจุบันหรือไม่
-G fileตรวจสอบว่ามีไฟล์อยู่หรือไม่และ ID กลุ่มตรงกับ ID กลุ่มของผู้ใช้ปัจจุบันหรือไม่

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

ลองใช้คำสั่งใดคำสั่งหนึ่งในทางปฏิบัติ:

#!/bin/bash
mydir=/home/likegeeks
if [ -d $mydir ]
then
echo "The $mydir directory exists"
cd $ mydir
ls
else
echo "The $mydir directory does not exist"
fi

สคริปต์นี้สำหรับไดเร็กทอรีที่มีอยู่จะแสดงเนื้อหา

การแสดงเนื้อหาของไดเร็กทอรี

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

ผลของการ

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

1. Bash Script ทีละขั้นตอน — ที่นี่เรากำลังพูดถึงวิธีเริ่มสร้างสคริปต์ทุบตี พิจารณาการใช้ตัวแปร โครงสร้างตามเงื่อนไข การคำนวณ การเปรียบเทียบตัวเลข สตริง และการค้นหาข้อมูลเกี่ยวกับไฟล์
2. Bash Scripting ตอนที่ 2 ทุบตีสุดยอด — นี่คือคุณสมบัติของการทำงานกับลูป for และ while ที่ถูกเปิดเผย
3. Bash Scripting ตอนที่ 3 พารามิเตอร์และตัวเลือก — เนื้อหานี้มีไว้สำหรับพารามิเตอร์บรรทัดคำสั่งและคีย์ที่สามารถส่งผ่านไปยังสคริปต์ได้ โดยทำงานกับข้อมูลที่ผู้ใช้ป้อนและสามารถอ่านได้จากไฟล์
4. Bash Scripting ตอนที่ 4 อินพุตและเอาต์พุต - ที่นี่เรากำลังพูดถึง file descriptor และการทำงานร่วมกับพวกมัน เกี่ยวกับอินพุต เอาต์พุต กระแสข้อผิดพลาด และเกี่ยวกับการเปลี่ยนเส้นทางเอาต์พุต
5. Bash Scripting ตอนที่ 5, Sighals และงาน — เนื้อหานี้มีไว้สำหรับสัญญาณ Linux การประมวลผลในสคริปต์ และการเรียกใช้สคริปต์ตามกำหนดเวลา
6. Bash Scripting ตอนที่ 6 ฟังก์ชั่น — คุณสามารถเรียนรู้เกี่ยวกับการสร้างและใช้งานฟังก์ชันในสคริปต์และการพัฒนาไลบรารีได้ที่นี่
7. Bash Scripting ตอนที่ 7 การใช้ sed — บทความนี้มีไว้สำหรับการทำงานกับโปรแกรมแก้ไขข้อความสตรีมมิ่ง sed
8. Bash Scripting ตอนที่ 8 การใช้ awk — เนื้อหานี้มีไว้สำหรับการเขียนโปรแกรมในภาษาประมวลผลข้อมูล awk
9. Bash Scripting ตอนที่ 9 นิพจน์ทั่วไป — คุณสามารถอ่านเกี่ยวกับการใช้นิพจน์ทั่วไปในสคริปต์ทุบตีได้ที่นี่
10. Bash Scripting ตอนที่ 10 ตัวอย่างเชิงปฏิบัติ — ต่อไปนี้เป็นเทคนิคในการทำงานกับข้อความที่สามารถส่งถึงผู้ใช้ได้ตลอดจนวิธีการตรวจสอบดิสก์
11. Bash Scripting ตอนที่ 11 คาดหวังคำสั่ง — เนื้อหานี้มีไว้สำหรับเครื่องมือ Expect โดยเฉพาะ ซึ่งคุณสามารถโต้ตอบกับยูทิลิตี้แบบโต้ตอบได้โดยอัตโนมัติ โดยเฉพาะอย่างยิ่ง เรากำลังพูดถึงสคริปต์คาดหวังและการโต้ตอบกับสคริปต์ทุบตีและโปรแกรมอื่นๆ

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

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

เฉพาะผู้ใช้ที่ลงทะเบียนเท่านั้นที่สามารถเข้าร่วมในการสำรวจได้ เข้าสู่ระบบ, โปรด.

ฉันควรแปลบทความที่เหลือในชุดนี้หรือไม่

• ใช่!

• ไม่จำเป็น

ผู้ใช้ 1030 คนโหวต ผู้ใช้ 106 รายงดออกเสียง

ที่มา: will.com