คำสั่ง BASH ส่งออกไปยังตัวแปร

Bash Command Output Variable



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

ตัวแปร= $(สั่งการ)
ตัวแปร= $(สั่งการ [ตัวเลือก…]ข้อโต้แย้ง1 ข้อโต้แย้ง2…)
ตัวแปร= $(/เส้นทาง/ถึง/สั่งการ)

หรือ







ตัวแปร=``สั่งการ``
ตัวแปร=``สั่งการ [ตัวเลือก…]ข้อโต้แย้ง1 ข้อโต้แย้ง2…``
ตัวแปร=`/เส้นทาง/ถึง/สั่งการ``

***หมายเหตุ: อย่าเว้นวรรคก่อนและหลังเครื่องหมายเท่ากับเมื่อใช้คำสั่งข้างต้น



เอาต์พุตคำสั่งเดียวไปยังตัวแปร

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



ตัวอย่าง #1:

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





$วันที่ปัจจุบัน= $(วันที่)
$โยนออก 'วันนี้เป็น$current_date'

เอาท์พุท:



ตัวอย่าง #2:

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

$ปัจจุบัน_dir=``pwd``
$โยนออก 'ไดเรกทอรีปัจจุบันคือ:$ ปัจจุบัน_dir'

เอาท์พุท:

คำสั่งพร้อมตัวเลือกและอาร์กิวเมนต์

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

ตัวอย่าง #3:

ทุบตี ` ห้องน้ำ คำสั่งใช้เพื่อนับจำนวนบรรทัด คำ และอักขระทั้งหมดของไฟล์ใดๆ คำสั่งนี้ใช้ -c, -w และ -l เป็นตัวเลือกและชื่อไฟล์เป็นอาร์กิวเมนต์เพื่อสร้างเอาต์พุต สร้างไฟล์ข้อความชื่อ ผลไม้.txt ด้วยข้อมูลต่อไปนี้เพื่อทดสอบสคริปต์ถัดไป
ผลไม้.txt

ผลไม้.txt
มะม่วง
ส้ม
กล้วย
องุ่น
ฝรั่ง
แอปเปิ้ล

เรียกใช้คำสั่งต่อไปนี้เพื่อนับและเก็บจำนวนคำทั้งหมดใน ผลไม้.txt ไฟล์ลงในตัวแปร $count_words และพิมพ์ค่าโดยใช้ ` echo` สั่งการ.

$count_words=``ห้องน้ำ -ในผลไม้.txt``
$โยนออก 'จำนวนคำใน fruits.txt คือ$count_words'

เอาท์พุท:

ตัวอย่าง #4:

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

วันธรรมดา.txt

วันจันทร์
วันอังคาร
วันพุธ
วันพฤหัสบดี
วันศุกร์
วันเสาร์
วันอาทิตย์

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

cmdsub1.sh

#!/bin/bash
ชื่อไฟล์='วันธรรมดา.txt'
ในขณะที่ อ่านไลน์;ทำ
วัน=``โยนออก $line | ตัด -ค 1-3``
ถ้า [ $วัน=='ดวงอาทิตย์' ]
แล้ว
โยนออก 'วันอาทิตย์เป็นวันหยุด'
อื่น
โยนออก $วัน
เป็น
เสร็จแล้ว<$ชื่อไฟล์

เรียกใช้สคริปต์

$แมววันธรรมดา.txt
$ทุบตีcmdsub1.sh

เอาท์พุท:

การใช้การแทนที่คำสั่งในลูป

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

ตัวอย่าง #5:

สร้างไฟล์ชื่อ cmdsub2.sh ด้วยรหัสต่อไปนี้ ที่นี่ ` ลส -d * / คำสั่ง ` ใช้เพื่อดึงรายการไดเร็กทอรีทั้งหมดจากไดเร็กทอรีปัจจุบัน For loop ใช้ที่นี่เพื่ออ่านแต่ละไดเร็กทอรีจากเอาต์พุตและเก็บไว้ในตัวแปร $dirname ซึ่งจะพิมพ์ในภายหลัง

cmdsub2.sh

#!/bin/bash
สำหรับ dirname ใน$(ลส -NS * /)
ทำ
โยนออก '$dirname'
เสร็จแล้ว

เรียกใช้สคริปต์

$ทุบตีcmdsub2.sh

เอาท์พุท:

การใช้คำสั่งซ้อน

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

ไวยากรณ์คำสั่งซ้อน:

ที่ไหน=``คำสั่ง1 ``สั่งการ``

ตัวอย่าง #6:

สองคำสั่ง ` โยนออก ` และ ` ใคร ` ใช้ในตัวอย่างนี้เป็นคำสั่งที่ซ้อนกัน ที่นี่ ` ใคร คำสั่ง ` จะดำเนินการก่อนที่พิมพ์ข้อมูลผู้ใช้ของผู้ใช้ที่เข้าสู่ระบบในปัจจุบัน ผลลัพธ์ของ ` ใคร ` คำสั่งจะดำเนินการโดย ` โยนออก ` คำสั่งและผลลัพธ์ของ ` โยนออก ` จะเก็บไว้ในตัวแปร $ var . ที่นี่ผลลัพธ์ของ ` โยนออก คำสั่ง ` ขึ้นอยู่กับผลลัพธ์ของ ` ใคร `คำสั่ง

$ที่ไหน=``โยนออก``ใคร``
$โยนออก $ var

เอาท์พุท:

การใช้เส้นทางคำสั่ง

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

ตัวอย่าง #7:

`โว้วมิ` คำสั่งแสดงชื่อผู้ใช้ของผู้ใช้ที่เข้าสู่ระบบในปัจจุบัน โดยค่าเริ่มต้น คำสั่งนี้จะถูกเก็บไว้ใน / usr/ เป็น/ โฟลเดอร์ เรียกใช้สคริปต์ต่อไปนี้เพื่อเรียกใช้ ` whoami` คำสั่งโดยใช้เส้นทางและเก็บไว้ในตัวแปร เอาท์พุท $, และพิมพ์ค่าของ $output .

$ผลผลิต= $(/usr/เป็น/ฉันเป็นใคร)
$โยนออก $output

เอาท์พุท:

การใช้อาร์กิวเมนต์บรรทัดคำสั่ง

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

ตัวอย่าง #8:

สร้างไฟล์ทุบตีชื่อ cmdsub3.sh ด้วยสคริปต์ต่อไปนี้ ` ชื่อฐาน คำสั่ง ` ใช้ที่นี่เพื่อดึงชื่อไฟล์จาก 2NSอาร์กิวเมนต์บรรทัดคำสั่งและเก็บไว้ในตัวแปร $ชื่อไฟล์ . เรารู้จัก 1เซนต์อาร์กิวเมนต์บรรทัดคำสั่งคือชื่อของสคริปต์ดำเนินการซึ่งแสดงด้วย 0 เหรียญ

#!/bin/bash
ชื่อไฟล์=``ชื่อฐาน $ 1``
โยนออก 'ชื่อไฟล์คือ$ชื่อไฟล์. '

เรียกใช้สคริปต์ด้วยค่าอาร์กิวเมนต์ต่อไปนี้

$ทุบตีcmdsub3.sh Desktop/อุณหภูมิ/สวัสดี.txt

ที่นี่, ชื่อฐาน ของเส้นทาง เดสก์ท็อป/อุณหภูมิ/hello.txt เป็น ' สวัสดี.txt ’ ดังนั้น ค่าของ $ชื่อไฟล์ จะ สวัสดี.txt .

เอาท์พุท:

บทสรุป:

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

ข้อมูลเพิ่มเติมในวิดีโอ: