φυβλαςのβλογ
บล็อกของ phyblas



การใช้ unix shell เบื้องต้น ใน linux และ mac
เขียนเมื่อ 2019/01/25 12:11
สำหรับคนที่ใช้ linux แล้ว ส่วนต่อประสานกับผู้ใช้ (user interface) ในรูปแบบคอมมานด์ไลน์ (command line) เป็นสิ่งที่เลี่ยงได้ยาก จำเป็นจะต้องใช้งานให้เป็น

คอมมานด์ไลน์ที่ใช้ใน linux คือเชลยูนิกซ์ (unix shell) และ mac เองก็ใช้เช่นเดียวกัน

รายละเอียดเกี่ยวกับว่าเชลยูนิกซ์คืออะไร คอมมานด์ไลน์คืออะไร เริ่มเปิดใช้งานยังไงอ่านได้ใน https://phyblas.hinaboshi.com/20190124

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

บทความนี้จะค่อยๆอธิบายวิธีการเขียนเชลยูนิกซ์ตั้งแต่เบื้องต้น เน้นคำสั่งพื้นฐานที่ใช้บ่อย



สารบัญ
เริ่มต้น
ดูตำแหน่งปัจจุบัน (pwd)
ดูสิ่งที่อยู่ข้างในโฟลเดอร์ด้วย ls
เคลื่อนย้ายตำแหน่ง (cd)
ตัวเลือกเสริมของคำสั่ง ls
ค้นข้อมูลของแต่ละคำสั่งเพิ่มเติม (info man --help)
ใช้ ls โดยระบุเป้าหมาย
การจัดการกับชื่อไฟล์หรือโฟลเดอร์ที่มีเว้นวรรคหรือเครื่องหมายพิเศษ
การคอมเมนต์ข้อความด้วย #
ตัวช่วยในการพิมพ์และค้นคำสั่ง (tab ↑)
การเลื่อนจุดพิมพ์หรือลบข้อความจำนวนมากในทีเดียว (ctrl+u/k/a/e)
การขึ้นบรรทัดใหม่โดยใช้ \
การสร้างและใช้และลบตัวแปร (= $ unset)
ความแตกต่างระหว่างเครื่องหมายคำพูด " กับ '
การสร้างสมนาม (alias unalias)
การเขียนข้อความใส่ไฟล์ด้วย > >> 2> &>
รันคำสั่งที่ถูกเขียนอยู่ในไฟล์ (. source)
การสร้างโฟลเดอร์ใหม่ (mkdir)
การคัดลอกไฟล์ (cp)
การย้ายหรือเปลี่ยนชื่อไฟล์ (mv)
การลบไฟล์ (rm rmdir)
การค้นหาไฟล์ที่ต้องการจากชื่อ (find)
การดูข้อความในไฟล์ (cat head tail)
การเปิดไฟล์ (open xdg-open)
การรันโค้ดโปรแกรมที่เขียนขึ้น
ตรวจดูต้นทางของคำสั่งต่างๆ (which type)
ตัวแปรสภาพแวดล้อม (export)
คำสั่งย่อยซ้อนในคำสั่งหลัก (`` |)
การเขียนหลายคำสั่งต่อกันทีเดียว (; || &&)
การดูขนาดของโฟลเดอร์ (du)
การดูขนาดและพื้นที่ว่างในไดรฟ์ (df)
ดูข้อมูลของ OS ที่ใช้ (sw_vers lsb_release)
การสั่งโปรแกรมให้ทำงานอยู่ในฉากหลัง (&)
ดูโปรแกรมที่รันอยู่ในเครื่อง (jobs ps top)
การสั่งปิดโปรแกรมที่ไม่ต้องการทิ้ง (kill killall)
การปิดโปรแกรมหรือหยุดชั่วคราวแล้วกลับมาทำต่อ(ctrl+c/z bg fg)
การดูบันทึกคำสั่งที่เคยพิมพ์มาก่อนหน้า (history)
การจัดการสิทธิ์ของไฟล์ (chmod chown chgrp)
การใช้ ssh เพื่อเชื่อมต่อเข้า linux เครื่องเซอร์เวอร์ (ssh scp)
สรุปคำสั่ง



บทความนี้จะแสดงตัวอย่างโดยใช้ linux เป็นหลัก แต่คำสั่งส่วนใหญ่ก็สามารถใช้ใน mac ได้เช่นเดียวกัน แม้อาจจะมีการแสดงผลต่างกันออกไปบ้าง ในที่นี้ถ้าอันไหนที่ใน mac มีความต่างไปมากก็จะอธิบายในส่วนของ mac แยกไว้ด้วย

linux เองคำสั่งต่างๆก็มีความแตกต่างกันไปตามรุ่นอยู่บ้าง แต่คำสั่งพื้นฐานมักจะไม่ต่างกันมาก

ในที่นี้ linux จะใช้ ubuntu 18 เป็นตัวอย่าง ส่วน mac ใช้เวอร์ชัน 10.14.2 mojave (โมฮาเบ) เป็นตัวอย่าง



เริ่มต้น

เริ่มจากเปิดเทอร์มินัลขึ้นมา เมื่อเปิดมาแล้วจะขึ้นหน้าจอแบบนี้



โดยทั่วไปจะขึ้นข้อความว่า
ชื่อผู้ใช้@ชื่อคอม:~$ <ตำแหน่งสำหรับพิมพ์ข้อความ>

ในที่นี้ชื่อผู้ใช้คือ phyblas ส่วนชื่อคอมถ้าไม่ตั้งอะไรไว้เริ่มแรกปกติจะขึ้นเป็น localhost ในที่นี้ได้ตั้งชื่อไว้เป็น pasokon เลยขึ้นตามนั้น

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

เวลาพิมพ์คำสั่งเสร็จแล้วก็กด enter จะเป็นการสั่งคำสั่งนั้น

เพื่อเป็นการยกตัวอย่าง ลองพิมพ์อะไรก็ได้ไปมั่วๆ เช่น
xxxxxx

แล้วจะมีข้อความขึ้นตอบกลับมาว่า
xxxxxx: ไม่พบคำสั่ง

นั่นเป็นเพราะไม่มีคำสั่งชื่อ xxxxxx อยู่ จึงไม่มีการทำงานอะไร ถ้าพิมพ์คำสั่งที่มีอยู่จึงจะเกิดการทำงานขึ้น



ดูตำแหน่งปัจจุบันด้วย pwd

คำสั่งแรกที่เป็นพื้นฐานที่สุดก็คือ
pwd

ลองพิมพ์ไปจากนั้นก็จะมีข้อความขึ้นมาประมาณนี้
/home/phyblas

pwd เป็นคำสั่งที่ใช้แสดงตำแหน่งโฟลเดอร์ที่อยู่ปัจจุบัน

การเปิดเชลขึ้นมานั้นก็เหมือนกับการหน้าต่างดูไฟล์ (finder ใน mac หรือ nautilus ใน linux) คือจะเป็นการเข้ามาดูและจัดการอะไรในโฟลเดอร์

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

โดยทั่วไปเมื่อเปิดขึ้นมาจะเริ่มต้นที่โฟลเดอร์บ้าน ซึ่งจะต่างกันไปแล้วแต่ผู้ใช้ ดังนั้นเมื่อพิมพ์ pwd จะได้ผลลัพธ์ออกมาในลักษณะนี้
/home/<ชื่อผู้ใช้>

home นี่สำหรับใน linux แต่ถ้าเป็นใน mac จะไม่ใช่ home แต่เป็น Users แทน

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

แต่ถ้าตำแหน่งปัจจุบันอยู่ที่โฟลเดอร์บ้านจะขึ้นเป็น ~ โดยสัญลักษณ์ ~ ในที่นี้แทนโฟลเดอร์บ้านนั่นเอง



ดูสิ่งที่อยู่ข้างในโฟลเดอร์ด้วย ls

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



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

หากจะดูว่าในโฟลเดอร์นั้นมีอะไรบ้างก็พิมพ์
ls

จะขึ้นชื่อไฟล์และโฟลเดอร์ย่อยที่อยู่ในโฟลเดอร์นั้น
fontconfig  ดาวน์โหลด  พื้นโต๊ะ  วีดิทัศน์    เอกสาร
ดนตรี        เทมเพลต   รูปภาพ  สาธารณะ

ทั้ง pwd และ ls เป็นคำสั่งพื้นฐานที่สำคัญ เพราะคนเรามักจะต้องการรู้ว่าตัวเองอยู่ที่ไหน ที่นั่นมีอะไรอยู่บ้าง และจะไปที่ไหนได้ยังไง

เมื่อรู้แล้วว่าอยู่ที่ไหนและในนั้นมีอะไร ขั้นต่อไปก็คือมาดูว่าจะไปที่ไหนยังไง



เคลื่อนย้ายตำแหน่งด้วย cd

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

เช่นถ้าต้องการย้ายไปที่ /usr ก็ให้พิมพ์ว่า
cd /usr

เมื่อย้ายมาแล้วจะเห็นว่าข้อความส่วนทางซ้ายของช่องป้อนข้อความจะกลายเป็นแบบนี้ แสดงให้เห็นว่าย้ายตำแหน่งมาแล้ว
phyblas@pasokon:/usr$

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

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

เช่นตอนนี้เราอยู่ใน /usr ถ้าหากพิมพ์
cd bin

ก็จะกลายเป็นเข้าไปอยู่ที่ /use/bin ซึ่งเป็น bin ที่อยู่ใน usr

แต่หากพิมพ์
cd /bin

