CLI คืออะไร ? Command-Line Interface คืออะไร ? พร้อมประวัติความเป็นมา

CLI คืออะไร ? หรือ Command-Line Interface คืออะไร ?

ในโลกของคอมพิวเตอร์ และการพัฒนาซอฟต์แวร์ ส่วนต่อประสานกับผู้ใช้ (UI) มีบทบาทสำคัญในการเชื่อมโยงระหว่างมนุษย์ กับ คอมพิวเตอร์ (PC) หนึ่งในรูปแบบที่เก่าแก่ แต่ยังคงทรงพลัง และได้รับความนิยมในหมู่นักพัฒนา และผู้ดูแลระบบ คือ Command-Line Interface หรือ CLI แม้จะไม่มีกราฟิกสวยงามเหมือนระบบ ส่วนต่อประสานกราฟิกกับผู้ใช้ (GUI) ที่คนทั่วไปนิยมใช้งานกัน แต่ CLI ก็มีจุดเด่นด้านความยืดหยุ่น, ความเร็ว และการควบคุมที่ลึกกว่า มีงานบางอย่างที่สามารถทำได้แค่ทาง CLI เท่านั้น

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

ส่วนติดต่อผู้ใช้แบบบรรทัดคำสั่ง คืออะไร ? (What is Command-Line Interface ?)

CLI หรือ Command-Line Interface หมายถึง UI ผู้ใช้แบบข้อความ (Text-Based UI) ที่ใช้สำหรับเรียกใช้งานโปรแกรม, จัดการไฟล์ในคอมพิวเตอร์ และโต้ตอบกับระบบ โดย CLI จะรับคำสั่งจากผู้ใช้ผ่าน คีย์บอร์ด (Keyboard) ซึ่งคำสั่งเหล่านั้นจะถูกประมวลผลเมื่อพิมพ์ที่ตำแหน่งพร้อมรับคำสั่ง (Command Prompt)

CLI ยังมีชื่อเรียกอื่น (ให้งงเล่น ๆ อีกมากมาย) เช่น Command-Line User Interface, Console User Interface และ Character User Interface โดยทั้งหมดหมายถึงรูปแบบการโต้ตอบผ่านข้อความที่ไม่มีกราฟิกนั่นเอง

ในปัจจุบัน ระบบปฏิบัติการ (OS) ส่วนใหญ่ อย่าง วินโดวส์ (Windows), แมคโอเอส (macOS) หรือแม้แต่ ลีนุกซ์ (Linux) จะมี GUI เป็นค่าเริ่มต้น แต่ระบบที่ใช้พื้นฐาน Unix หลายระบบยังคงรองรับทั้ง CLI และ GUI เพื่อความยืดหยุ่นในการใช้งาน

ตัวอย่างของ CLI ได้แก่ ระบบปฏิบัติการ MS-DOS และ Command Shell ใน Windows รวมถึงแพลตฟอร์มพัฒนาภาษาโปรแกรม เช่น Python ก็สามารถใช้งานผ่าน CLI ได้เช่นกัน

แม้ความนิยมของ CLI จะลดลงไปมาก หลังจากการมาถึงของระบบปฏิบัติการที่มี GUI ในยุค ค.ศ. 1980 (พ.ศ. 2523) เช่น Microsoft Windows และ macOS รุ่นดั้งเดิม แต่ CLI ยังคงเป็นเครื่องมือสำคัญสำหรับผู้เชี่ยวชาญด้านไอที, นักพัฒนาซอฟต์แวร์, ผู้ดูแลระบบ และผู้ดูแลเครือข่ายจำนวนมาก ที่ต้องการ UI ที่แม่นยำ และสามารถทำซ้ำได้ในการควบคุมดูแลระบบ

ฟังก์ชันหลักของ ส่วนติดต่อผู้ใช้แบบบรรทัดคำสั่ง (Primary functions of Command-Line Interface)

CLI ถูกออกแบบมาเพื่อทำหน้าที่ดังต่อไปนี้เป็นหลัก

• รันคำสั่ง : ใช้ในการเรียกใช้งาน
  • โปรแกรม
  • สคริปต์
  • เครื่องมือของระบบ
  • พารามิเตอร์ที่กำหนด
• ทำงานอัตโนมัติ : เชื่อมโยงคำสั่งหลายชุดผ่านสคริปต์ หรือเครื่องมือบรรทัดคำสั่ง เพื่อทำงานซ้ำ ๆ โดยอัตโนมัติ
• เข้าถึงทรัพยากรระบบ :
  • ใช้ในการนำทางระบบไฟล์
  • จัดการโปรเซส
  • ปรับแต่งสภาพแวดล้อมของระบบ
