7 ทริค Linux สำหรับมือใหม่ที่ช่วยให้ทำงานได้เร็วขึ้นทันที

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

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

1) ใช้ alias ย่อคำสั่งยาวให้สั้นและจำง่าย

ถ้าคุณต้องพิมพ์คำสั่งเดิมบ่อย ๆ เช่น git, docker หรือ kubectl การสร้าง alias จะช่วยลดจำนวนตัวอักษรที่ต้องพิมพ์ และทำให้ทำงานได้ลื่นขึ้นมาก

ตัวอย่างเช่น

alias gs='git status'
alias gp='git pull --rebase'
alias k='kubectl'

หลังจากตั้งค่าแล้ว คุณสามารถพิมพ์ gs แทน git status ได้ทันที

หากต้องการให้ alias ใช้งานได้ทุกครั้งที่เปิด terminal ให้เพิ่มลงในไฟล์ต่อไปนี้

• ~/.bash_aliases
• หรือ ~/.bashrc

จากนั้น reload การตั้งค่าด้วยคำสั่ง

source ~/.bashrc

ทริคนี้เหมาะมากสำหรับคนที่ต้องรันคำสั่งชุดเดิมซ้ำ ๆ ระหว่างวัน

2) ใช้ alias แบบกันพลาดกับคำสั่งอันตราย

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

ตัวอย่างที่แนะนำคือ

alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'

ความหมายคือ

• rm -i ให้ถามก่อนลบ
• cp -i ให้ถามก่อนเขียนทับไฟล์
• mv -i ให้ถามก่อนย้ายหรือทับไฟล์เดิม

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

3) ค้นประวัติคำสั่งอย่างรวดเร็วด้วย Ctrl+R

เวลาต้องการรันคำสั่งเดิม หลายคนมักกดลูกศรขึ้นซ้ำ ๆ เพื่อย้อนหา แต่จริง ๆ แล้วมีวิธีที่เร็วกว่าเยอะ คือการใช้ Ctrl+R

วิธีใช้คือ

1. กด Ctrl+R
2. พิมพ์บางส่วนของคำสั่งที่เคยใช้
3. ระบบจะค้นย้อนหลังให้อัตโนมัติ
4. กด Ctrl+R ซ้ำเพื่อดูผลลัพธ์ก่อนหน้า
5. กด Enter เพื่อรันทันที หรือกดลูกศรขวาเพื่อแก้ไขก่อนรัน

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

4) เพิ่มเวลาใน history เพื่อแกะรอยการทำงาน

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

ตั้งค่าได้ด้วยคำสั่ง

export HISTTIMEFORMAT='%F %T '

หลังจากตั้งค่าแล้ว เมื่อใช้คำสั่ง history คุณจะเห็น timestamp กำกับในแต่ละบรรทัด ทำให้รู้ได้ชัดเจนว่า

• รันคำสั่งอะไร
• รันเมื่อวันและเวลาใด
• ลำดับการทำงานเป็นอย่างไร

นี่เป็นทริคง่าย ๆ ที่ช่วยให้ history กลายเป็นบันทึกการทำงานที่มีคุณค่ามากขึ้น

5) ฝึกใช้ pipe ให้เป็นนิสัย เพื่อเชื่อมคำสั่งเล็ก ๆ ให้ทำงานใหญ่ได้

แนวคิดของ pipe คือให้คำสั่งหนึ่งส่ง output ไปเป็น input ของอีกคำสั่งหนึ่ง ทำให้คุณสามารถต่อเครื่องมือหลายตัวเข้าด้วยกันเป็น workflow ได้ โดยไม่ต้องคัดลอกข้อมูลไปมา

ตัวอย่างที่ใช้บ่อยมีดังนี้

ดู process ที่ใช้ RAM มากที่สุด 10 อันดับ

ps aux | sort -rk 4 | head -n 10

คำสั่งนี้จะดึงรายการ process ทั้งหมด จากนั้นเรียงตามการใช้หน่วยความจำ และแสดงเฉพาะ 10 อันดับแรก

ค้นหา error จาก log ของ nginx แบบอ่านง่าย

journalctl -u nginx | grep -i error | tail -n 50

คำสั่งนี้เหมาะสำหรับการไล่ดูปัญหาล่าสุดจาก service log อย่างรวดเร็ว

นับจำนวนไฟล์ตามชนิดไฟล์

find . -type f | sed 's/.*\.//' | sort | uniq -c | sort -nr | head

ช่วยให้เห็นว่าในโฟลเดอร์มีไฟล์นามสกุลอะไรบ้าง และชนิดไหนมีจำนวนมากที่สุด

เมื่อใช้ pipe คล่องขึ้น คุณจะเริ่มคิดงานเป็นขั้นตอนที่ต่อกันได้แบบอัตโนมัติ และลดงานซ้ำซ้อนลงอย่างมาก

6) ใช้ tee เพื่อบันทึกผลลัพธ์ลงไฟล์พร้อมดูบนหน้าจอ

บางครั้งคุณต้องการดูผลลัพธ์แบบสด ๆ บนหน้าจอ แต่ก็อยากเก็บ log ลงไฟล์ไว้ด้วย เช่น ตอนรัน test, deploy หรือ debug ปัญหา

คำสั่ง tee ช่วยเรื่องนี้ได้ดีมาก

ตัวอย่าง

make test | tee test.log

หากต้องการเพิ่มต่อท้ายไฟล์เดิม ใช้

make test | tee -a test.log

ข้อดีคือ

• เห็นผลลัพธ์ทันทีบนหน้าจอ
• เก็บหลักฐานไว้ตรวจย้อนหลังได้
• เหมาะกับงาน debug และ deployment

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

7) ใช้ xargs แปลงรายการหลายบรรทัดให้กลายเป็นคำสั่งที่รันต่อได้

xargs เหมาะกับงานที่มีรายการ input หลายบรรทัด แล้วต้องนำแต่ละรายการไปทำงานซ้ำ ๆ เช่น cleanup, batch processing หรือ automation

ตัวอย่างการลบไฟล์ .log ที่เก่ากว่า 7 วัน

find . -name '*.log' -mtime +7 -print0 | xargs -0 rm -i

จุดสำคัญคือการใช้ -print0 และ -0 เพื่อรองรับชื่อไฟล์ที่มีช่องว่างได้อย่างปลอดภัย

อีกตัวอย่างหนึ่งคือค้นหาไฟล์ที่มีคำว่า TODO แล้วเปิดด้วย editor ทีละไฟล์

grep -rl 'TODO' . | xargs -n 1 code

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

วิธีจำแบบสั้น ๆ

ถ้าจะสรุปให้จำง่าย สามารถจำได้ดังนี้

• alias = พิมพ์น้อยลง
• Ctrl+R และ history = เรียกของเก่ากลับมาเร็วขึ้น
• pipe, tee, xargs = เชื่อมเครื่องมือหลายตัวให้กลายเป็นสายการผลิต

สรุปท้าย

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

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