ก็จะไปอยู่ที่ /bin ซึ่งเป็นโฟลเดอร์ bin ที่อยู่ในราก

ถ้าจะเข้าโฟลเดอร์ที่อยู่ด้านในโฟลเดอร์ย่อยอีกทีก็พิมพ์ต่อกันแล้วคั่นด้วย / ได้ เช่น
cd /usr
cd local/bin

แบบนี้ก็จะไปอยู่ใน /usr/local/bin

ทีนี้เวลาที่เวลาที่อยู่ในโฟลเดอร์ด้านในหากต้องการย้อนกลับไปยังโฟลเดอร์แม่ให้พิมพ์
cd ..

เช่นจากตรงนี้ /usr/local/bin ก็จะกลายเป็นไปอยู่ที่ /usr/local

ถ้าย้อน ๒ ขั้นก็พิมพ์
cd ../..

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

นอกจากนี้ยังมีการใส่พาธแบบพิเศษอีกแบบ คือใช้เครื่องหมาย ~ กับ -

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

ดังนั้นถ้าพิมพ์
cd ~

ก็จะไปอยู่ที่ /home/<ชื่อผู้ใช้>

นอกจากนี้ถ้าพิมพ์แค่ cd เฉยๆก็จะเป็นการกลับไปสู่หน้าบ้านเช่นเดียวกับการพิมพ์ cd ~
cd

ถ้าต้องการเข้าโฟลเดอร์ที่อยู่ด้านในโฟลเดอร์บ้านก็พิมพ์ต่อจาก ~ ได้ เช่น
cd ~/พื้นโต๊ะ

ด้านซ้ายจะเปลี่ยนกลายมาเป็น
phyblas@pasokon:~/พื้นโต๊ะ$

ข้อความที่อยู่ด้านซ้ายนั้นโดยปกติคือถ้าเราอยู่ในโฟลเดอร์บ้านก็จะขึ้นต้นด้วย ~ แต่ถ้าอยู่นอกโฟลเดอร์บ้านจึงจะแสดงที่อยู่เต็ม



ส่วน - จะแทนหน้าที่แล้วที่เราอยู่ เช่น
cd /usr
cd /etc
cd -

แบบนี้สุดท้ายเราก็จะไปอยู่ที่โฟลเดอร์ /usr



ตัวเลือกเสริมของคำสั่ง ls

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

ตัวเลือกเสริมมักจะใส่ได้โดยพิมพ์ขีด - ตามด้วยอักษรตัวเดียว (แยกพิมพ์ใหญ่และเล็ก)

แต่ละคำสั่งมีตัวเลือกเสริมต่างกันออกไป ขอเริ่มยกตัวอย่างจากคำสั่ง ls

เมื่อใช้ ls เฉยๆจะเป็นแค่การแสดงชื่อไฟล์ แต่หากเติม -l ต่อจะเป็นการแสดงรายละเอียดของไฟล์

เช่นลองเข้าไปที่โฟลเดอร์ /etc แล้วพิมพ์
ls -l

จะได้รายละเอียดประมาณนี้
total 1108
drwxr-xr-x  3 root root    4096 ก.ค.  25 11:08 acpi
-rw-r--r--  1 root root    3028 ก.ค.  25 11:04 adduser.conf
drwxr-xr-x  2 root root    4096 ม.ค.  21 18:45 alternatives
-rw-r--r--  1 root root     401 พ.ค.  30  2017 anacrontab
-rw-r--r--  1 root root     433 ต.ค.   2  2017 apg.conf
drwxr-xr-x  6 root root    4096 ก.ค.  25 11:06 apm
(ฯลฯ)

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

ในส่วนของขนาดไฟล์จะเห็นขนาดเป็นไบต์ แบบนี้อาจดูลำบากเพราะถ้าไฟล์ขนาดใหญ่ปกติเราจะใช้หน่วน KB หรือ MB กัน

หากต้องการให้เปลี่ยนไปแสดงในลักษณะนั้นให้ใส่ตัวเลือก h เพิ่มเข้าไป

การใส่ตัวเลือกมากว่าหนึ่งตัวจะใส่แยกหรือใส่รวมก็ได้ เช่น l กับ h นั้นถ้าใส่แยกคือเขียนเป็น -l -h ถ้ารวมก็เขียนเป็น -lh ส่วนลำดับจะสลับกันยังไงก็ได้ ดังนั้นอาจเขียน -h -l หรือ -hl ก็ได้ด้วย

ลองสั่ง
ls -lh

ผลที่ได้จะกลายเป็นแบบนี้
total 1.1M
drwxr-xr-x  3 root root   4.0K ก.ค.  25 11:08 acpi
-rw-r--r--  1 root root   3.0K ก.ค.  25 11:04 adduser.conf
drwxr-xr-x  2 root root   4.0K ม.ค.  21 18:45 alternatives
-rw-r--r--  1 root root    401 พ.ค.  30  2017 anacrontab
-rw-r--r--  1 root root    433 ต.ค.   2  2017 apg.conf
drwxr-xr-x  6 root root   4.0K ก.ค.  25 11:06 apm
(ฯลฯ)

เวลาที่ดูข้อมูลละเอียดแบบนี้จะสามารถแยกแยะชนิดไฟล์ได้โดยดูที่หลักซ้ายสุด เช่น ถ้าอันไหนเป็นโฟลเดอร์จะเขียนเป็นตัว d ถ้าอันไหนเป็นไฟล์ธรรมดา

แต่ยังมีอีกวิธีที่ช่วยให้แยกชนิดข้อมูลได้ง่ายกว่า คือใส่ตัวเลือก -F
ls -F

ได้
acpi/                   hosts                 popularity-contest.conf
adduser.conf            hosts.allow           ppp/
alternatives/           hosts.deny            printcap@
anacrontab              hp/                   profile
(ฯลฯ) (ฯลฯ) (ฯลฯ)

จะเห็นว่าที่เป็นโฟลเดอร์จะมี / ต่อท้าย ส่วนที่เป็นพวกชอร์ตคัตจะมี @ ต่อท้าย ทำให้แยกชนิด

หากเติม -a ผลที่ได้จะมีการแสดงไฟล์ที่ชื่อขึ้นต้นด้วย . ด้วย ซึ่งปกติจะเป็นไฟล์ที่ถูกซ่อนไม่ให้มองเห็นได้ตามปกติ

ลองไปที่โฟลเดอร์บ้านแล้วพิมพ์
ls -a

จะพบว่าในบ้านมีไฟล์หรือโฟลเดอร์ที่ซ่อนอยู่เต็มไปหมด
.              .bashrc     .gnupg            .parallels  เทมเพลต  สาธารณะ
..             .cache      .ICEauthority     .profile    พื้นโต๊ะ    เอกสาร
.bash_history  .config     .local            ดนตรี        รูปภาพ
.bash_logout   fontconfig  .pam_environment  ดาวน์โหลด    วีดิทัศน์

นอกจากนี้ยังจะเห็นว่ามี . กับ .. โผล่มาด้วย โดยทั่วไปแล้ว . จะหมายถึงตัวโฟลเดอร์ที่เราอยู่ตอนนั้น ส่วน .. จะหมายถึงโฟลเดอร์แม่ของโฟลเดอร์นั้น

ดังนั้นเวลาเราเพิมพ์ cd . ก็จะไม่เกิดอะไรขึ้น เพราะเป็นการไปยังโฟลเดอร์ปัจจุบัน แต่ถ้าพิมพ์ cd .. จะเป็นการย้อนไปยังโฟลเดอร์แม่

ถ้าไม่ต้องการให้มี . กับ .. โผล่มาด้วยให้ใช้ -A แทน
ls -A

ได้
.bash_history  .config        .local            ดนตรี      รูปภาพ
.bash_logout   fontconfig     .pam_environment  ดาวน์โหลด  วีดิทัศน์
.bashrc        .gnupg         .parallels        เทมเพลต   สาธารณะ
.cache         .ICEauthority  .profile          พื้นโต๊ะ     เอกสาร

หากเติม -R จะเป็นการดูเนื้อหาไฟล์ที่อยู่ในโฟลเดอร์ย่อยในนั้นทั้งหมด

หากเติม -t ไฟล์จะเรียงตามเวลาที่แก้ล่าสุด และหากเติม -S ไฟล์จะเรียงตามขนาดไฟล์ โดยไฟล์ใหญ่กว่าขึ้นก่อน

ถ้าใช้ทั้ง S กับ t ตัวที่วางไว้ข้างหลังจะสำคัญกว่า ดังนั้น ls -St กับ ls -tS จะไม่เหมือนกัน

นอกจากนี้ยังมีตัวเลือกเสริมอีกหลายอย่าง สามารถอ่านรายละเอียดเพิ่มเติมได้โดยใช้คำสั่ง info หรือ man



ค้นข้อมูลของแต่ละคำสั่งเพิ่มเติม

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

เช่น
info ls

หรือ
man ls

จากนั้นจะมีข้อความอธิบายการใช้คำสั่ง ls สามารถใช้ลูกเลื่อนเมาส์เพื่อเลื่อนดูได้ พอดูเสร็จให้พิมพ์ q ก็จะกลับออกมา

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

นอกจากนี้ยังมีอีกวิธี คือเติม --help ตามหลังคำสั่ง
ls --help

เพียงแต่ไม่ใช่ว่าทุกคำสั่งจะใช้ได้ ส่วนใหญ่ใน linux จะใช้ --help ได้ แต่ใน mac จะไม่มีให้ใช้