• เชื่อมต่อกับ API และบริการต่าง ๆ :
  • ใช้ในการสื่อสาร กับแพลตฟอร์ม คลาวด์ (Cloud)
  • ระบบควบคุมเวอร์ชัน
  • ระบบ Continuous Integration (CI)/Continuous Delivery (CD)
• ปรับแต่งพฤติกรรมการทำงาน :
  • ใช้แฟล็ก (Flags)
  • อาร์กิวเมนต์ (Arguments)
  • ตัวแปรสภาพแวดล้อม (Environment Variables) เพื่อปรับแต่งการทำงานของคำสั่งให้ตรงตามความต้องการ

ภาพจาก : https://betterdev.blog/command-line-arguments-anatomy-explained/

• รองรับสถาปัตยกรรมซอฟต์แวร์แบบแยกส่วน : เปิดให้เข้าถึงองค์ประกอบเฉพาะของระบบ เพื่อให้เหมาะกับการออกแบบแบบไมโครเซอร์วิส และระบบแบบโมดูลาร์

ประเภทของการใช้งาน ส่วนติดต่อผู้ใช้แบบบรรทัดคำสั่ง (Types of Command-Line Interface operations)

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

• การควบคุมเวอร์ชัน (Version Control) : ใช้จัดการคลังซอร์สโค้ดด้วยเครื่องมือ อย่างเช่น
  • git
  • gh (GitHub CLI)
  • svn
• การสร้าง และนำระบบไปใช้งาน (Build and Deployment) : รันสคริปต์สำหรับการ build เช่น
  • make
  • npm
  • mvn
  • นำแอปพลิเคชันไปใช้งานผ่านเครื่องมืออย่าง
    • kubectl
    • terraform
    • az (Azure CLI)
    • aws (AWS CLI)
• การบริหารระบบ (System Administration) :
  • ใช้ติดตั้งแพ็กเกจ
  • จัดการผู้ใช้งาน
  • ปรับแต่งบริการต่าง ๆ บนระบบปฏิบัติการ
• การประมวลผลข้อมูล (Data processing) :
  • ใช้ในการแยกวิเคราะห์ การจัดเก็บข้อมูล (Log) แปลงข้อมูล
  • รันกระบวนการวิเคราะห์ข้อมูลแบบ Pipeline
• การพัฒนาเครื่องมือ (Tool development) : สร้าง CLI แบบกำหนดเองด้วยภาษาโปรแกรม  เพื่อปรับปรุงกระบวนการภายในองค์กร เช่น
  • Python
  • Go
  • Node.js

ส่วนติดต่อผู้ใช้แบบบรรทัดคำสั่ง ทำงานอย่างไร ? (How does Command-Line Interface work ?)

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

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

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

ภาพจาก : https://www.geeksforgeeks.org/linux-unix/linux-operating-system-cli-command-line-interface-and-gui-graphic-user-interface/

ประวัติความเป็นมาของ ส่วนติดต่อผู้ใช้แบบบรรทัดคำสั่ง (History of Command-Line Interface)

CLI มีวิวัฒนาการมาจากรูปแบบการสื่อสารที่มนุษย์ใช้ผ่านเครื่องพิมพ์โทรเลข (Teleprinter หรือ TTY) ซึ่งในบางกรณีใช้ในการส่งคำสั่ง หรือการยืนยันผ่านระบบ Telex ระบบคอมพิวเตอร์ยุคแรกมักใช้เครื่องพิมพ์โทรเลขเป็นช่องทางหลักในการโต้ตอบ กับผู้ควบคุมระบบ

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

เมื่อยุคไมโครคอมพิวเตอร์เข้ามาแทนที่ เทอร์มินัลแบบฮาร์ดแวร์ก็ถูกแทนที่ด้วยโปรแกรมจำลองเทอร์มินัล (Terminal Emulator) ซึ่งเป็นซอฟต์แวร์บน PC ที่สามารถตีความสัญญาณเทอร์มินัลผ่านพอร์ตอนุกรมของเครื่อง โดยมักใช้เชื่อมต่อ คอมพิวเตอร์ส่วนบุคคล (PC) กับเมนเฟรมที่มีอยู่เดิม หรือเชื่อมต่อระหว่าง PC เข้าด้วยกัน บางเครื่องยังใช้รันซอฟต์แวร์ระบบกระดานข่าว (Bulletin Board System)

