$ i=5;j=9423483247234;$ echo $i |. grep -q "^[0-9]$"$ echo $?0$ echo $j |. $ เสียงสะท้อน $?0
$ c="A"; d="fwefewjuew"; e="fewfEFWefwefe"$ echo $c |. grep -q "^[AZ]$"$ echo $d |. $ echo $e |. grep -q "^[a-zA-Z]+$"
$ ic="432fwfwefeFWEwefwef"$ echo $ic |. grep -q "^[0-9a-zA-Z]+$"
$ echo " " |. grep " "$ echo -e "t" |. grep "[[:space:]]" #[[:space:]] จะจับคู่ทั้งช่องว่างและคีย์ TAB $ echo -e " t" |. grep "[[:space:]]"$ echo -e "t" |. grep "" #หากต้องการกดปุ่ม TAB บนแป้นพิมพ์ ไม่ใช่ตัวอักษร
$ echo "[email protected]" |. grep "[0-9a-zA-Z.]*@[0-9a-zA-Z.]"[email protected]
$ echo "http://news.lzu.edu.cn/article.jsp?newsid=10135" | grep "^http://[0-9a-zA-Z./=?]+$"http //news.lzu.edu.cn/article.jsp?newsid=10135
แสดงให้เห็น:
/dev/nullและ
/dev/ศูนย์อุปกรณ์นี้น่าสนใจมาก มันเหมือนกับหลุมดำ อะไรก็ตามที่ตกลงไปจะหายไป
[[:ช่องว่าง:]]ใช่
เกรปเครื่องหมายที่ใช้จับคู่ช่องว่างหรืออักขระคีย์ TAB โปรดตรวจสอบความช่วยเหลือสำหรับเครื่องหมายอื่นๆ:
แมน เกรป
ทั้งหมดที่กล่าวมาถูกนำมาใช้
เกรปเพื่อทำการจับคู่รูปแบบจริงๆ
sed-
โอเคทั้งสองสามารถใช้สำหรับการจับคู่รูปแบบ สำหรับความรู้เกี่ยวกับนิพจน์ทั่วไปที่ใช้ในการจับคู่ โปรดดูข้อมูลที่เกี่ยวข้องด้านล่าง
หากคุณต้องการตรวจสอบว่าสตริงว่างเปล่าหรือไม่ คุณสามารถกำหนดได้ว่าความยาวของสตริงเป็นศูนย์หรือไม่
ทดสอบผู้บังคับบัญชา
-zตัวเลือกในการดำเนินการดูการใช้งานเฉพาะ
ทดสอบคำสั่ง,
การทดสอบของมนุษย์
$ echo "tn" |. grep "[[: พิมพ์:]]"$ เสียงสะท้อน $?1
นอกจากประเภทอักขระที่ประกอบเป็นสตริงแล้ว สตริงมีคุณสมบัติอื่นใดอีกบ้าง จำนวนอักขระที่ประกอบเป็นสตริง
ต่อไป เราจะคำนวณความยาวของสตริง ซึ่งก็คือจำนวนอักขระทั้งหมด และแนะนำวิธีการต่างๆ ในการค้นหาจำนวนอักขระที่ระบุในสตริงโดยย่อ
นั่นก็คือการนับจำนวนตัวอักษรทั้งหมดมีวิธีการคำนวณที่หลากหลายให้เลือกอันที่ดีที่สุดแล้วนำไปใช้:
$ var="get the length of me"$ echo ${var} # นี่เทียบเท่ากับ $varget ความยาวของฉัน$ echo ${#var}20$ expr length "$var"20$ echo $var awk ' { printf("%dn", length($0));}'20$ echo -n $var | wc -c20$ echo $var |.tr -cd g |. wc -c2$ echo -n $var -e 's/[^g]//g' | /[^gt]//g' |. wc -c5
สำหรับข้อมูลที่เกี่ยวข้องเพิ่มเติม โปรดดูตัวอย่างที่เกี่ยวข้องกับ สถิติ ใน "การคำนวณเชิงตัวเลข"
$ echo $var |. wc -w5$ echo "" "n" |. grep รับ |
แสดงให้เห็น:
-ผู้ดำเนินการเป็น "ชื่อใหญ่" ใน Bash และมีความสามารถในการทำงานค่อนข้างมาก โปรดดูรายละเอียดที่ "คำถามสิบสามข้อเกี่ยวกับเชลล์" ที่เขียนโดยใครบางคนบนอินเทอร์เน็ต
-และ
-นอกจาก
-ความแตกต่างคืออะไร? "บาร์.
ต่อไป เราจะพูดถึงวิธีควบคุมการแสดงอักขระในเทอร์มินัล
$ echo -e " 33[31;40m" #ตั้งค่าสีพื้นหน้าเป็นสีดำและสีพื้นหลังเป็นสีแดง $ echo -e " 33[11;29H สวัสดีชาวโลก!" #ในบรรทัดที่ 11 คอลัมน์ 29 ของ หน้าจอเริ่มพิมพ์สตริง Hello, World!
$ while :; do echo -e " 33[11;29H "$(date "+%Y-%m-%d %H:%M:%S");
ใช้
พ.อคำสั่งจะกรองอักขระควบคุมบางตัวเมื่อประมวลผล เช่น
สคริปต์-
หน้าจอสิ่งนี้มีประโยชน์เมื่อรอเอาต์พุตของคำสั่งสกรีนช็อต
$ screen -L$ cat /bin/cat$ exit$ cat screenlog.0 |. col -b # หลังจากกรองอักขระควบคุมบางตัวแล้ว คุณสามารถเก็บบันทึกการดำเนินการที่อ่านได้
ในความเห็นของเรา สตริงเป็นเพียงชุดอักขระ แต่เพื่อความสะดวกในการใช้งาน เรามักจะทำให้สตริงแสดงโครงสร้างบางอย่างได้ ที่นี่เราไม่สนใจเกี่ยวกับโครงสร้างการจัดเก็บข้อมูลที่แท้จริงของสตริงในหน่วยความจำ แต่จะสนใจเฉพาะโครงสร้างเชิงตรรกะที่แสดงเท่านั้น ตัวอย่างเช่น สตริงลักษณะนี้:
ได้ความยาวของฉัน"เราสามารถนำเสนอได้จากแง่มุมต่างๆ
แสดงอักขระตามตำแหน่งในสตริง
ด้วยวิธีนี้เราสามารถค้นหาสตริงย่อยโดยการระบุตำแหน่ง โดยปกติสามารถทำได้โดยใช้พอยน์เตอร์ในภาษา C ในการเขียนโปรแกรมเชลล์ มีเครื่องมือมากมายให้เลือกใช้ เช่น
หมดอายุ-
โอเคทั้งสองมีวิธีการที่คล้ายกันเพื่อใช้การดำเนินการสืบค้นสตริงย่อย ทั้งสองเกือบจะรองรับการจับคู่รูปแบบ
จับคู่และการทำงานแบบตรงทั้งหมด
ดัชนี- ซึ่งจะอธิบายรายละเอียดในภายหลังในการดำเนินการสตริง
รับแต่ละส่วนของสตริงตามตัวคั่นที่กำหนด
สิ่งที่พบบ่อยที่สุดในที่นี้คือตัวคั่นบรรทัด การเว้นวรรค หรือ
แท็บตัวคั่น แบบแรกถูกใช้เป็นหมายเลขบรรทัด ดูเหมือนว่าเราจะคุ้นเคยกับมันแล้ว เนื่องจากตัวแก้ไขของเราจัดการกับตัวแยกบรรทัดในลักษณะนี้ (ภายใต้ UNIX มันคือ
\nมีความแตกต่างบางประการในระบบอื่น เช่น ใน Windows
รn- และช่องว่างหรือ
แท็บคีย์มักใช้เพื่อแยกฟิลด์ในฐานข้อมูล และดูเหมือนว่าจะเป็นเรื่องปกติ
ด้วยเหตุนี้ จึงมีการผลิตเครื่องมือแก้ไขบรรทัดที่ยอดเยี่ยมจำนวนมาก เช่น
เกรป-
โอเค-
sedรอ. ในแง่ของการแยกสตริง "อินไลน์" (ลองใส่แบบนี้ หมายถึงการประมวลผลบรรทัดเดียว นั่นคือ สตริงไม่มีตัวคั่นบรรทัดอีกต่อไป)
ตัดและ
โอเคให้ความสามารถในการประมวลผลแบบ "อินไลน์" (การประมวลผลบรรทัดเดียว) ที่เหนือกว่ามาก
สะดวกกว่าในการประมวลผลส่วนต่าง ๆ โดยคั่นด้วยตัวคั่น
นอกจากนี้ยังใช้ตัวคั่นด้วย แต่เพื่อให้ใช้งานส่วนต่างๆ ของสตริงได้สะดวกยิ่งขึ้นหลังจากการแยก เราจึงสรุปโครงสร้างข้อมูลของ "อาร์เรย์" ซึ่งทำให้สะดวกยิ่งขึ้นสำหรับเราในการรับส่วนที่ระบุผ่านตัวห้อย
ทุบตีให้โครงสร้างข้อมูลดังกล่าวและยอดเยี่ยม
โอเคมีการจัดเตรียมไว้ด้วย และเราจะแนะนำการใช้งานโดยย่อที่นี่
โครงสร้างข้อมูลอาร์เรย์ที่ Bash จัดทำใช้ตัวเลขเป็นตัวห้อย ซึ่งเหมือนกับตัวห้อยที่เริ่มต้นจาก 0 ในภาษา C
$ var="get the length of me"$ var_arr=($var) #Store สตริง var ลงในอาร์เรย์สตริง var_arr โดยค่าเริ่มต้น ช่องว่างจะถูกใช้เป็นตัวคั่น 1 ]} ${var_arr[2]} ${var_arr[3]} ${var_arr[4]}รับความยาวของฉัน$ echo ${var_arr[@]} #สำหรับสตริงทั้งหมด * สามารถใช้แทน @ ได้ ค่าเดียวกันด้านล่างจะได้รับความยาวของ me$ echo ${#var_arr[@]} #คล้ายกับการค้นหาความยาวของสตริง ตัวดำเนินการ `#` ก็สามารถเป็นได้เช่นกัน ใช้ค้นหาจำนวนองค์ประกอบอาร์เรย์ 5คุณยังสามารถกำหนดค่าให้กับองค์ประกอบอาร์เรย์ได้โดยตรง
$ var_arr[5]="new_element"$ echo ${var_arr[5]}6$ echo ${var_arr[5]}new_elementBash ยังมีฟังก์ชันการทำงานที่เหมือน "อาเรย์" อีกด้วย
สำหรับฉันในซึ่งสามารถรับส่วนต่าง ๆ ของสตริงได้อย่างง่ายดาย เช่น:
$ สำหรับฉันใน $var; ทำ echo -n $i"_";
โอเคอาร์เรย์ใน สนใจที่จะเปรียบเทียบกับ
ทุบตีความเหมือนและความแตกต่างของอาร์เรย์ใน
แยกแยกบรรทัดด้วยช่องว่างและจัดเก็บไว้ในอาร์เรย์
var_arrและส่งกลับความยาวอาร์เรย์ หมายเหตุ: ตัวห้อยขององค์ประกอบแรกที่นี่ไม่ใช่ 0 แต่เป็น 1
$ echo $var |. awk '{printf("%d %sn", split($0, var_arr, " "), var_arr[1]);}'5 รับที่จริงแล้วการดำเนินการข้างต้นมีความคล้ายคลึงกันมาก
โอเคฟังก์ชั่นการประมวลผลแถวของตัวเอง:
โอเคตามค่าเริ่มต้น บรรทัดจะถูกแบ่งออกเป็นหลายฟิลด์ตามช่องว่าง และสามารถส่งผ่านได้
$1-
2 ดอลลาร์-
$3``...ที่จะได้รับ
$0แสดงถึงทั้งบรรทัด
นี่.
เอ็นเอฟเป็นจำนวนฟิลด์ทั้งหมดในแถว ซึ่งคล้ายกับความยาวของอาร์เรย์ด้านบน นอกจากนี้ยังมีฟังก์ชันในการเข้าถึงสตริงผ่าน "ตัวห้อย" ที่คล้ายกัน
$ echo $var |. awk '{printf("%d | %s %s %s %s | %sn", NF, $1, $2, $3, $4, $5, $0);}'5 | ดูความยาวของฉัน | ดูความยาวของฉันโอเคฟังก์ชัน "อาร์เรย์" ของ
สำหรับอ้างโปรดทราบว่าสิ่งนี้และ
ทุบตีข้างใน
สำหรับไม่เหมือนกันซะทีเดียว
ฉันไม่ใช่องค์ประกอบเอง แต่เป็นตัวห้อย:
$ echo $var |. awk '{split($0, var_arr, " "); for(i in var_arr) printf("%s ",var_arr[i]);}' ของฉันได้ความยาว 4 5 1 2 3นอกจากนี้จะเห็นได้จากผลลัพธ์ข้างต้นหลังจากนั้น
สำหรับหลังจากการประมวลผล ผลลัพธ์ทั้งหมดจะไม่ถูกจัดเรียงตามลำดับอักขระหลัก แต่จะมีความหมายเช่นกันหากเพียงวนซ้ำองค์ประกอบทั้งหมด
โอเคนอกจากนี้ยังมีพลังการประมวลผลที่ "ทรงพลัง" มากกว่า ตัวห้อยไม่สามารถเป็นตัวเลขได้ แต่เป็นสตริง จึงกลายเป็น "การเชื่อมโยง" นี้สะดวกมากในบางด้าน ตัวอย่างเช่น หากต้องการแทนที่ชื่อการเรียกของระบบในไฟล์ด้วยที่อยู่ตามตารางการแมปที่อยู่ฟังก์ชันในไฟล์อื่น คุณสามารถทำได้ดังนี้:
$ cat symbolsys_exitsys_readsys_close$ ls /boot/System.map*$ awk '{if(FILENAME ~ "System.map") map[$3]=$1; else {printf("%sn", แผนที่[$1])} }' /boot/System.map-2.6.20-16-generic สัญลักษณ์c0129a80c0177310c0175d80นอกจากนี้ awk ยังรองรับการใช้ฟังก์ชันลบเพื่อลบองค์ประกอบอาร์เรย์ หากจำเป็นในบางสถานการณ์ อย่าลืมว่า awk รองรับอาร์เรย์สองมิติด้วย
การดำเนินการสตริงรวมถึงการเรียกสตริงย่อย การสืบค้นสตริงย่อย การแทรกสตริงย่อย การลบสตริงย่อย การแทนที่สตริงย่อย การเปรียบเทียบสตริงย่อย การเรียงลำดับสตริงย่อย การแปลงเลขฐานสิบหกของสตริงย่อย การแปลงการเข้ารหัสสตริงย่อย ฯลฯ
วิธีการหลักในการรับสตริงย่อยคือ:
ไปที่ตำแหน่งที่ระบุโดยตรงเพื่อค้นหาสตริงย่อย
การจับคู่อักขระเพื่อค้นหาสตริงย่อย
เช่น จะเริ่มตรงไหน และต้องใช้กี่ตัวอักษร?
$ var="get the length of me"$ echo ${var:0:3}get$ echo ${var:(-2)} # ในทิศทางตรงกันข้าม me$ echo `expr substr "$var" 5 3` # อย่าลืมใส่เครื่องหมายคำพูด $var ไม่เช่นนั้น expr จะแยกวิเคราะห์ข้อผิดพลาดเนื่องจากการเว้นวรรค the$ echo $var |.โอเคมัด
$varแยกออกเป็นหลายตัวแปรตามช่องว่างตามลำดับ
$1-
2 ดอลลาร์-
$3-
$4-
$5
$ echo $var |. awk '{printf("%sn", $1);}'get$ echo $var |. awk '{printf("%sn", $5);}'meเกือบละเว้น
ตัดเครื่องมือเล็กๆ ที่คล้ายกับ awk
-dระบุตัวคั่น เช่นเดียวกับใน
โอเคใช้
-ฟตัวคั่นที่ระบุจะเหมือนกัน
-ฉระบุ "โดเมน" เช่น awk's
$หมายเลข-
$ echo $var | . ตัด -d" " -f 5
ใช้การสนับสนุนในตัวของ Bash เพื่อค้นหาสตริง:
$ echo ${var%% *} #เริ่มจากทางขวาและลบอักขระทั้งหมดทางด้านขวาของช่องว่างซ้ายสุด get$ echo ${var% *} #เริ่มจากทางขวาและลบอักขระทั้งหมดทางด้านขวาของช่องว่างแรก รับความยาวของ$ echo ${var##* } #เริ่มจากด้านซ้ายและลบอักขระทั้งหมดทางซ้ายของช่องว่างขวาสุด me$ echo ${var#* } #เริ่มจากด้านซ้ายและลบอักขระทั้งหมดทางด้านซ้าย ช่องว่างแรกเท่ากับความยาวของฉันลบทั้งหมด
การผสมช่องว่าง + ตัวอักษรสตริง:
$ echo $var | .sed 's/ [az]*//g'get$ echo $var |
sedมีฟังก์ชั่นพิมพ์ (p) ตามที่อยู่ (บรรทัด) อย่าลืมนำไปใช้ก่อน
ตรแทนที่ช่องว่างด้วยหมายเลขบรรทัด:
$ echo $var |.tr " " "n" |
ตรนอกจากนี้ยังสามารถใช้เพื่อรับสตริงย่อยได้อีกด้วย
-และ
-หากต้องการ "ลบ" สตริงบางส่วนเพื่อให้ได้สตริงย่อย:
$ echo $var |. tr -d " "getthelengthofme$ echo $var |. "[az]" #ลบช่องว่างทั้งหมดและเก็บเฉพาะสตริงตัวอักษรไว้
แสดงให้เห็น:
-และ
-คำแนะนำในการลบอักขระจะแตกต่างกัน ตัวแรกอยู่ทางขวา และตัวหลังอยู่ทางซ้าย
-และ
--
-และ
-ทิศทางคือคู่แรกคือคู่สูงสุด และคู่หลังคือคู่ขั้นต่ำ (สำหรับวิธีหน่วยความจำที่ดี โปรดดูวิธีหน่วยความจำแป้นพิมพ์ของผู้คนบนอินเทอร์เน็ต:
--
--
-คือปุ่มสามปุ่มบนคีย์บอร์ดจากซ้ายไปขวา)
ตรของ
-คตัวเลือกคือ
เสริมคำย่อของ
พลิกกลับ,และ
-dตัวเลือกคือลบ
tr -cd "[az]"ซึ่งจะเก็บตัวอักษรทั้งหมดไว้
สำหรับการสกัดกั้นสตริง จริงๆ แล้วมีคำสั่งบางคำสั่ง
ศีรษะ-
หางคุณสามารถใช้ฟังก์ชันที่น่าสนใจได้โดยการดักจับจำนวนบรรทัดหรือไบต์ที่ระบุทั้งด้านหน้าและด้านหลังสตริง ตัวอย่างเช่น:
$ echo "abcdefghijk" | .head -c 4abcd$ echo -n "abcdefghijk" | . หาง -c 4hijk
แบบสอบถามสตริงย่อยรวมถึง:
ส่งกลับสตริงย่อยที่ตรงกับรูปแบบ
ส่งกลับตำแหน่งของสตริงย่อยในสตริงเป้าหมาย
การเตรียมการ: ก่อนดำเนินการต่อไปนี้ โปรดเตรียมไฟล์ test.txt ซึ่งมีเนื้อหา "ประกอบด้วย" สำหรับตัวอย่างต่อไปนี้
ดัชนี exprดูเหมือนว่าจะสามารถคืนตำแหน่งที่อักขระตัวแรกของอักขระบางตัวหรืออักขระหลายตัวปรากฏขึ้นเท่านั้น
$ var="get the length of me"$ expr index "$var" t3
awk สามารถค้นหาสตริงได้ และการจับคู่ก็สามารถจับคู่นิพจน์ทั่วไปได้เช่นกัน
$ echo $var |. awk '{printf("%dn", match($0,"the"));}'5โอเค-
sedฟังก์ชั่นเหล่านี้สามารถรับรู้ได้แต่
เกรปดีที่สุดที่
$ grep "consists of" test.txt # ค้นหาบรรทัดที่ไฟล์มี "ประกอบด้วย" และพิมพ์บรรทัดเหล่านี้ $ grep "consists[[:space:]]of" -n -H test.txt # พิมพ์ชื่อไฟล์ และตำแหน่งของสตริงย่อย หมายเลขบรรทัดของบรรทัดและเนื้อหาของบรรทัด $ grep "consists[[:space:]]of" -n -o test.txt # พิมพ์เฉพาะหมายเลขบรรทัดและเนื้อหาของบรรทัดที่ตรงกัน สตริงย่อยเอง $ awk '/ประกอบด้วย of/{ printf("%s:%d:%sn",FILENAME, FNR, $0)}' test.txt #เห็นไหม? ผลลัพธ์จะเหมือนกับ grep $ sed -n -e '/consists of/=;/consists of/p' test.txt #เลขบรรทัดก็พิมพ์ได้เช่นกันแสดงให้เห็น:
โอเค-
เกรป-
sedทั้งสองสามารถค้นหาสตริงที่ระบุผ่านการจับคู่รูปแบบได้ แต่แต่ละสตริงมีจุดแข็งของตัวเอง เราจะใช้และเปรียบเทียบสตริงเหล่านั้นในบทต่อๆ ไปเพื่อค้นหาข้อดีของมันเอง
เราจะถือว่าเนื้อหาไฟล์เป็นสตริงขนาดใหญ่ที่นี่ การดำเนินการกับไฟล์จะถูกนำมาใช้โดยเฉพาะในบทต่อไปนี้ ดังนั้นจะมีการวิเคราะห์เชิงลึกเพิ่มเติมและคำแนะนำเบื้องต้นเกี่ยวกับการดำเนินการจัดเก็บสตริงในเนื้อหาไฟล์
การแทนที่สตริงย่อยคือการแทนที่สตริงย่อยที่ระบุด้วยสตริงอื่น ซึ่งรวมถึงการดำเนินการของ "แทรกสตริงย่อย" และ "ลบสตริงย่อย" ตัวอย่างเช่น หากคุณต้องการแทรกสตริงก่อนสตริงย่อย คุณสามารถแทนที่สตริงย่อยเดิมด้วย "สตริงย่อย + สตริงใหม่" หากคุณต้องการลบสตริงย่อย ให้แทนที่สตริงย่อยด้วยสตริงว่าง อย่างไรก็ตาม เครื่องมือบางอย่างมีการใช้งานพิเศษบางอย่างสำหรับการแทรกและการลบสตริงย่อย ดังนั้นฉันจะแนะนำเครื่องมือเหล่านี้โดยเฉพาะ นอกจากนี้ หากคุณต้องการแทนที่สตริงย่อยบางรายการ คุณมักจะค้นหาสตริงย่อยก่อน (ค้นหาสตริงย่อย) แล้วจึงแทนที่ ที่จริงแล้ว เครื่องมือจำนวนมากสะท้อนถึงสิ่งนี้ในการใช้งานและการออกแบบ
ใช้
-โอเปอเรเตอร์ จำได้ไหม? บทเรียนจากผู้คนบนอินเทอร์เน็ต
$ var="get the length of me"$ echo ${var/ /_} #แทนที่ช่องว่างแรกด้วยขีดล่าง get_the length of me$ echo ${var// /_} #แทนที่ช่องว่างทั้งหมดด้วยขีดล่าง get_the_length_of_meใช้
โอเค-
โอเคให้ฟังก์ชันการแทนที่ขั้นต่ำสำหรับการแปลง
ย่อยและฟังก์ชันการทดแทนส่วนกลาง
gsub,คล้ายกัน
-และ
-
$ echo $var |.awk '{sub(" ", "_", $0); printf("%sn", $0);}'get_the ความยาวของฉัน$ echo $var |. , "_", $0); printf("%sn", $0);}'get_the_length_of_meใช้
sed, การแทนที่สตริงย่อยสามารถทำได้
sedความเชี่ยวชาญ:
$ echo $var |. sed -e 's/ /_/' #s <= substitudeget_the length of me$ echo $var | sed 's/ /_/g' #ดูว่าคุณทำได้ เพียงสองคำสั่งสั้นๆ บรรลุมัน การจับคู่ขั้นต่ำและการจับคู่สูงสุด g <= globalget_the_length_of_me
ลืมไปแล้ว
ตรคำสั่ง? คุณสามารถแทนที่อักขระตัวเดียวด้วย:
$ echo $var |. tr " " "get_the_length_of_me$ echo $var |. tr '[az]' '[AZ]' #น่าสนใจ แทนที่อักษรตัวพิมพ์เล็กทั้งหมดด้วยตัวพิมพ์ใหญ่ GET THE LENGTH OF ME
แสดงให้เห็น:
sedนอกจากนี้ยังมีการใช้แท็กที่น่าสนใจอีกด้วย ซึ่งผมจะแนะนำด้านล่าง
การแทนที่สตริงที่น่าสนใจอีกอย่างหนึ่งคือการกลับบรรทัดของไฟล์ทั้งหมด ซึ่งสามารถทำได้โดย
แทคการใช้คำสั่งมันจะกลับบรรทัดทั้งหมดในไฟล์ ในแง่หนึ่ง การเรียงลำดับเป็นการแทนที่สตริงจริงๆ
แทรกสตริงย่อยในตำแหน่งที่ระบุ ตำแหน่งนี้อาจเป็นตำแหน่งของสตริงย่อยบางตัว หรืออาจเป็นความยาวที่กำหนดจากจุดเริ่มต้นของไฟล์ จากแบบฝึกหัดข้างต้น เราพบว่าทั้งสองมีความคล้ายคลึงกันจริงๆ
สูตร: ใส่สตริงย่อย = แทนที่ "สตริงย่อยเก่า" ด้วย "สตริงย่อยเก่า+สตริงย่อยใหม่" หรือ "สตริงย่อยใหม่+สตริงย่อยเก่า"
ใช้{}:
$ var="get the length of me"$ echo ${var/ /_ } #Insert a string before the specified string get_ the length of me$ echo ${var// /_ }get_ the_ length_ of_ me$ echo $ {var/ / _} #ใส่สตริงหลังสตริงที่ระบุ get _the length of me$ echo ${var// / _}get _the _length _of _meคุณยังต้องสาธิตให้คนอื่นเห็นอีกไหม? ที่นี่เราจะแนะนำวิธีการใช้ sed เพื่อแทรกอักขระเป็นหลัก เนื่องจากฟังก์ชันป้ายกำกับน่าสนใจมาก:
-และ
-เก็บสตริงที่ไม่ตรงกันเป็นป้ายกำกับ ตามลำดับที่ตรงกัน:
1-
2-
$ echo $var | .sed -e 's/( )/_1/'get_ ความยาวของฉัน$ echo $var | sed 's/( )/_1/g'get_ the_ length_ of_ me$ echo $var |.sed -e 's/( )/1_/'get _the ความยาวของฉัน$ echo $var | sed -e 's/( )/1_/g'get _ความยาว_ของ_ฉัน
ดูสิ
sedลำดับของแท็กไม่ได้
1-
2..., ดู?
2และ
1หลังจากเปลี่ยนตำแหน่งแล้ว
ที่และ
รับตำแหน่งที่มีการเปลี่ยนแปลง:
$ echo $var |.sed 's/([az]*) ([az]*) /2 1 /g'ความยาวของฉัน
sedนอกจากนี้ยังมีคำแนะนำการแทรกพิเศษ
กและ
ฉันตามลำดับโดยระบุการแทรกอักขระที่ระบุหลังบรรทัดที่ตรงกันและก่อนบรรทัด
$ echo $var |. sed '/get/a test'get ความยาว metest$ echo $var |
การลบสตริงย่อย: มันควรจะง่ายมาก การแทนที่สตริงย่อยด้วย "ว่างเปล่า" (ไม่มีเลย) หมายถึงการลบ มาทบทวนการทดแทนโดยย่อ
กำลังใจ : ไม่รู้จะเปลี่ยนเป็นคำไหน ใครจะรู้? แต่ภาษาจีนมีความเชื่อมโยงเข้าด้วยกัน คุณเคยคิดบ้างไหมว่าภาษาจีนนั้นยากแค่ไหน? ปรากฎว่าคุณเป็นอัจฉริยะด้านภาษาเช่นกัน และภาษาอังกฤษก็ไม่ได้แย่นัก ตราบใดที่คุณมีความตั้งใจ
ใช้ซ้ำ
-
$ echo ${var// /}getthelengthofmeใช้ซ้ำ
โอเค
$ echo $var |.awk '{gsub(" ","",$0); printf("%sn", $0);}'ใช้ซ้ำ
sed
$ echo $var | .sed 's/ //g'getthelengthofme
มีง่ายกว่า
ตรคำสั่ง,
ตรคุณยังสามารถลบช่องว่างได้ ดู
$ echo $var |.tr -d ""getthelengthofme
จะทำอย่างไรถ้าคุณต้องการลบสตริงทั้งหมดหลังจากช่องว่างแรก? ยังจำได้
-ของ
-และ
-การใช้งาน? หากคุณจำไม่ได้ ให้กลับไปที่จุดเริ่มต้นของส่วนนี้และเริ่มทบทวน (ในความเป็นจริง การลบสตริงย่อยและการรับสตริงย่อยเป็นการดำเนินการเสริมสองประการ การลบสตริงย่อยที่ไม่ต้องการบางส่วนจะได้รับสตริงย่อยอื่นที่ต้องการในเวลาเดียวกัน - โลกนี้เป็นโลก "ไบนารี" น่าสนใจมาก)
อันนี้ง่าย: จำไว้
ทดสอบจะใช้คำสั่งอย่างไร?
การทดสอบของมนุษย์- สามารถใช้เพื่อกำหนดว่าสองสายเท่ากันหรือไม่ นอกจากนี้ยังมี "ว่าสตริงจะเท่ากันหรือไม่" และ "ว่าสตริงจะตรงกับสตริงอื่นหรือไม่"
-มีความสัมพันธ์ระหว่างสองคำถามนี้หรือไม่? สองสตริงจะเท่ากันหากตรงกันทุกประการ ดังนั้น สามารถใช้วิธีจับคู่สตริงที่ใช้ด้านบนได้ที่นี่เช่นกัน
ฉันเกือบลืมเนื้อหาที่สำคัญนี้ไปแล้ว การเรียงลำดับสตริงย่อยมักใช้กันเช่น ลำดับตัวอักษร ลำดับตัวเลข ฯลฯ ลำดับบวกหรือลบ
เรียงลำดับคำสั่งสามารถใช้เพื่อทำงานนี้ได้ เช่นเดียวกับคำสั่งประมวลผลบรรทัดอื่น ๆ คำสั่งนี้ทำงานบนพื้นฐานบรรทัด
ตัดและ
โอเคคุณสามารถระบุตัวคั่นและระบุคอลัมน์ที่จะเรียงลำดับได้
$ var="get the length of me"$ echo $var |. sort -r #การเรียงลำดับแบบย้อนกลับ getlengthmeofthe$ echo $var | > ข้อมูล.txt1 2 3 4 5 6 7 8 9 10 11 12 13 14 1541 45 44 44 26 44 42 20 20 38 37 25 45 45 4516 17 18 19 20 21 22 23 24 25 26 27 28 29 3044 20 30 39 35 38 38 28 25 30 36 20 24 32 3331 32 33 34 35 36 37 38 39 40 41 42 43 44 4541 33 51 39 20 20 44 37 38 39 42 40 37 50 5046 47 48 49 50 51 52 53 54 55 5642 43 41 42 45 42 19 39 75 17 17$ cat data.txt | sort -k 2 -n1 2 3 4 5 6 7 8 9 10 11 12 13 14 1516 17 18 19 20 21 22 23 24 25 26 27 28 29 3044 20 30 39 35 38 38 28 25 30 36 20 24 32 3331 32 33 34 35 36 37 38 39 40 41 42 43 44 4541 33 51 39 20 20 44 37 38 39 42 40 37 50 5042 43 41 42 45 42 19 39 75 17 1741 45 44 44 26 44 42 20 20 38 37 25 45 45 4546 47 48 49 50 51 52 53 54 55 56
หากใช้อักขระตัวอักษรและตัวเลขในการนับ แสดงว่ามีปัญหากับการแปลงฐาน ในส่วน "การคำนวณเชิงตัวเลข" ได้มีการแนะนำแล้ว
ก่อนคริสต์ศักราชคำสั่ง, ทบทวนได้ที่นี่.
$ echo "ibase=10;obase=16;10" |.bcA
แสดงให้เห็น:
ไอเบสระบุฐานอินพุต
อ้วนระบุฐานเอาต์พุตดังนั้นโดยการปรับ
ไอเบสและ
อ้วนคุณสามารถหมุนมันได้ตามที่คุณต้องการ!
การเข้ารหัสอักขระคืออะไร? สิ่งนี้ไม่จำเป็นต้องมีการแนะนำ คุณเคยเห็นหน้าเว็บเหล่านั้นแสดงอย่างยุ่งเหยิงหรือไม่? โดยส่วนใหญ่มีสาเหตุมาจากความไม่สอดคล้องกันระหว่าง "การเข้ารหัส" ที่เบราว์เซอร์ใช้และ "การเข้ารหัส" จริงที่ใช้โดยหน้าเว็บ การเข้ารหัสอักขระมักจะหมายถึงการแปลงลำดับของอักขระที่ "พิมพ์ได้" เป็นการแทนไบนารี ในขณะที่การถอดรหัสอักขระจะดำเนินการกระบวนการตรงกันข้าม หากทั้งสองกระบวนการไม่ตรงกัน สิ่งที่เรียกว่า "อักขระที่อ่านไม่ออก" จะปรากฏขึ้น
เพื่อแก้ปัญหา "รหัสที่อ่านไม่ออก"? จำเป็นต้องมีการแปลงการเข้ารหัส ภายใต้ Linux เราสามารถใช้ได้
ไอคอนวีเครื่องมือนี้ใช้เพื่อดำเนินการที่เกี่ยวข้อง สถานการณ์นี้มักเกิดขึ้นเมื่อย้ายไฟล์ระหว่างระบบปฏิบัติการที่แตกต่างกันและแลกเปลี่ยนไฟล์ระหว่างโปรแกรมแก้ไขต่างๆ ในปัจจุบัน การเข้ารหัสอักขระภาษาจีนที่ใช้กันทั่วไปใน Windows คือ
gb2312ในขณะที่ใช้ Linux ส่วนใหญ่จะใช้งาน
utf8-
$ nihao_utf8=$(echo "สวัสดี")$ nihao_gb2312=$(echo $nihao_utf8 | iconv -f utf8 -t gb2312)
ในความเป็นจริง เมื่อเขียนโปรแกรมใน Bash คุณใช้เวลาส่วนใหญ่ในการประมวลผลสตริง ดังนั้นจึงเป็นเรื่องสำคัญมากที่จะต้องเชี่ยวชาญส่วนนี้
ที่อยู่ URL (URL (Uniform Resource Locator: Uniform Resource Locator) คือที่อยู่ของหน้า WWW) แทบจะเป็นเพื่อนเล่นในชีวิตประจำวันของเราแล้ว ที่อยู่ URL ความถูกต้อง สกัดกั้นส่วนต่างๆ ของที่อยู่ (ประเภทเซิร์ฟเวอร์ ที่อยู่เซิร์ฟเวอร์ พอร์ต เส้นทาง ฯลฯ) และดำเนินการเพิ่มเติมในแต่ละส่วน
มาจัดการกับที่อยู่ URL นี้โดยละเอียด: ftp://anonymous:[email protected]/software/scim-1.4.7.tar.gz
$ url="ftp://anonymous:[email protected]/software/scim-1.4.7.tar.gz"
จับคู่ที่อยู่ URL และกำหนดความถูกต้องของที่อยู่ URL
$ echo $url |. grep "ftp://[az]*:[az]*@[az./-]*"
ประเภทเซิร์ฟเวอร์สกัดกั้น
$ echo ${url%%:*}ftp$ echo $url |. ตัด -d:: -f 1ftpสกัดกั้นชื่อโดเมน
$ tmp=${url##*@} ; echo ${tmp%%/*}mirror.lzu.edu.cnตัดเส้นทาง
$ tmp=${url##*@} ; echo ${tmp%/*}mirror.lzu.edu.cn/softwareชื่อไฟล์สกัดกั้น
$ ชื่อฐาน $urlscim-1.4.7.tar.gz$ echo ${url##*/}scim-1.4.7.tar.gzประเภทไฟล์สกัดกั้น (นามสกุล)
$ echo $url |.sed -e 's/.*[0-9].(.*)/1/g'tar.gz
ขั้นแรกให้เตรียมไฟล์ทดสอบ README
บทที่ 7 -- แบบฝึกหัด 7.1 โปรดรันโปรแกรม: mainwithoutreturn และพิมพ์ค่าที่ส่งคืนด้วยคำสั่ง "echo $?" จากนั้นเปรียบเทียบการส่งคืนของฟังก์ชัน printf ทั้งสองค่าจะเหมือนกัน 7.2 ขึ้นอยู่กับ โหมดการดำเนินการ แบบโต้ตอบหรือการเปลี่ยนเส้นทางไปยังไฟล์ หากเป็นแบบโต้ตอบ การดำเนินการ "เอาต์พุต" จะเกิดขึ้นหลังจาก n อักขระด้วยโหมด linebuffer มิฉะนั้น จะถูก "พิมพ์" จริง ๆ หลังจากสตริงทั้งหมดแล้ว ยังคงอยู่ในบัฟเฟอร์ 7.3 ไม่มีวิธีอื่นที่มีประสิทธิภาพในระบบปฏิบัติการส่วนใหญ่เนื่องจาก argc และ argv ไม่ใช่ตัวแปรระดับโลกเช่นสภาพแวดล้อม
จากนั้นจึงเริ่มทดลอง
ก่อนพิมพ์คำตอบให้ระบุช่วงบรรทัด : บรรทัด 7 ถึงบรรทัด 9 เพิ่งเจอคำตอบข้อ 2
$ sed -n 7,9p README7.2 มันจะขึ้นอยู่กับโหมดการดำเนินการ การโต้ตอบหรือการเปลี่ยนเส้นทางไปยังไฟล์ หากการโต้ตอบ การดำเนินการ "เอาต์พุต" จะเกิดขึ้นหลังจาก n ถ่านด้วยโหมด linebuffer มิฉะนั้นจะเป็น "พิมพ์" จริงๆ หลังจากที่สตริงทั้งหมดมีแล้ว
เนื่องจากรูปแบบเนื้อหาของไฟล์นี้มีเอกลักษณ์เฉพาะตัวมาก จึงมีวิธีที่ง่ายกว่านี้
$ awk '/7.2/,/^$/ {printf("%sn", $0);}' README7.2 ขึ้นอยู่กับโหมดการดำเนินการ การโต้ตอบ หรือการเปลี่ยนเส้นทางไปยังไฟล์ หากโต้ตอบ "เอาต์พุต " การกระทำจะเกิดขึ้นหลังจาก n ถ่านด้วยโหมด linebuffer ไม่เช่นนั้น จะถูก "พิมพ์" จริงๆ หลังจากที่สตริงทั้งหมดยังคงอยู่ในบัฟเฟอร์ด้วยความรู้ข้างต้น คุณสามารถทำงานเหล่านี้ได้อย่างง่ายดาย: แก้ไขชื่อไฟล์ของไฟล์ เช่น การปรับการเข้ารหัส การดาวน์โหลดไฟล์ทั้งหมดในหน้าเว็บ
เมื่อฉันทำงานปกติ ส่วนใหญ่ฉันจะจัดการกับข้อความที่ "จัดรูปแบบ" เช่น ข้อความประมาณนั้น
/etc/passwdข้อความที่มีแถวและคอลัมน์คงที่ก็คล้ายกันเช่นกัน
ต้นไม้ชนิดของข้อความที่มีโครงสร้างแบบต้นไม้ที่คำสั่งส่งออก และแน่นอนว่าเป็นข้อความอื่นๆ ที่มีโครงสร้างเฉพาะ
เกี่ยวกับการประมวลผลข้อความที่มีโครงสร้างแบบต้นไม้ คุณสามารถอ้างถึงโพสต์บล็อกอื่นที่ฉันเขียนไว้ก่อนหน้านี้: การวิเคราะห์ซอร์สโค้ด: การวิเคราะห์แบบคงที่ แผนภาพการเรียกฟังก์ชันโปรแกรม C
ในความเป็นจริง ตราบใดที่คุณเข้าใจลักษณะบางอย่างของโครงสร้างลักษณะเฉพาะและตามการใช้งานเฉพาะ การจัดการกับมันก็จะไม่ใช่เรื่องยาก
ต่อไปนี้จะแนะนำการทำงานของข้อความเฉพาะ
/etc/passwdไฟล์เป็นตัวอย่าง หากต้องการความช่วยเหลือและการใช้งานไฟล์นี้ โปรดไปที่
คนที่ 5 รหัสผ่านตรวจสอบ. มาดำเนินการที่มีความหมายกับไฟล์นี้และไฟล์ที่เกี่ยวข้องกัน
เลือกคอลัมน์ชื่อผู้ใช้และ ID กลุ่มในไฟล์ /etc/passwd
$ cat /etc/passwd | .cut -d: -f1,4
เลือกคอลัมน์ชื่อกลุ่มและ ID กลุ่มในไฟล์ /etc/group
$ cat /etc/group | .cut -d: -f1,3
จะทำอย่างไรถ้าคุณต้องการทราบว่าผู้ใช้ทั้งหมดอยู่ในกลุ่มใด
$ เข้าร่วม -o 1.1,2.1 -t: -1 4 -2 3 /etc/passwd /etc/grouproot:rootbin:bindaemon:daemonadm:admlp:lppop:popnobody:nogroupfalcon:users
แสดงให้เห็น:
เข้าร่วมคำสั่งนี้ใช้เพื่อเชื่อมต่อสองไฟล์ซึ่งค่อนข้างคล้ายกับการเชื่อมต่อของสองตารางในฐานข้อมูล
-ทีระบุตัวคั่น
-1 4 -2 3ระบุกลุ่มตามคอลัมน์ 4 ของไฟล์แรกและคอลัมน์ 3 ของไฟล์ที่สอง
บัตรประจำตัวประชาชนเพื่อเชื่อมต่อ
-o``1.1,2.1หมายความว่ามีเพียงคอลัมน์แรกของไฟล์แรกและคอลัมน์แรกของไฟล์ที่สองเท่านั้นที่จะส่งออก เพื่อให้เราได้ผลลัพธ์ที่เราต้องการ อย่างไรก็ตาม น่าเสียดายที่ผลลัพธ์นี้ไม่ถูกต้อง หากคุณดำเนินการต่อไปนี้ คุณจะพบกับ:
$ cat /etc/passwd |. sort -t: -n -k 4 > /tmp/passwd$ cat /etc/group |. sort -t: -n -k 3 > /tmp/group$ เข้าร่วม -o 1.1,2.1 -t: -1 4 -2 3 /tmp/passwd /tmp/grouphalt:rootoperator:rootroot:rootshutdown:rootsync:rootbin:bindaemon:daemonadm:admlp:lppop:popnobody:nogroupfalcon:usersgames:users
คุณจะเห็นว่าผลลัพธ์นี้ถูกต้อง ดังนั้นจึงใช้มันในอนาคต
เข้าร่วมโปรดใส่ใจกับปัญหานี้ ไม่เช่นนั้นการใช้แนวทางอนุรักษ์นิยมมากขึ้นจะช่วยให้มั่นใจถึงความถูกต้องได้ดีกว่า สำหรับการสนทนาเพิ่มเติมเกี่ยวกับการเชื่อมต่อไฟล์ โปรดดูข้อมูลในภายหลัง
ข้างต้นเกี่ยวข้องกับการประมวลผลคอลัมน์ที่ระบุในแถวที่จัดรูปแบบ รวมถึงการสกัดกั้น (เช่น
SQLของ
เลือกการใช้งาน) การเชื่อมต่อ (เช่น
SQLของ
เข้าร่วมการใช้งาน) การเรียงลำดับ (เช่น
SQLของ
สั่งซื้อโดยการใช้งาน) คุณสามารถแยกบรรทัดที่จัดรูปแบบได้โดยการระบุตัวคั่น นอกจากนี้ ยังมีวิธี "สกัดกั้น" หลายวิธีอีกด้วย
ตัด-
โอเคแม้จะผ่าน
ไอเอฟเอสระบุตัวคั่น
อ่านซึ่งสามารถทำได้ด้วยคำสั่ง เช่น:
$ IFS=///; cat /etc/group |. ในขณะที่อ่าน C1 C2 C3 C4;
ดังนั้นเมื่อทำความคุ้นเคยกับประเพณีเหล่านี้ งานของเราจะมีความยืดหยุ่นและน่าสนใจมาก
ณ จุดนี้ คุณต้องทำแบบฝึกหัดง่ายๆ วิธีแปลงชื่อผู้ใช้และ ID ผู้ใช้ที่สอดคล้องกับคอลัมน์เป็นแถว นั่นคือข้อมูลที่คล้ายกับข้อมูลต่อไปนี้:
$ cat /etc/passwd |. ตัด -d: -f1,3 --output-delimiter=" "root 0bin 1daemon 2
แปลงเป็น:
$ cat aroot bin daemon0 1 2
แล้วแปลงกลับต้องทำอย่างไร? จำสิ่งต่าง ๆ เช่น
ตร-
แปะ-
แยกและคำสั่งอื่นๆ ก็สามารถใช้ได้
วิธีการอ้างอิง:
การแปลงเชิงบวก: ขั้นแรกให้ดักคอลัมน์ชื่อผู้ใช้และบันทึกลงในไฟล์
ผู้ใช้แล้วสกัดกั้นผู้ใช้
บัตรประจำตัวประชาชนเงินฝาก
บัตรประจำตัวประชาชนแล้วใช้ทั้งสองไฟล์
วาง -sคำสั่งเชื่อมต่อเข้าด้วยกัน จึงทำให้การแปลงไปข้างหน้าเสร็จสมบูรณ์
การแปลงผกผัน: ใช้ผลลัพธ์ที่ได้รับจากการแปลงไปข้างหน้าเป็นอันดับแรก
แยก -1แยกเป็นสองไฟล์ จากนั้นใช้ไฟล์แยกสองไฟล์
ตรตัวคั่น
tแทนที่ด้วย
nใช้เท่านั้น
แปะคำสั่งเชื่อมต่อทั้งสองไฟล์เข้าด้วยกัน ดังนั้นจึงเสร็จสิ้นการแปลงแบบย้อนกลับ
"คู่มือการเขียนโปรแกรม Bash Script ขั้นสูง" ดำเนินการสตริงและระบุประเภทของตัวแปร
"เชลล์สิบสามคำถาม"
-และ
-นอกจาก
-ความแตกต่างคืออะไร?
นิพจน์ทั่วไป - คู่มือผู้ใช้
บทช่วยสอนนิพจน์ปกติ
บทช่วยสอน Grep
สอนเซด
awkTutorial
sedTutorial
ไพรเมอร์ที่น่ากลัว
ที่มาของชื่อคำสั่ง UNIX แปลกๆ
ฝึกฝนทักษะของคุณในการสร้างรูปแบบการแสดงออกปกติ
พื้นฐาน 11: การจัดหมวดหมู่ไฟล์ การรวมและการแยก (เรียงลำดับ uniq รวม ตัด วาง แยก)
ลดความซับซ้อนในการแยกข้อมูลโดยใช้เครื่องมือข้อความ Linux
การอ้างอิงสคริปต์บรรทัดเดียว SED อย่างรวดเร็ว (Unix Stream Editor)
ส่วนนี้ควรจะแล้วเสร็จเมื่อสัปดาห์ที่แล้ว แต่ช่วงนี้ฉันยุ่งมาก ฉันเพิ่งเขียน "ฉบับร่างฉบับแรก" เท่านั้น และจะเพิ่มตัวอย่างเฉพาะเจาะจงเมื่อฉันมีเวลา ตัวอย่างในส่วนนี้น่าจะเป็นตัวอย่างที่น่าสนใจที่สุด ดังนั้นคุณควรศึกษาตัวอย่างที่น่าสนใจบางตัวอย่างอย่างละเอียด
ดูเหมือนว่าจะประมาณตี 1 เมื่อฉันเขียนส่วนข้างต้นเสร็จเมื่อสักครู่นี้
ตรวจสอบหลังจากตรวจสอบการพิมพ์ผิดและไวยากรณ์แล้ว ฉันก็เพิ่มส่วนอื่นคือ "โครงสร้างการจัดเก็บข้อมูลของสตริง" และตอนนี้ก็เกือบจะเสร็จแล้ว
2 ทุ่มครึ่งราตรีสวัสดิ์นะเพื่อนๆ
ในวันที่ 26 เพิ่มสองส่วน "การแปลงฐานสตริงย่อย" และ "การแปลงการเข้ารหัสสตริงย่อย" และการประมวลผล
URLตัวอย่างที่อยู่