การทำงานของคำสั่งเดียวกันภายใน mac และ linux อาจมีรายละเอียดต่างกัน ตัวเลือกที่ใช้ได้



ใช้ ls โดยระบุเป้าหมาย

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

เช่นจะดูไฟล์ใน /etc ก็ไม่ต้องเข้าไปถึงในนั้น แต่พิมพ์แบบนี้ได้เลย
ls /etc

จะดูพร้อมกันหลายโฟลเดอร์ก็ได้ กรณีนี้ให้เขียนชื่อต่อกันเลย โดยเว้นวรรค
ls /var /usr

หากมีการใส่เป้าหมายของคำสั่งด้วย ตัวเลือกเสริมจะวางไว้ก่อน เป้าหมายจะอยู่ท้ายสุด เช่น
ls -l /dev

หากใช้คำสั่ง ls ตามด้วยชื่อไฟล์ที่ไม่ใช่โฟลเดอร์ก็จะเป็นการดูข้อมูลของไฟล์นั้นโดยเฉพาะ ส่วนใหญ่มักจะใช้คู่กับ -l เพื่อดูรายละเอียดของไฟล์นั้นๆเช่น
ls -lh /etc/profile.d/cedilla-portuguese.sh



การจัดการกับชื่อไฟล์หรือโฟลเดอร์ที่มีเว้นวรรคหรือเครื่องหมายพิเศษ

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

ชื่อโฟลเดอร์ที่มีเครื่องหมายพิเศษบางอย่างก็จำเป็นต้องใส่เครื่องหมายคำพูดเช่นกัน เช่น ( ) < > { } # ;

เช่น
cd "Applications (Parallels)"

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

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

นอกจากนี้ยังมีอีกวิธีหนึ่งก็คือใช้ \ นำหน้าช่องเว้นวรรคและเครื่องหมายพิเศษทั้งหมด
cd Applications\ \(Parallels\)

ในขณะเดียวกันหากต้องการพิมพ์ชื่อที่มีเครื่องหมายคำพูดหรือ \ อยู่ก็ให้นำหน้าด้วย

เช่นถ้าโฟลเดอร์ชื่อ a"b\c"d ให้พิมพ์ว่า
cd a\"b\\c\"d



การคอมเมนต์ข้อความด้วย #

สำหรับอักษร # ปกติจะใช้เพื่อให้ข้อความที่ตามมาข้างหลังเป็นแค่คอมเมนต์ ไม่มีผลอะไร เช่น
cd /home/phyblas # เข้าสู่โฟลเดอร์บ้าน

จะเหมือนกับเราพิมพ์แค่ cd /home/phyblas ข้อความตั้งแต่ # ถูกเพิกเฉย

แต่สมมุติว่ามีโฟลเดอร์ที่ชื่อ #a แล้วเราต้องการเข้าไปจะต้องพิมพ์ \ นำหน้า
cd \#a

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



ตัวช่วยในการพิมพ์และค้นคำสั่ง

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

เช่น pw tabtab จะปรากฏคำสั่งเหล่านี้ขึ้น
pwck      pwconv    pwd       pwdx      pwunconv

แต่ถ้าผลการค้นหามีเยอะเกินไป เช่นเวลาที่พิมพ์แค่อักษรตัวแรกตัวเดียวมันจะขึ้นเตือนมาถามให้แน่ใจก่อนว่าจะให้แสดงจริงหรือไม่ ถ้าต้องการก็กด y ไม่ต้องการก็กด n

เช่น p tabtab จะได้
Display all 361 possibilities? (y or n)

แสดงว่ามีคำสั่งที่ขึ้นต้นด้วย p มากถึงขนาดนี้

เมื่อกด y ให้แสดงแล้วจะเห็นว่าจำนวนมีเยอะจนแสดงไม่หมดให้กด enter เพื่อเลื่อนลงไปเรื่อยๆดูได้

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

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

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



การเลื่อนจุดพิมพ์หรือลบข้อความจำนวนมากในทีเดียว

ปกติแล้วเวลาที่เราพิมพ์คอมมานด์ไลน์อยู่แล้วถ้าพิมพ์ผิดก็จะต้องกดปุ่มลบเพื่อลบ

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

ในเวลาแบบนี้ถ้ากด ctrl+u เพียงเท่านี้ข้อความทั้งหมดที่อยู่ทางซ้ายของตำแหน่งที่พิมพ์อยู่ก็จะถูกลบหมดได้

ในทางตรงกันข้าม ถ้ากด ctrl+k จะเป็นการลบข้อความทั้งหมดที่อยู่ด้านขวา

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

ในเวลาแบบนี้ให้กด ctrl+a จะกลับไปที่ตำแหน่งซ้ายสุดได้

ในทางตรงกันข้าม หากกด ctrl+e ก็จะไปที่ตำแหน่งขวาสุด

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



การขึ้นบรรทัดใหม่โดยใช้ \

หากอยากพิมพ์คำสั่งเดียวแต่ไม่อยากให้ยาวเหยียดต่อกันก็สามารถขึ้นบรรทัดใหม่ได้โดยพิมพ์ \ เช่น
cd /usr/lib/python3/dist-packages/\
> pkg_resources/extern

พอพิมพ์ \ แล้วกด enter จะขึ้นบรรทัดใหม่แล้วมี > โผล่ขึ้นมา ให้พิมพ์ข้อความต่อจากตรงนั้นได้เหมือนเป็นการพิมพ์ต่อจากตัวก่อน \

ดังนั้นจะมีค่าเท่ากับการพิมพ์ต่อเนื่องแบบนี้
/usr/lib/python3/dist-packages/pkg_resources/extern



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

เชลยูนิกซ์ก็สามารถสร้างตัวแปรได้เหมือนกับภาษาโปรแกรม วิธีการประกาศตัวแปรก็ทำได้โดยใช้เครื่องหมาย = โดยใส่ชื่อตัวแปรไว้ด้านซ้าย และค่าที่ต้องการไว้ด้านขวา เช่น
x=12

จะเป็นการสั่งให้ตัวแปร x มีค่าเท่ากับ 12

แต่ข้อควรระวังก็คือค่าที่ถูกป้อนเข้าไปจะถือเป็นสายอักขระเสมอ อย่าง 12 ในที่นี้ก็จะถือว่าเป็นสายอักขระ ไม่ใช่ตัวเลข

อีกอย่างคือจำเป็นต้องพิมพ์ติดกันโดยไม่เว้นวรรค เช่นจะพิมพ์เป็น x = 12 หรือ x =12 แบบนี้ไม่ได้

ชื่อตัวแปรสามารถใช้อักษร a-z หรือ A-Z (แยกพิมพ์เล็กและใหญ่) หรือตัวเลข 0-9 หรือขีดล่าง _ แต่ว่าตัวเลขไม่สามารถใช้เป็นตัวขึ้นต้นได้

ถ้าหากข้อความมีเว้นวรรคหรือมีเครื่องหมายพิเศษก็จะต้องใส่เครื่องหมายคำพูดไปด้วย
xx="ls -l"

จากนั้นเวลาจะใช้ค่าตัวแปรก็ใส่เครื่องหมาย $ นำหน้า

ค่าตัวแปรที่ป้อนเข้าไปแล้วสามารถดูค่าได้โดยพิมพ์คำสั่ง echo เช่น
echo $xx

จะได้ ls -l

หรือสามารถนำมาใช้เหมือนเป็นการรันคำสั่ง เช่นใช้ค่า xx ที่เพิ่งป้อนไป
$xx

แบบนี้ก็มีค่าเท่ากับรันคำสั่ง ls -l

จะเอามาเขียนต่อด้วยอะไรก็ได้ เช่น
$xx -t

จะกลายเป็นการรันคำสั่ง ls -l -t

สามารถอ้างอิงตัวแปรเพื่อป้อนค่าให้ตัวแปรอีกตัวได้ เช่น
xxx="$xx -S"

จะได้ว่า xxx กลายเป็น ls -l -S

ซึ่งจะสังเกตได้ว่าตัวแปรทางซ้ายที่จะรับค่าจะไม่มี $ นำหน้า แต่ตัวแปรที่จะอ้างถึงต้องมี $ นำหน้า

$ เป็นตัวบอกว่าตัวหนังสือที่จะเขียนต่อจากนี้ไปจะใช้ในฐานะตัวแปร ไม่ได้เป็นสายอักขระ

ชื่อตัวแปรจะเริ่มจากถัดจาก $ ไปจนกว่าจะเจอเครื่องหมายพิเศษหรือเว้นวรรค

ดังนั้นกรณีที่ด้านหลังชื่อตัวแปรเป็นตัวอักษรที่ไม่ใช่สัญลักษณ์พิเศษจะไม่สามารถเขียนต่อได้โดยตรง ให้ใช้ {} คร่อมเพื่อบอกขอบเขต เช่น
echo ${xx}h

จะเป็นการเอาค่าของตัวแปร xx มาต่อกับ x กลายเป็น ls -lh

เพราะถ้าเขียน $xxh ก็จะกลายเป็นการเอาค่าตัวแปร xxh

หากต้องการลบตัวแปรก็ทำได้ด้วยคำสั่ง unset เช่น
unset xxx



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

แต่ความแตกต่างจะเกิดขึ้นในกรณีที่มีการใส่ตัวแปรไว้ในข้อความ โดยที่ ' (ขีดเดียว) จะถือว่า $ เป็นอักษรธรรมดาไม่มีการตีความอะไรเป็นพิเศษ ในขณะที่ " (สองขีด) จะตีความ $ เป็นตัวแปรทั้งหมด