ภาพจาก : https://glasstty.com/

CLI ของระบบปฏิบัติการยุคแรกมักถูกฝังอยู่ในโปรแกรมควบคุมระบบหลัก (Resident Monitor) และไม่สามารถเปลี่ยนได้ง่าย การนำเสนอ Shell แบบเปลี่ยนได้ครั้งแรกเกิดขึ้นในระบบปฏิบัติการ Multics ซึ่งรองรับการแบ่งเวลาใช้งาน ในปี ค.ศ. 1964 (พ.ศ. 2507) Louis Pouzin จากศูนย์คอมพิวเตอร์ MIT ได้พัฒนาเครื่องมือชื่อ RUNCOM สำหรับรันสคริปต์คำสั่งพร้อมรองรับการแทนที่อาร์กิวเมนต์ Louis Pouzi เป็นผู้บัญญัติคำว่า "Shell" เพื่ออธิบายแนวคิดการใช้คำสั่งแบบภาษาการเขียนโปรแกรม และเขียนบทความเกี่ยวกับการนำแนวคิดนี้ไปใช้ในระบบ Multics ต่อมาในปี ค.ศ. 1964 (พ.ศ. 2508) เขากลับไปยังประเทศฝรั่งเศส และ Glenda Schroeder ได้พัฒนา Shell ตัวแรกของ Multics

Shell แรกของ Unix คือ V6 Shell ซึ่งพัฒนาโดย Ken Thompson ในปี ค.ศ. 1971 (พ.ศ. 2514) ที่ Bell Labs โดยอิงแนวคิดจาก Shell ของ Schroeder ต่อมาในปี ค.ศ. 1977 (พ.ศ. 2520) มีการเปิดตัว Bourne Shell เพื่อแทนที่ V6 Shell โดยนอกจากใช้เป็นตัวแปลคำสั่งแบบโต้ตอบแล้ว ยังออกแบบให้ใช้เป็นภาษาสคริปต์ที่รองรับโครงสร้างโปรแกรมอย่างเต็มรูปแบบ Bourne Shell เป็นพื้นฐานให้เกิด KornShell (ksh), Almquist Shell (ash) และ Bourne-again Shell (Bash) ที่ได้รับความนิยมอย่างสูง

ไมโครคอมพิวเตอร์ยุคแรก เช่น CP/M, DOS และ AppleSoft BASIC ต่างก็ใช้ CLI เป็นหลัก ในช่วงทศวรรษ ค.ศ. 1980-1990 (พ.ศ. 2523-2533) การมาถึงของ Apple Macintosh และ ระบบปฏิบัติการ (OS) Microsoft วินโดวส์ (Windows) ทำให้ CLI ถูกแทนที่ด้วย GUI อย่างไรก็ตาม CLI ยังคงมีให้ใช้งานเป็นทางเลือก โดยเฉพาะในงานบริหารระบบ, การเขียนโปรแกรม และการประมวลผลแบบกลุ่มคำสั่ง (Batch Processing)

ในเดือนพฤศจิกายน ค.ศ. 2006 (พ.ศ. 2549) Microsoft ได้เปิดตัว Windows PowerShell เวอร์ชัน 1.0 (ชื่อเดิมคือ Monad) ซึ่งรวมฟีเจอร์ของ Shell แบบ Unix เข้ากับโครงสร้างเชิงวัตถุของ .NET Framework Microsoft แล้วยังมีแพ็กเกจ โอเพนซอร์ส (Open-Source) สำหรับ Windows เช่น MinGW และ Cygwin ที่ให้ CLI แบบ Unix และยังให้บริการ MKS Korn shell ผ่านส่วนเสริม Services for UNIX

ตั้งแต่ปี ค.ศ. 2001 (พ.ศ. 2544) ระบบปฏิบัติการ แมคโอเอส (macOS) ของ Apple ได้พัฒนาบนพื้นฐานของระบบปฏิบัติการแบบ Unix ที่ชื่อว่า Darwin โดยผู้ใช้สามารถเข้าถึง CLI แบบ Unix ได้ผ่านโปรแกรม Terminal ซึ่งอยู่ในโฟลเดอร์ Utilities ของ Applications หรือผ่านการล็อกอินระยะไกลด้วย ssh macOS ใช้ Z shell เป็น Shell เริ่มต้น โดยยังมี Bash, tcsh และ KornShell ให้ใช้งาน ก่อน macOS Catalina นั้น Bash เคยเป็น Shell เริ่มต้นมาก่อน