เช่น
y=3
echo "$y a"
echo '$y a'

แบบนี้อันแรกจะได้เป็น 3 a แต่อันหลังจะได้เป็น $y a



การสร้างสมนาม (alias)

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

ชื่อใหม่ที่ถูกตั้งขึ้นมาแทนนี้เรียกว่า alias แปลเป็นไทยว่า "สมนาม" คำแปลนี้เป็นศัพท์บัญญัติทางคอมพิวเตอร์ ถ้าให้แปลให้เข้าใจง่ายๆอาจแปลว่า "ชื่อเล่น"

คำสั่งที่ใช้สร้างสมนามก็คือ alias ตัวอย่างการใช้ เช่น
alias lsl="ls -l"

เท่านี้แค่เรียกใช้
lsl

แบบนี้ก็เป็นการเรียกใช้ ls -l แล้ว

ถ้าใช้คำสั่ง alias แล้วตามด้วยชื่อของตัวแปรที่ตั้งเป็นสมนามไว้ก็จะได้ตัวคำสั่งเต็มกลับมา เช่นใช้กับ lsl ที่ตั้งไว้ตะกี้ดู
alias lsl

ได้
alias lsl='ls -l'

อันที่จริงก็คล้ายกับการสร้างตัวแปร เพียงแต่เวลาเรียกใช้จะไม่ต้องเติม $ เวลาเรียกใช้

เช่นถ้าใช้การสร้างตัวแปรทั่วไปก็จะเขียนเป็น
lsl="ls -l"

แล้วเวลาเรียกใช้ก็เป็น
$lsl

แต่ถ้าตั้งเป็นสมนามแล้ว พิมพ์แค่ lsl ก็พอ

การลบสมนามสามารถทำได้โดยใช้คำสั่ง unalias เช่น
unalias lsl

เท่านี้ lsl ก็จะใช้การไม่ได้อีกต่อไป

นอกจากนี้ ยังตั้งให้คำสั่งนึงกลายเป็นสมนามของตัวมันเองได้ด้วย เช่น
alias ls='ls -a'

แบบนี้แค่พิมพ์ ls ก็จะกลายเป็นเท่ากับ ls -a

แต่ว่าถ้าใช้ unalias ก็จะกลับมาเป็นเหมือนเดิมได้
unalias ls

หมายความว่าถ้าเขียนสมนามทับคำที่เป็นคำสั่ง คำสั่งนั้นก็ไม่ได้หายไปไหน พอ unalias ไปก็จะกลับมาเหมือนเดิมได้

ใน linux จะมีคำสั่ง ll ซึ่งความจริงแล้วสมนามที่ถูกตั้งไว้แต่แรก โดยแทนคำสั่ง ls ผสมกับตัวเลือกอื่นๆ ซึ่งผลจะต่างกันไปใน linux แต่ละแบบ

เช่นถ้าลอง
alias ll

สำหรับใน ubuntu 18 จะได้
alias ll='ls -alF'

แต่ถ้าเป็น CentOS 7 จะได้เป็น
alias ll='ls -l --color=auto'

แต่ก็อาจได้ต่างออกไปจากนี้อีก ขึ้นอยู่กับในเครื่องนั้นตั้งไว้แบบไหน

นอกจากนี้ในถ้าสั่ง alias เฉยๆจะเป็นการแสดงรายการสมนามทั้งหมดที่ตั้งไว้

ใน linux หากลองสั่ง alias ดูก็จะพบว่าระบบมีการตั้งสมนามไว้ให้อยู่แล้วหลายตัวเป็นค่าตั้งต้น แต่จะสร้างอะไรไว้บ้างนั้นมีความต่างกันไปมากในแต่ละรุ่น



การเขียนข้อความใส่ไฟล์ด้วย > >> 2> &>

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

แต่ว่าถ้าหากต้องการให้ข้อความผลลัพธ์ไปเก็บไว้ในไฟล์ก็ทำได้โดยพิมพ์ > ตามด้วยชื่อไฟล์ที่ต้องการบันทึก
ls > ls.txt

หรือจะเขียน ls>ls.txt ก็ได้ เว้นวรรคหรือไม่ก็ไม่มีผล

ผลที่ได้ก็คือผลจากคำสั่ง ls จะไปเก็บอยู่ในไฟล์ชื่อ ls.txt

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

หากไม่ต้องการเขียนทับแต่อยากให้เขียนต่อจากของเดิมถ้ามีอยู่แล้วก็ใช้ >> แทน เช่น
ls -l >> ls.txt

แบบนี้จะเป็นการเขียนต่อบรรทัดต่อไป

เพียงแต่ว่าถ้าไฟล์ชื่อนี้ไม่ได้มีอยู่ตั้งแต่แรกก็จะเป็นการสร้างไฟล์ขึ้นใหม่ ไม่ต่างจากใช้ > ธรรมดา

ถ้าหากอยู่ดีๆต้องการสร้างไฟล์ที่มีข้อความบางอย่างตามที่ต้องการขึ้นมาอาจใช้คำสั่ง echo
echo 555555 >> 555.txt

แบบนี้ก็จะเป็นการสร้างไฟล์ 555.txt ซึ่งมีข้อความ 555555 อยู่ข้างใน

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

หากต้องการให้บันทึกข้อผิดพลาดให้พิมพ์ 2> เช่นคำสั่ง ls ไม่มีตัวเลือก -j อยู่ ถ้าใส่ไปก็จะเป็นข้อผิดพลาด
ls -j 2> lsj.txt

ที่เป็นเลข 2 ก็เพราะข้อผิดพลาดถือเป็นข้อมูลขาออกชนิดที่สองในขณะที่ผลลัพธ์ปกติเป็นชนิดที่หนึ่ง ดังนั้นผลลัพธ์ปกติจะใช้ 1> ก็ได้เช่นกัน จะมีผลเหมือนกับ > เฉยๆ

แต่หากต้องการให้บันทึกทั้งหมดไม่ว่าจะเป็นข้อความผลลัพธ์ปกติหรือข้อผิดพลาดให้ใช้ &>
ls -j &> lsj.txt



รันคำสั่งที่ถูกเขียนอยู่ในไฟล์

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

เช่น
echo "ls -lh" > lslh.sh
echo "pwd" >> lslh.sh
source lslh.sh

แบบนี้คำสั่ง ls -lh และ pwd ก็จะถูกนำมารันต่อกันไป

หรืออาจพิมพ์โดยใช้จุด . แทน source ก็ได้
. lslh.sh

แบบนี้ก็ได้ผลเหมือนกัน

อนึ่ง ที่ไฟล์บันทึกเป็น .sh เพราะเป็นโค้ดของเชล มักตั้งชื่อเป็นสกุลนี้

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



การสร้างโฟลเดอร์ใหม่

สามารถสร้างโฟลเดอร์ใหม่ได้ด้วยพิมพ์คำสั่ง mkdir ตามด้วยชื่อโฟลเดอร์ที่ต้องการ
mkdir foldermai

เพียงแต่ว่าถ้าหากว่าต้องการสร้างโฟลเดอร์ที่อยู่ด้านในโฟลเดอร์อีกทีละก็ โฟลเดอร์ด้านนอกนั้นต้องถูกสร้างขึ้นมาก่อน เช่นถ้าต้องการสร้างโฟลเดอร์ fa/fb จะต้องมีโฟลเดอร์ fa อยู่ก่อน ไม่เช่นนั้นจะเกิดข้อผิดพลาดขึ้น

ดังนั้นถ้าต้องการให้มีโฟลเดอร์ fa/fb/fc จำเป็นจะต้องสั่งตามลำดับแบบนี้
mkdir fa
mkdir fa/fb
mkdir fa/fb/fc

แต่ว่าจริงๆแล้วมีวิธีที่ไม่ต้องมาสร้างทีละขั้น คือใส่ตัวเลือก -p ลงไป
mkdir -p ga/gb/gc

แบบนี้ถ้าหากโฟลเดอร์ ga ไม่มีอยู่แต่แรกก็จะมีการสร้างขึ้นมาใหม่ก่อน และจะสร้างโฟลเดอร์ไล่ไปเรื่อยๆจนถึงด้านในสุด



การคัดลอกไฟล์

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

เช่น
echo aaa > a.txt
cp a.txt b.txt

ก็จะได้ไฟล์ b.txt ที่มีข้อความ aaa เช่นเดียวกับ a.txt

หรือหากต้องการคัดลอกไฟล์หนึ่งไปยังโฟลเดอร์อื่นก็ทำได้โดยพิมพ์ชื่อไฟล์ตามด้วยชื่อโฟลเดอร์ เช่น
mkdir ab
cp a.txt ab/

แบบนี้ a.txt ก็จะถูกคัดลอกไปยังโฟลเดอร์ ab

หากมีไฟล์อยู่หลายไฟล์ที่ต้องการคัดลอกอาจใช้การเขียนด้วยดอกจัน *

เช่น
cp *.txt ab/

จะเป็นการคัดลอกไฟล์ทั้งหมดที่เป็นสกุล .txt

หรือถ้า
cp a* ab/

จะคัดลอกไฟล์ที่ขึ้นต้นด้วย a ทั้งหมด

ในที่นี้ * จะแทนอักษรอะไรก็ได้กี่ตัวก็ได้

การเขียนในลักษณะแบบนี้เรียกว่ากล็อบ (glob) รายละเอียดเพิ่มเติมอ่านได้ใน https://phyblas.hinaboshi.com/20190109

เราอาจใช้ * คู่กับ ls ก็ได้ กรณีนี้จะเป็นการแสดงชื่อไฟล์ที่เข้าข่าย

เช่น
ls a*

แบบนี้จะแสดงชื่อไฟล์ที่ขึ้นต้นด้วย a และเนื้อหาในทุกโฟลเดอร์ที่ขึ้นต้นด้วย a

ถ้าต้องการให้เวลาที่สั่งไปแล้วมีการแสดงว่ามีการคัดลอกไฟล์อะไรไปบ้างให้ใส่ตัวเลือก -v

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

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

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

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

สำหรับโฟลเดอร์ให้ใส่ตัวเลือกเสริม -R นำหน้าไปด้วย ไม่เช่นนั้นจะคัดลอกไม่ได้ เช่น
mkdir ba
echo xxx > ba/aaa.txt
cp -R ba ab/

แบบนี้โฟลเดอร์ ba ก็จะถูกคัดลอกลงไปใส่ใน ab และไฟล์ที่อยู่ในนั้นก็ถูกคัดลอกตามเข้าไปด้วย

คำถามให้ลองไปดูเล่นๆ จะเกิดอะไรขึ้นหากพยายามคัดลอกตัวโฟลเดอร์นั้นเข้าไปในตัวมันเอง โดยพิมพ์
cp -R ab ab/



การย้ายหรือเปลี่ยนชื่อไฟล์

การย้ายไฟล์นั้นคล้ายกับการคัดลอกไฟล์ แค่เปลี่ยนจาก cp เป็น mv
mv a.txt ab/

จะย้าย a.txt ไปยังโฟลเดอร์ ab

แต่คำสั่ง mv ยังใช้ในการเปลี่ยนชื่อไฟล์ได้ด้วย โดยเขียนชื่อเดิมแล้วตามด้วยชื่อที่ต้องการเปลี่ยน เช่น
mv b.txt c.txt

จะเปลี่ยนชื่อจาก b.txt ไปเป็น c.txt

และเช่นเดียวกับ cp สามารถใส่ตัวเลือก -u หรือ -n หรือ -i เพื่อจัดการในกรณีไฟล์มีอยู่แล้ว



การลบไฟล์

การลบไฟล์สามารถทำได้โดยพิมพ์คำสั่ง rm ตามด้วยชื่อไฟล์ เช่น
rm c.txt

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

ถ้าใช้กล็อบก็จะลบไฟล์พร้อมกันทีละหลายไฟล์ได้ เช่นเขียนแบบนี้จะเป็นการลบไฟล์ .txt ทั้งหมดไป
rm *.txt

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

แบบนี้
rm -i *.txt

ก็จะมีขึ้นมาถามทีละไฟล์ว่าจะลบไฟล์นั้นจริงหรือเปล่า

ถ้าจะลบก็พิมพ์ตอบว่า y หรือ yes แล้ว enter ถ้าจะไม่ลบก็พิมพ์อย่างอื่นตอบไป

สำหรับการลบโฟลเดอร์นั้นให้ใส่ตัวเลือกเสริม -rf ลงไปด้วย ไม่เช่นนั้นจะลบไม่ได้
rm -rf ab

สำหรับการลบโฟลเดอร์มีคำสั่ง rmdir
rmdir ab

แต่คำสั่งนี้จะลบได้แค่โฟลเดอร์เปล่าๆเท่านั้น และหากใช้ rm -rf ก็สามารถลบโฟลเดอร์ได้เช่นกัน คำสั่งนี้จึงอาจไม่จำเป็นต้องใช้ก็ได้



การค้นหาไฟล์ที่ต้องการจากชื่อ

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

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

คำในการหาสามารถเขียนในรูปกล็อบได้ ตัวอย่างเช่น
find . -name r*

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



การดูข้อความในไฟล์

สามารถใช้คำสั่ง cat เพื่อดูเนื้อหาข้างในไฟล์ได้ เช่น
ls > ls.txt
cat ls.txt

ถ้าต้องการให้แสดงเลขแถวด้วยก็ใส่ตัวเลือก -b หรือ -n
cat -b ls.txt

เพียงแต่ว่า -b กับ -n จะต่างกันตรงที่ -b จะละเลขแถวในแถวที่ว่างเปล่าไป แต่ -n จะแสดงของแถวที่ว่างเปล่าด้วย

สามารถดูหลายไฟล์พร้อมกันได้โดยวางชื่อไฟล์ต่อกันโดยเว้นวรรค จะได้ข้อความของแต่ละไฟล์มาเรียงต่อกันโดยมีการเว้นบรรทัด
echo aaa > a.txt
echo bbb > b.txt
cat a.txt b.txt

ได้
aaa
bbb

สามารถใช้สร้างไฟล์ใหม่ที่เอาไฟล์สองไฟล์ขึ้นไปมาต่อกันได้
cat a.txt b.txt > ab.txt

หากต้องการดูแค่ส่วนหัว 10 บรรทัดแรกให้ใช้คำสั่ง head หรือถ้าต้องการดูแค่ส่วนท้าย 10 บรรทัดให้ใช้คำสั่ง tail
head ls.txt
tail ls.txt

ถ้าหากต้องการกำหนดจำนวนบรรทัดที่ดูให้ใส่ตัวเลือกเสริม -n แล้วตามด้วยตัวเลขจำนวนที่ต้องการ ก่อนจะตามด้วยชื่อไฟล์
head -n 7 ls.txt
tail -n 4 ls.txt

จะเป็นการดูส่วนหัว 7 บรรทัดแรก และส่วนท้ายสุด 4 บรรทัด

นอกจากนี้ใน linux มีคำสั่งชื่อ tac ด้วย เป็นการดูเนื้อหาทั้งหมดเช่นเดียวกับ cat เพียงแต่จะเรียงจากบรรทัดล่างขึ้นบน เพราะคำว่า tac ก็คือ cat ที่เขียนกลับหลังมาหน้านั่นเอง



การเปิดไฟล์

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

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

หากใส่ตัวเลือกเสริม -t ลงไปจะเป็นการบังคับว่าให้เปิดไฟล์ขึ้นมาเพื่ออ่านด้วยโปรแกรมแก้ไขข้อความ ไม่ว่าจะเป็นไฟล์อะไรก็ตาม

หากใช้ open กับโฟลเดอร์จะเป็นการเปิดดูโฟลเดอร์นั้นใน finder
open .

ส่วนใน linux จะใช้คำสั่งชื่อ xdg-open ไม่ใช่ open เฉยๆ
xdg-open .

ถ้าใช้กับโฟลเดอร์จะเป็นการเปิดหน้าต่างดูไฟล์ สำหรับใน linux แล้วมักจะใช้เป็น nautilus

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

จะพิมพ์ว่า gedit เพื่อสั่งเปิดไฟล์ขึ้นมาแก้ข้อความโดยตรงเลยก็ได้
gedit xxx.txt

นอกจากนี้ยังมีตัวแก้ข้อความที่นิยมใช้มากอย่าง vi กับ nano ซึ่งปกติจะมีลงไว้อยู่แล้วทั้ง mac และ linux (แต่บางรุ่นก็อาจไม่ได้ลง nano ไว้ ต้องลงเพิ่ม)

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

วิธีการเปิดใช้ก็เป็นในลักษณะเดียวกัน คือพิมพ์ vi หรือ nano ตามด้วยชื่อไฟล์
vi xxx.txt
nano xxx.txt

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

nano จะใช้ง่ายกว่า vi แต่ vi ถ้าใช้คล่องแล้วจะทำอะไรได้สะดวกมากกว่า

การออกจาก nano ให้พิมพ์ ctrl+x ส่วน vi ต้องพิมพ์ :q แล้วกด enter



การรันโค้ดโปรแกรมที่เขียนขึ้น

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

เช่น หากต้องการรันไพธอนก็แค่พิมพ์ python ตามด้วยชื่อไฟล์ เช่น
python xxx.py

แต่ถ้าพิมพ์ python เฉยๆจะเข้าโหมดเชลโต้ตอบของไพธอน สามารถออกได้โดยพิมพ์ exit() หรือกด ctrl+d

การจะรันภาษาไหนได้นั้นภายในเครื่องจะต้องมีติดตั้งคอมไพเลอร์ภาษานั้นไว้อยู่แล้ว

ปกติแล้วใน mac และ linux มีการลงไพธอนไว้อยู่แล้วในตัว ดังนั้นพอพิมพ์ python จึงใช้งานได้เลย

เพียงแต่ว่าไพธอนเองก็มีหลายเวอร์ชัน จะเป็นการรันไพธอนเวอร์ชันไหนนั้นก็ขึ้นอยู่กับว่าถูกตั้งเอาไว้ยังไง

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



ตรวจดูต้นทางของคำสั่งต่างๆ

ที่จริงแล้วคำสั่งต่างๆที่พิมพ์มานั้นส่วนใหญ่แล้วเป็นสั่งรันไฟล์โปรแกรมที่ถูกเก็บอยู่ในเครื่อง

การจะตรวจดูว่าคำสั่งนั้นเป็นการรันไฟล์ที่ไหนให้พิมพ์คำสั่ง which เช่น
which cat

จะได้
/bin/cat

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

ตำแหน่งที่เก็บคำสั่งนั้นมีอยู่หลากหลายที่ คำสั่งแต่ละอย่างถูกเก็บอยู่ในที่อื่นๆต่างๆไม่เหมือนกัน เช่น cd อยู่คนละที่กับ ls
which cd

จะได้
/usr/bin/cd

แต่ว่ามีบางคำสั่งที่ต่อให้ใช้ which หาก็ไม่เจอ เพราะคำสั่งพวกนั้นเป็นคำสั่งที่ฝังอยู่ในเชล bash เช่น unset

หรือคำสั่งที่เป็นสมนามก็จะหาด้วย which ไม่เจอเช่นกัน

ถ้าใช้คำสั่ง type จะให้ผลคล้ายกับ which แต่จะบอกได้ว่าตัวไหนเป็นคำสั่งที่ฝังอยู่ในเชลหรือเป็นสมนามเช่น
type unset
type tail
type ll

ได้
unset is a shell builtin
tail is /usr/bin/tail
ll is aliased to `ls -alF'

หากอยากรู้ว่าคำสั่งรันไพธอนนั้นอยู่ที่ไหนก็ลองดูได้โดย
which python

โดยทั่วไปถ้าเป็นไพธอนที่ติดมากับเครื่องจะได้ /usr/bin/python

แต่หากใครลงเพิ่มเช่นใช้ anaconda ก็อาจได้เป็นโฟลเดอร์ที่ติดตั้งไว้ แต่ยังไงไพธอนตัวเดิมที่ /usr/bin/ ก็ยังอยู่ แค่เวลาใช้มันจะเลือกไปอ่านไพธอนที่เราลงใหม่เท่านั้น

สิ่งที่เป็นตัวกำหนดว่ามันจะไปอ่านตัวไหนนั้นก็คือตัวแปรสภาพแวดล้อมที่ชื่อว่า PATH



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

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

การดูค่าตัวแปรเหล่านั้นทำได้โดยใช้คำสั่ง export
export

ได้
declare -x CLUTTER_IM_MODULE="xim"
declare -x COLORTERM="truecolor"
declare -x DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/1001/bus"
declare -x DESKTOP_SESSION="ubuntu"
declare -x DISPLAY=":1"
(ฯลฯ)

ค่าตัวแปรเหล่านี้จะถูกเรียกใช้ได้จากโปรแกรมต่างๆในตัวเครื่อง เช่น $USER จะเป็นชื่อของผู้ใช้
echo $USER

ได้
phyblas

PATH เป็นตัวที่จะบอกว่าคำสั่งต่างๆถูกเก็บไว้ที่ไหน
echo $PATH

ค่า PATH จะเป็นชื่อโฟลเดอร์หลายอันคั่นด้วย : แบบนี้
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

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

การเปลี่ยนแปลงค่าตัวแปรสำคัญต่างๆสามารถทำได้ด้วยการเขียนทับตัวแปรธรรมดา เช่น
PATH=/home/phyblas/anaconda3/bin:$PATH

จะเป็นการเพิ่มโฟลเดอร์ /home/phyblas/anaconda3/bin เข้าไปด้านหน้าของพาธเดิม

เมื่อทำแบบนี้แล้วเมื่อสั่ง python จึงเป็นการไปอ่าน python ที่อยู่ใน /home/phyblas/anaconda3/bin เพราะขึ้นต้นก่อนนั่นเอง

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

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

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

เช่น หากต้องการเพิ่มตัวแปรสำคัญชื่อ x ก็สามารถทำได้โดย
export x=1

หรือจะประกาศตัวแปรนั้นก่อน แล้วค่อยสั่ง export ทีหลังก็ได้
x=1
export x

หากใช้ export กับตัวแปรที่มีอยู่แล้วจะเป็นการไปแก้ค่า ซึ่งก็ไม่ต่างจากการพิมพ์ = เฉยๆโดยไม่ใส่ export
export PATH=/usr/local/bin:$PATH

ดังนั้นหากไม่แน่ใจว่าตัวแปรนั้นมีอยู่ก่อนแล้วหรือเปล่าก็ให้ใช้ export ไปก่อน ไม่มีปัญหา

การลบตัวแปรสำคัญออกก็ทำได้เช่นเดียวกับตัวแปรธรรมดา คือใช้ unset เมื่อตัวแปรถูกลบมันก็จะหายไปจากรายการด้วยเช่นกัน
unset x



คำสั่งย่อยซ้อนในคำสั่งหลัก

ที่ผ่านมาทั้งหมดเมื่อรันคำสั่งหนึ่งเสร็จแล้วก็จบไป ถึงมีคำสั่งอะไรตามมาอีกก็ไม่ได้เกี่ยวกับคำสั่งแรกแล้ว

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

แบบนั้นก็สามารถทำได้โดยใช้เครื่องหมายอักซ็องกราฟ (accent grave) `` คร่อมคำสั่งย่อย แล้ววางในตำแหน่งที่ต้องการใช้ผลที่ได้จากคำสั่งนั้นลงในคำสั่งหลัก

ตัวอย่าง
export x=`pwd`

ทำแบบนี้จะเป็นการรันคำสั่ง pwd เพื่อหาตำแหน่งปัจจุบันแล้วได้ค่าเอามาเก็บในตัวแปร x

หรืออย่าง
rm -rf `ls`

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

นอกจากนี้ยังมีอีกวิธีที่ได้ผลเหมือนกัน คือใช้ $ แล้วตามด้วยวงเล็บ เช่น
export x=$(pwd)
rm -rf $(ls)

แบบนี้จะมีความหมายเหมือนกับ ๒ คำสั่งที่ใช้ `` ในตัวอย่างก่อนหน้า

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

สำหรับพวกคำสั่งบางตัวเช่น cat head tail พวกนี้จะอ่านข้อมูลจากไฟล์เพื่อนำมาแสดง แต่ถ้าเราอยากให้คำสั่งพวกนี้รับค่าที่เป็นผลลัพธ์จากคำสั่งอื่น แทนที่จะรับค่าจากไฟล์ก็ทำได้ เช่นกัน กรณีแบบนี้อาจใช้เครื่องหมาย | เรียกว่า ไปป์ (pipe)

ตัวอย่างเช่น ถ้าเราต้องการค้นชื่อไฟล์แต่ให้แสดงแค่ ๓ ตัวสุดท้าย อาจเขียนแบบนี้
ls -l | tail -3

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

ข้อแตกต่างระหว่าง `` กับ | ก็คือปกติ | จะใช้แทนการอ่านข้อมูลจากไฟล์ แต่ `` จะแทนตัวหนังสือที่ป้อนโดยตรง ดังนั้นโดยทั่วไปวิธีการใช้จึงต่างกัน

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

นอกจากนี้เรายังอาจพบการประยุกต์ใช้ `` และ | แบบอื่นๆได้อีกมากมาย



การเขียนหลายคำสั่งต่อกันทีเดียว

หากต้องการเขียนหลายคำสั่งต่อกันให้รันต่อกันไปก็ทำได้โดยใส่ ; ปิดท้ายคำสั่งแรก แล้วก็เขียนคำสั่งถัดไปต่อได้เลย เช่น
mkdir aaa; ls > aaa/a.txt

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

ถ้าใช้ && เป็นตัวเชื่อม คำสั่งหลังจะทำเมื่อคำสั่งหน้าทำเสร็จโดยไม่มีข้อผิดพลาด เช่น
ls aaa && ls > aaa/a.txt

ถ้าโฟลเดอร์ชื่อ aaa มีตัวตนอยู่ คำสั่ง ls ก็จะไม่มีปัญหาอะไร จึงทำคำสั่งข้างหลัง && แต่ถ้าไม่มีโฟลเดอร์ชื่อนี้ก็จะมีปัญหาและไม่มีการทำอะไรต่อ

ถ้าใช้ || เป็นตัวเชื่อม คำสั่งหลังจะทำเมื่อคำสั่งหน้าทำไม่สำเร็จ เช่น
ls aaa || mkdir aaa

แบบนี้ถ้าไม่มีโฟลเดอร์ aaa อยู่ก็จะถูกสร้างขึ้นมาใหม่

อนึ่ง ระวังว่า && กับ || ในที่นี้มีความหมายคนละแบบกับในภาษาซี ดังนั้นอย่าสับสน



การดูขนาดของโฟลเดอร์

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

ตัวอย่าง
du -h /usr/lib/python3/dist-packages/

ได้
136K    /usr/lib/python3/dist-packages/__pycache__
40K    /usr/lib/python3/dist-packages/ptyprocess/__pycache__
88K    /usr/lib/python3/dist-packages/ptyprocess
(ฯลฯ)

นอกจากนี้ยังอาจใส่ -k ถ้าต้องการให้เป็นหน่วย kb ทั้งหมด และใส่ -m ถ้าต้องการให้เป็น Mb

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

หากต้องการดูขนาดรวมทั้งหมดของโฟลเดอร์ที่อยู่นั้นโดยไม่แสดงรายละเอียดข้างในให้ใส่ -s ไปด้วย
du -sh /usr/lib/python3

ได้
45M    /usr/lib/python3

ถ้าต้องการหาขนาดของทุกโฟลเดอร์ย่อยภายในโฟลเดอร์ที่อยู่นี้ก็พิมพ์
du -sh *

เพียงแต่ว่าแบบนี้จะแสดงได้แค่โฟลเดอร์ที่ไม่ได้ขึ้นต้นด้วย . เท่านั้น ถ้าต้องการให้ครอบคลุมหมดจริงๆอาจใช้
du -sh `ls -A`

ถ้าใส่ -a จะแสดงขนาดของไฟล์ภายในโฟลเดอร์ด้วย
du -a



การดูขนาดและพื้นที่ว่างในไดรฟ์

หากต้องการดูสภาพการใช้งานของไดรฟ์ทั้งหมดว่ามีเท่าไหร่ใช้ไปเท่าไหร่เหลือที่ว่างเท่าไหร่สามารถทำได้โดยใช้คำสั่ง df และสามารถเติม -h หรือ -k หรือ -m ได้เช่นเดียวกับ du
df -h

ได้
Filesystem      Size  Used Avail Use% Mounted on
udev            1.9G     0  1.9G   0% /dev
tmpfs           394M  1.6M  393M   1% /run
/dev/sda1        63G  7.9G   52G  14% /
(ฯลฯ)

ถ้าหากระบุไฟล์หรือโฟลเดอร์ไปด้วยจะเป็นการระบุแค่ฮาร์ดดิสก์ที่บรรจุไฟล์นั้นไว้ เช่นถ้าต้องการให้แสดงแค่ฮาร์ดดิสก์ของโฟลเดอร์ที่อยู่ตอนนี้ก็เขียนแบบนี้
df -h .

วิธีนี้ยังทำให้เรารู้ว่าโฟลเดอร์นั้นๆอยู่ในไดรฟ์ไหนด้วย



ดูข้อมูลของ OS ที่ใช้

การดูเวอร์ชันของ OS สำหรับ mac ใช้คำสั่ง sw_vers
sw_vers

ได้
ProductName:    Mac OS X
ProductVersion:    10.14.2
BuildVersion:    18C54

ส่วน linux ใช้คำสั่ง lsb_release เพียงแต่บางรุ่นก็อาจไม่ได้ติดตั้งคำสั่งนี้ไว้ ต้องติดตั้งเพิ่มเอาเอง
lsb_release -a

ได้
Distributor ID:    Ubuntu
Description:    Ubuntu 18.04.1 LTS
Release:    18.04
Codename:    bionic

โดย -a ในที่นี้หมายถึงให้แสดงข้อมูลทั้งหมด

นอกจากนี้ยังมีคำสั่ง uname สำหรับแสดงข้อมูลอีกหลายอย่างเช่นวันที่ติดตั้ง เคอร์เนล ฯลฯ
uname -a

ได้
Linux pasokon 4.15.0-43-generic #46-Ubuntu SMP Thu Dec 6 14:45:28 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux



การสั่งโปรแกรมให้ทำงานอยู่ในฉากหลัง

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

แต่ก็มีวิธีที่ทำให้สั่งแล้วคำสั่งไปทำอยู่ที่ฉากหลังแล้วเราก็เอาเทอร์มินัลนั้นไปทำอย่างอื่นต่อได้

วิธีการทำได้โดยง่ายด้วยการใส่ & ลงไปหลังคำสั่ง เช่น
find / -name python* &> findpython.txt &

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



ดูโปรแกรมที่รันอยู่ในเครื่อง

หากต้องการรู้สถานะของโปรแกรมที่รันอยู่ในฉากหลังโดยผ่านเทอร์มินัลที่เปิดอยู่นี้ก็อาจใช้คำสั่ง jobs
jobs -l

จะได้ผลออกมาแบบนี้
[1]+  6307 Running                 find / -name python* &> findpython.txt &

[1] คือหมายเลขของงานที่สั่งไป ปกติจะเรียงตั้งแต่ 1 ไป ส่วนเลขที่อยู่ถัดมาคือ PID (process ID) เป็นเลขรหัสของงานนั้นๆ

ที่ใส่ -l ไปนั้นเพื่อให้แสดงเลข PID ด้วย ถ้าไม่ได้ใส่ก็จะไม่แสดง

นอกจากนี้ยังอาจใช้คำสั่ง ps เพื่อแสดงโปรแกรมคำสั่งทั้งหมดที่ถูกรันผ่านเทอร์มินัลที่เราเปิดอยู่นี้
ps -l

จะขึ้นแสดงคำสั่ง find ที่เราเพิ่งสั่งไป และตัวคำสั่ง ps นี้เอง รวมถึง bash ซึ่งก็คือเทอร์มินัลที่เราเปิดอยู่นี้
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1001  6307 19869 51  80   0 -  7115 tg_req pts/0    00:00:06 find
0 R  1001  6342 19869  0  80   0 -  9016 -      pts/0    00:00:00 ps
0 S  1001 19869 19859  0  80   0 -  7516 wait   pts/0    00:00:00 bash

PPID คือ PID ของคำสั่งหลักที่ใช้สั่งคำสั่งนั้นๆ เช่นจะเห็นว่าทั้ง find และ ps มี PPID เป็น 19869 ซึ่งคือ PID ของ bash ของเทอร์มินัลที่เปิดอยู่นี้

แต่ถ้าสั่ง ps -e จะแสดงโปรแกรมทั้งหมดที่ถูกรันอยู่
ps -el

จะพบว่ามีโปรแกรมอะไรต่างๆรันอยู่มากมายที่เราอาจไม่ได้สั่งเองและไม่รู้ว่าคืออะไรมาจากไหน เพราะระบบได้สร้างโปรแกรมต่างๆรันทิ้งไว้เป็นฉากหลังมากมายเป็นปกติ
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
4 S     0     1     0  0  80   0 - 40037 -      ?        00:00:04 systemd
1 S     0     2     0  0  80   0 -     0 -      ?        00:00:00 kthreadd
1 I     0     4     2  0  60 -20 -     0 -      ?        00:00:00 kworker/0:0H
1 I     0     6     2  0  60 -20 -     0 -      ?        00:00:00 mm_percpu_wq
(ฯลฯ)

นอกจากนี้ยังมีคำสั่ง top ซึ่งเอาไว้จับตาดูว่าในเครื่องมีการรันโปรแกรมหรือคำสั่งอะไรอยู่บ้าง
top

จะได้ผลประมาณนี้



top จะแสดงรายการโปรแกรมที่รันอยู่ขณะนั้นโดยละเอียดและจะเปลี่ยนทุก ๕ วินาที แต่ถ้าอยากกำหนดความถี่เอาเองก็ให้ใส่ -d ตามด้วยเวลา เช่นถ้าต้องการให้เปลี่ยนทุกวินาทีก็ใส่ 1
top -d 1

สิ่งที่แสดงอยู่นั้นไม่ใช่ทั้งหมดแต่เป็นแค่ส่วนที่เรียงอยู่บนๆสุดเท่านั้น หากต้องการตัวต่อๆมาให้กดลง ↓

โดยทั่วไปการเรียงจะเอาตัวที่กินการใช้งาน CPU เยอะขึ้นก่อนเปลี่ยนวิธีการจัดเรียงก็อาจพิมพ์
N เรียงตาม PID
M เรียงตามการใช้ RAM
P เรียงตามการใช้ CPU
T เรียงตามว่าเวลาว่าทำงานมานานแค่ไหนแล้ว

ถ้าต้องการออกให้กด q



การสั่งปิดโปรแกรมที่ไม่ต้องการทิ้ง

บางครั้งโปรแกรมที่เราสั่งรันไปอาจเกิดปัญหาขึ้นมา ไม่สามารถสิ้นสุดการทำงานได้ตามปกติ เวลาแบบนั้นอาจต้องสั่งปิดเอง

หรือเราอาจจะรันคำสั่งให้ทำงานอยู่ในฉากหลังด้วย & แล้วเกิดต้องการปิดขึ้นมา

กรณีแบบนี้สามารถสั่งปิดได้ด้วยการพิมพ์คำสั่ง kill ตามด้วยเลข PID

เช่นใช้คำสั่ง jobs เพื่อดู PID พอรู้ PID ก็นำมาสั่งปิด
kill 6307

นอกจากนี้ยังสั่งปิดด้วยการพิมพ์ kill %เลขงาน (ซึ่งแสดงเมื่อใช้คำสั่ง jobs) เช่น
kill %1

แม้ชื่อคำสั่งอาจฟังดูน่ากลัว แต่จริงๆแล้วไม่ได้ไปฆ่าใคร แค่เป็นการสั่งปิดโปรแกรมเท่านั้น

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

ในเวลาแบบนั้นต้องเติม -9 เข้าไป จะเป็นการบังคับให้ปิดทันทีโดยไม่ต้องเข้ากระบวนการปิดแบบปกติ
kill -9 6307

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

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

แบบนี้โปรแกรมภาษาไพธอนที่รันอยู่ทั้งหมดจะถูกสั่งปิดเรียบ

แต่ถ้าแค่ต้องการให้แสดง PID ของโปรแกรมที่ต้องการทั้งหมดเพื่อมาคัดดูอีกทีก็อาจใช้คำสั่ง pidof เพียงแต่ว่าคำสั่งนี้มีแค่ใน linux ไม่มีใน mac ต้องลงเพิ่ม

เช่นถ้าเราเปิดหน้าต่าง bash อยู่
pidof bash # ได้ 19869 7389

ถ้าใช้วิธีการเขียนด้วย `` แบบนี้ก็สามารถปิดโปรแกรมไพธอนทั้งหมดได้เหมือนกัน
kill `pidof python`



การปิดโปรแกรมหรือหยุดชั่วคราวแล้วกลับมาทำต่อ

เวลาที่สั่งคำสั่งหรือรันโปรแกรมอะไรไปแล้วยังไม่เสร็จแล้วอยากเลิกกลางคันปกติจะปิดได้ด้วยการกด ctrl+c

** โดยทั่วไปคนส่วนใหญ่จะคุ้นเคยว่า ctrl+c จะเป็นคำสั่งคัดลอก แต่สำหรับในเทอร์มินัลแล้ว ctrl+c จะมีความหมายเป็นการปิดโปรแกรม ดังนั้นจึงต้องระวังสับสน ตั้งใจจะคัดลอกข้อความแต่กลายเป็นเผลอไปปิดโปรแกรม

แต่ถ้าไม่ได้ต้องการปิดไปเลยแต่แค่อยากจะหยุดชั่วคราวให้กด ctrl+z

หลังจากนั้นถ้าต้องการกลับมาทำต่อให้พิมพ์คำสั่ง fg หรือถ้าต้องการให้รันอยู่ในฉากหลังให้พิมพ์ bg

ตัวอย่าง
find / -name python* &> findpython.txt
^Z
[1]+  Stopped                 find / -name python* &> findpython.txt

จากนั้นสั่ง
fg %1

คำสั่งจะกลับมาทำต่อ

แต่ถ้าสั่ง
bg %1

คำสั่งก็จะกลายเป็นรันอยู่ในฉากหลัง เหมือนกับเมื่อพิมพ์คำสั่งแล้วต่อท้ายด้วย &

งานที่สั่งรันอยู่เบื้องหลังนี้ ถ้าพิมพ์ fg ก็จะเปลี่ยนมาเป็นงานที่ทำอยู่เบื้องหน้าได้เช่นกัน

ดังนั้นหากเราสั่งคำสั่งอะไปแล้วรู้สึกว่าน่าจะต้องใช้เวลานาน อยากเอาเทอร์มินัลมาทำอย่างอื่นต่อก็อาจกด ctrl+z เพื่อหยุดไว้แล้วพิมพ์ bg เพื่อให้มันทำงานต่อเบื้องหลังก็ได้



การดูบันทึกคำสั่งที่เคยพิมพ์มาก่อนหน้า

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

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

แล้วจะแสดงคำสั่งทั้งหมดพร้อมเลขลำดับคำสั่ง แบบนี้
  217  ls
  218  pidof bash
  219  killall python
  220  history 4

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

หรือถ้าพิมพ์ !! ก็จะเป็นการทำตามคำสั่งล่าสุด
!!

ถ้าพิมพ์ ! แล้วตามด้วยคำจะเป็นการทำตามคำสั่งล่าสุดที่ใช้คำสั่งที่ขึ้นต้นด้วยคำนั้น เช่น
!l

จะเป็นการไปทำคำสั่ง ls ที่บรรทัด 217

ถ้าหากอยากลบบันทึกทั้งหมดก็ทำได้โดยเพิ่มตัวเลือกเสริม -c เข้าไป เช่นลองสั่ง
history -c
ls
history

จะพบว่าบันทึกถูกลบไปแล้ว เริ่มบันทึกประวัติศาสตร์กันใหม่
    1  ls
    2  history

หากต้องการเขียนลงไฟล์แทนที่จะพิมพ์ออกมาในนั้นเลยก็เพิ่ม -w แล้วตามด้วยชื่อเข้าไป เช่น
history -w histoire.txt

ปกติแล้วเวลาที่ปิดเทอร์มินัลไป history จะถูกนำไปบันทึกในไฟล์ .bash_history โดยอัตโนมัติ พอเปิดขึ้นมาใหม่ไฟล์นี้จะถูกอ่าน แล้ว history ก็จะต่อจากคราวนั้น

แต่ถ้าพิมพ์ history -w โดยไม่ระบุชื่อไฟล์จะเป็นการบันทึกเข้าไปใน .bash_history

ตัวเลือก -a จะคล้ายกับ -w แต่ต่างกันตรงที่ไม่ใช่การเขียนทับแต่เป็นการเขียนต่อเข้าไป

ส่วน -r จะเป็นการอ่าน history จากไฟล์มาเขียนต่อลง history ของเทอร์มินัล



การจัดการสิทธิ์ของไฟล์

การจัดการเรื่องสิทธิ์ต่างๆของไฟล์สามารถทำได้โดยคำสั่ง chmod, chown และ chgrp รายละเอียดเรื่องนี้แยกเขียนไว้ใน https://phyblas.hinaboshi.com/20190126



คำสั่งเบื้องต้นที่น่าจะต้องใช้งานบ่อยก็น่าจะมีอยู่ประมาณเท่านี้

สรุปคำสั่ง

สรุปคำสั่งที่ยกมาทั้งหมด ไล่ตามอักษร
alias สร้างหรือแสดงสมนาม
cat แสดงข้อความในไฟล์
bg สั่งให้โปรแกรมทำงานอยู่ในฉากหลัง
cd ย้ายตำแหน่งที่อยู่
cp คัดลอกไฟล์
df แสดงขนาดและพื้นที่ว่างในไดรฟ์
du แสดงขนาดของโฟลเดอร์
echo แสดงค่าตัวแปร
export ดูค่าตัวแปรสภาพแวดล้อมหรือสร้างขึ้นใหม่
fg สั่งให้โปรแกรมมาทำงานอยู่เป็นฉากหน้า
find ค้นหาไฟล์
head ดูส่วนต้นของไฟล์
history ย้อนดูคำสั่งที่เคยพิมพ์มา
info แสดงข้อมูลรายละเอียดของคำสั่ง
jobs แสดงรายการงานที่สั่งให้รันอยู่ในฉากหลัง
kill สั่งปิดโปรแกรม
killall สั่งปิดโปรแกรมชนิดที่ต้องการทั้งหมด
ls แสดงไฟล์ต่างๆที่อยู่ในโฟลเดอร์
lsb_release ดูเวอร์ชัน OS (ใน linux)
man แสดงข้อมูลวิธีการใช้งานคำสั่ง
mkdir สร้างโฟลเดอร์
mv ย้ายหรือเปลี่ยนชื่อไฟล์
open เปิดไฟล์ (ใน mac)
ps แสดงรายการโปรแกรมที่ทำงานอยู่
pwd แสดงตำแหน่งโฟลเดอร์ที่กำลังอยู่
rm ลบไฟล์
rmdir ลบโฟลเดอร์
source รันคำสั่งจากไฟล์
sw_vers ดูเวอร์ชัน OS (ใน mac)
tail ดูส่วนท้ายของไฟล์
top ดูสถานะการใช้งานของเครื่องและโปรแกรมที่ทำงานอยู่
type แสดงชนิดของคำสั่ง
unalias ลบสมนาม
uname แสดงข้อมูลของ OS
unset ลบตัวแปร
xdg-open เปิดไฟล์ (ใน linux)



อ้างอิง


-----------------------------------------

囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧囧

ดูสถิติของหน้านี้

หมวดหมู่

-- คอมพิวเตอร์ >> shell

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

สารบัญ

รวมคำแปลวลีเด็ดจากญี่ปุ่น
python
-- numpy
-- matplotlib

-- pandas
-- pytorch
maya
การเรียนรู้ของเครื่อง
-- โครงข่าย
     ประสาทเทียม
javascript
บันทึกในญี่ปุ่น
บันทึกในจีน
-- บันทึกในปักกิ่ง
-- บันทึกในฮ่องกง
-- บันทึกในมาเก๊า
บันทึกในไต้หวัน
บันทึกในยุโรปเหนือ
บันทึกในประเทศอื่นๆ
เรียนภาษาจีน
qiita
บทความอื่นๆ

บทความแบ่งตามหมวด



ติดตามอัปเดตของบล็อกได้ที่แฟนเพจ

  ค้นหาบทความ

  บทความแนะนำ

เรียนรู้วิธีการใช้ regular expression (regex)
หลักการเขียนทับศัพท์ภาษาจีนกวางตุ้ง
การใช้ unix shell เบื้องต้น ใน linux และ mac
หลักการเขียนทับศัพท์ภาษาจีนกลาง
g ในภาษาญี่ปุ่นออกเสียง "ก" หรือ "ง" กันแน่
ทำความรู้จักกับปัญญาประดิษฐ์และการเรียนรู้ของเครื่อง
ค้นพบระบบดาวเคราะห์ ๘ ดวง เบื้องหลังความสำเร็จคือปัญญาประดิษฐ์ (AI)
หอดูดาวโบราณปักกิ่ง ตอนที่ ๑: แท่นสังเกตการณ์และสวนดอกไม้
พิพิธภัณฑ์สถาปัตยกรรมโบราณปักกิ่ง
เที่ยวเมืองตานตง ล่องเรือในน่านน้ำเกาหลีเหนือ
บันทึกการเที่ยวสวีเดน 1-12 พ.ค. 2014
แนะนำองค์การวิจัยและพัฒนาการสำรวจอวกาศญี่ปุ่น (JAXA)
เล่าประสบการณ์ค่ายอบรมวิชาการทางดาราศาสตร์โดยโซวเคนได 10 - 16 พ.ย. 2013
ตระเวนเที่ยวตามรอยฉากของอนิเมะในญี่ปุ่น
เที่ยวชมหอดูดาวที่ฐานสังเกตการณ์ซิงหลง
บันทึกการเที่ยวญี่ปุ่นครั้งแรกในชีวิต - ทุกอย่างเริ่มต้นที่สนามบินนานาชาติคันไซ
หลักการเขียนทับศัพท์ภาษาญี่ปุ่น
ทำไมจึงไม่ควรเขียนวรรณยุกต์เวลาทับศัพท์ภาษาต่างประเทศ
ทำไมถึงอยากมาเรียนต่อนอก
เหตุผลอะไรที่ต้องใช้ภาษาวิบัติ?

ไทย

日本語

中文