สวัสดีทุกคน! ในบทความนี้ เราจะพิจารณาบรรทัดคำสั่งอย่างละเอียด (หรือที่รู้จักในชื่อ CLI คอนโซล เทอร์มินัล หรือเชลล์)

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

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

ไปกันเถอะ! =D

สารบัญ

• ความแตกต่างระหว่างคอนโซล เทอร์มินัล บรรทัดคำสั่ง (CLI) และเชลล์
  • คอนโซล
  • เทอร์มินัล
  • เชลล์
  • บรรทัดคำสั่ง (CLI)
• ทำไมฉันถึงต้องสนใจการใช้เทอร์มินัลด้วย
• เปลือกหอยชนิดต่างๆ
  • ประวัติศาสตร์เล็กน้อย - Posix
  • ฉันจะรู้ได้อย่างไรว่าฉันกำลังเรียกใช้เชลล์อะไรอยู่
  • เปลือกไหนดีกว่ากัน?
    • ความคิดเห็นเกี่ยวกับการปรับแต่ง
• คำสั่งที่ใช้บ่อยและมีประโยชน์มากที่สุด
  • คำสั่ง Git
• บทแรกของเรา
• ปัดเศษขึ้น

ความแตกต่างระหว่างคอนโซล บรรทัดคำสั่ง (CLI) เทอร์มินัลและเชลล์

ฉันคิดว่าจุดเริ่มต้นที่ดีคือการรู้ว่าบรรทัดคำสั่งคืออะไร

เมื่อกล่าวถึงสิ่งนี้ คุณอาจเคยได้ยินคำว่า Terminal, console, command line, CLI และ shell ผู้คนมักใช้คำเหล่านี้สลับกัน แต่ความจริงแล้ว จริงๆ แล้วเป็นคนละสิ่งกัน

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

คอนโซล:

คอนโซลคืออุปกรณ์ทางกายภาพ ที่ให้คุณโต้ตอบกับคอมพิวเตอร์ได้

ในภาษาอังกฤษธรรมดา มันคือหน้าจอคอมพิวเตอร์ คีย์บอร์ด และเมาส์ของคุณ ในฐานะผู้ใช้ คุณโต้ตอบกับคอมพิวเตอร์ของคุณผ่าน คอนโซลของคุณ

เทอร์มินัล:

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

เป็นภาษาอังกฤษธรรมดาอีกครั้ง มันคือ "หน้าต่าง" ที่คุณป้อนคำสั่งจริงที่คอมพิวเตอร์ของคุณจะประมวลผล

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

ระบบปฏิบัติการทั้งหมดมาพร้อมกับเทอร์มินัลเริ่มต้นที่ติดตั้งไว้ แต่มีตัวเลือกมากมายให้เลือก ซึ่งแต่ละระบบมีฟังก์ชันและคุณสมบัติเฉพาะตัว

เชลล์:

เชลล์เป็นโปรแกรม ที่ทำหน้าที่เป็นล่ามบรรทัดคำสั่ง ประมวลผลคำสั่ง และ แสดงผล . มันตีความและประมวลผลคำสั่งที่ป้อนโดยผู้ใช้

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

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

ในระบบปฏิบัติการ Linux และ Mac ส่วนใหญ่ เชลล์เริ่มต้นคือ Bash ในขณะที่ใช้ Windows มันคือ Powershell ตัวอย่างอื่นๆ ของเปลือกหอย ได้แก่ Zsh และ Fish

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

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

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

บรรทัดคำสั่งหรือ CLI (อินเทอร์เฟซบรรทัดคำสั่ง):

CLI คืออินเทอร์เฟซที่เราป้อนคำสั่งให้คอมพิวเตอร์ประมวลผล ในภาษาอังกฤษธรรมดาอีกครั้ง เป็นพื้นที่ที่คุณป้อนคำสั่งที่คอมพิวเตอร์จะดำเนินการ

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

สิ่งที่น่าสนใจที่จะกล่าวถึงในที่นี้คือระบบปฏิบัติการส่วนใหญ่มีอินเทอร์เฟซสองประเภท:

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

เหตุใดฉันจึงควรสนใจเกี่ยวกับการใช้เทอร์มินัลด้วย

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

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

ในแง่นี้ ความสบายใจกับบรรทัดคำสั่งจะช่วยให้คุณประหยัดเวลาและทำงานได้เร็วขึ้น

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

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

การเขียนสคริปต์เป็นวิธีที่ยอดเยี่ยมในการประหยัดเวลาในการทำงานซ้ำๆ

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

ดังนั้น ความสบายใจกับ CLI จะทำให้คุณโต้ตอบกับคอมพิวเตอร์ได้ในทุกโอกาส

เหตุผลสุดท้ายคือมันดูเท่และสนุก คุณไม่เห็นแฮกเกอร์ภาพยนตร์คลิกที่คอมพิวเตอร์ของพวกเขาใช่ไหม;)

เปลือกหอยชนิดต่างๆ

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

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

เกร็ดประวัติศาสตร์ – Posix

สำหรับเชลล์ มีมาตรฐานทั่วไปที่เรียกว่า Posix .

Posix ทำงานกับเชลล์ในลักษณะที่คล้ายคลึงกันมากกับ ECMAScript ที่ทำงานกับ JavaScript เป็นมาตรฐานที่กำหนดคุณลักษณะและคุณลักษณะบางอย่างที่กระสุนทั้งหมดควรปฏิบัติตาม

มาตรฐานนี้มีความเสถียรในปี 1980 และกระสุนปัจจุบันส่วนใหญ่ได้รับการพัฒนาตามมาตรฐานนั้น นั่นเป็นสาเหตุที่เชลล์ส่วนใหญ่ใช้รูปแบบเดียวกันและคุณลักษณะที่คล้ายกัน

ฉันจะทราบได้อย่างไรว่าฉันกำลังเรียกใช้เชลล์ใดอยู่

หากต้องการทราบว่าคุณกำลังเรียกใช้เชลล์ใดอยู่ เพียงเปิดเทอร์มินัลแล้วป้อน echo $0 . การดำเนินการนี้จะพิมพ์ชื่อโปรแกรมที่กำลังรันอยู่ ซึ่งในกรณีนี้คือเชลล์จริง

เชลล์ไหนดีกว่ากัน

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

มีความแตกต่างเล็กน้อยที่คุณอาจต้องการทราบ:

• ดังที่กล่าวมา ทุบตี เป็นโปรแกรมที่ใช้กันอย่างแพร่หลายที่สุดและติดตั้งโดยค่าเริ่มต้นบน Mac และ Linux
• Zsh คล้ายกับ Bash มาก แต่มันถูกสร้างขึ้นหลังจากนั้นและมาพร้อมกับการปรับปรุงที่ดีบางอย่าง หากคุณต้องการทราบรายละเอียดเพิ่มเติมเกี่ยวกับความแตกต่าง โปรดอ่านบทความดีๆ เกี่ยวกับเรื่องนี้
• ปลา เป็นอีกหนึ่งเชลล์ที่ใช้กันทั่วไปซึ่งมาพร้อมกับคุณสมบัติและการกำหนดค่าในตัวที่ดี เช่น การเติมข้อความอัตโนมัติและการเน้นไวยากรณ์ สิ่งที่เกี่ยวกับ Fish คือไม่ใช่การร้องเรียนของ Posix ในขณะที่ Bash และ Zsh เป็น ซึ่งหมายความว่าคำสั่งบางคำสั่งที่คุณจะสามารถเรียกใช้บน Bash และ Zsh จะไม่ทำงานบน Fish และในทางกลับกัน ซึ่งทำให้การเขียนสคริปต์ Fish เข้ากันได้กับคอมพิวเตอร์ส่วนใหญ่น้อยลงเมื่อเทียบกับ Bash และ Zsh
• ยังมีเปลือกหอยอื่นๆ เช่น ขี้เถ้า หรือ แดช (การตั้งชื่อทำให้ทุกอย่างสับสนมากขึ้น ฉันรู้...) ที่เป็นรุ่นย่อยของ Posix shells ซึ่งหมายความว่าพวกเขาเสนอคุณสมบัติที่จำเป็นใน Posix เท่านั้น และไม่มีอย่างอื่น ในขณะที่ Bash และ Zsh เพิ่มคุณสมบัติเพิ่มเติม มากกว่าที่ Posix ต้องการ

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

ดังนั้น แนวทางปฏิบัติทั่วไปคือการใช้เชลล์ที่ "ปรับปรุง" เช่น Bash หรือ Zsh สำหรับการโต้ตอบทั่วไป และเชลล์ "ปล้น" เช่น Ash หรือ Dash เพื่อรันสคริปต์

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

หากคุณสนใจการเปรียบเทียบโดยละเอียดระหว่างเชลล์เหล่านี้ นี่คือวิดีโอที่อธิบายได้ดีมาก:

หากต้องแนะนำเชลล์ ฉันขอแนะนำ bash เนื่องจากเป็นเชลล์มาตรฐานและใช้กันทั่วไปมากที่สุด ซึ่งหมายความว่าคุณจะสามารถแปลความรู้ของคุณไปสู่สภาพแวดล้อมส่วนใหญ่ได้

แต่อีกครั้ง ความจริงก็คือ มีความแตกต่างไม่มากนักระหว่างกระสุนส่วนใหญ่ ดังนั้นไม่ว่าในกรณีใด คุณสามารถลองสองสามอย่างและดูว่าอันไหนที่คุณชอบที่สุด;)

ความคิดเห็นเกี่ยวกับการปรับแต่ง

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

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

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

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

ตัวเลือกการปรับแต่งเหล่านี้ใช้ได้กับเทอร์มินัลเช่นกัน

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

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

คำสั่งที่ใช้บ่อยและมีประโยชน์มากที่สุด

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

โปรดทราบว่าตัวอย่างเหล่านี้จะอิงตามการกำหนดค่าปัจจุบันของฉัน (Bash บน Linux OS) แต่คำสั่งส่วนใหญ่ควรใช้กับการกำหนดค่าส่วนใหญ่อยู่ดี

• เสียงก้อง พิมพ์ในเทอร์มินัลไม่ว่าพารามิเตอร์ใดก็ตามที่เราส่งผ่าน

echo Hello freeCodeCamp! // Output: Hello freeCodeCamp!

• pwd ย่อมาจากไดเร็กทอรีการพิมพ์และพิมพ์ "สถานที่" หรือไดเร็กทอรีที่เราอยู่ในคอมพิวเตอร์

pwd // Output: /home/German

• ล แสดงเนื้อหาของไดเร็กทอรีที่คุณอยู่ในปัจจุบัน โดยจะแสดงทั้งไฟล์และไดเร็กทอรีอื่นๆ ที่ไดเร็กทอรีปัจจุบันของคุณมีอยู่

ตัวอย่างเช่น ฉันอยู่ในไดเร็กทอรีโครงการ React ที่ฉันเพิ่งใช้งานเมื่อเร็วๆ นี้:

ls // Output:
node_modules  package.json  package-lock.json  public  README.md  src

หากคุณส่งคำสั่งนี้แฟล็กหรือ paremter -a นอกจากนี้ยังจะแสดงไฟล์หรือไดเรกทอรีที่ซ่อนอยู่ ชอบ .git หรือ .gitignore ไฟล์

ls -a // Output:
.   .env  .gitignore    package.json       public     src
..  .git  node_modules  package-lock.json  README.md

• ซีดี ย่อมาจาก Change directory และจะนำคุณจากไดเร็กทอรีปัจจุบันไปยังไดเร็กทอรีอื่น

ขณะที่อยู่ในโฮมไดเร็กตอรี่ของฉัน ฉันสามารถป้อน cd Desktop และจะพาฉันไปที่ Desktop Directory

ถ้าฉันต้องการขึ้นหนึ่งไดเร็กทอรี หมายถึง ไปที่ไดเร็กทอรีที่มีไดเร็กทอรีปัจจุบัน ฉันสามารถป้อน cd ..

หากคุณป้อน cd เพียงอย่างเดียวก็จะพาคุณตรงไปยังโฮมไดเร็กตอรี่ของคุณ

• mkdir ย่อมาจาก make directory และจะสร้างไดเร็กทอรีใหม่ให้กับคุณ คุณต้องส่งคำสั่งพารามิเตอร์ชื่อไดเร็กทอรี

ถ้าฉันต้องการสร้างไดเร็กทอรีใหม่ชื่อ "Test" ฉันจะเข้าสู่ mkdir test .

• rmdir ย่อมาจาก Remove directory และมันทำอย่างนั้น มันต้องการพารามิเตอร์ชื่อไดเร็กทอรีเช่นเดียวกับ mkdir :rmdir test .

• สัมผัส ให้คุณสร้างไฟล์เปล่าในไดเร็กทอรีปัจจุบันของคุณ พารามิเตอร์จะใช้ชื่อไฟล์ เช่น touch test.txt .

• rm ให้คุณลบไฟล์ได้เช่นเดียวกัน rmdir อนุญาตให้คุณลบไดเร็กทอรี
  rm test.txt

• cp อนุญาตให้คุณคัดลอกไฟล์หรือไดเร็กทอรี คำสั่งนี้ใช้พารามิเตอร์สองตัว:อันแรกคือไฟล์หรือไดเร็กทอรีที่คุณต้องการคัดลอก และอันที่สองคือปลายทางของสำเนาของคุณ (คุณต้องการคัดลอกไฟล์/ไดเร็กทอรีของคุณไปที่ใด)

หากฉันต้องการทำสำเนาไฟล์ txt ของฉันในไดเร็กทอรีเดียวกัน ฉันสามารถป้อนข้อมูลต่อไปนี้:

cp test.txt testCopy.txt

เห็นว่าไดเร็กทอรีไม่เปลี่ยนแปลง ส่วน "ปลายทาง" ฉันป้อนชื่อไฟล์ใหม่

หากฉันต้องการคัดลอกไฟล์ไปยังไดเร็กทอรีอื่น แต่เก็บชื่อไฟล์เดิมไว้ ฉันสามารถป้อนสิ่งนี้:

cp test.txt ./testFolder/

และถ้าฉันต้องการคัดลอกไปยังโฟลเดอร์อื่นเพื่อเปลี่ยนชื่อฟิลด์ แน่นอน ฉันสามารถป้อนสิ่งนี้:

cp test.txt ./testFolder/testCopy.txt

• mv ย่อมาจากการย้าย และให้เราย้ายไฟล์หรือไดเรกทอรีจากที่หนึ่งไปยังอีกที่หนึ่ง นั่นคือ สร้างมันในไดเร็กทอรีใหม่และลบมันในไดเร็กทอรีก่อนหน้า (เหมือนกับที่คุณสามารถทำได้โดยการตัดและวาง)

อีกครั้ง คำสั่งนี้ใช้ paremers สองตัว ไฟล์หรือไดเร็กทอรีที่เราต้องการย้ายและปลายทาง

mv test.txt ./testFolder/

เราสามารถเปลี่ยนชื่อไฟล์ได้ด้วยคำสั่งเดียวกันหากต้องการ:

mv test.txt ./testFolder/testCopy.txt

• หัว ให้คุณดูจุดเริ่มต้นของไฟล์หรือข้อมูลที่ไปป์ได้โดยตรงจากเทอร์มินัล

head test.txt // Output:
this is the beginning of my test file

• หาง ใช้งานได้เหมือนกันแต่จะแสดงจุดสิ้นสุดของไฟล์ให้คุณเห็น

tail test.txt // Output:

this is the end of my test file

• --ช่วยเหลือ แฟล็กสามารถใช้ได้กับคำสั่งส่วนใหญ่ และจะส่งคืนข้อมูลเกี่ยวกับวิธีการใช้คำสั่งที่กำหนด

cd --help // output:
cd: cd [-L|[-P [-e]] [-@]] [dir]
Change the shell working directory.

เปลี่ยนไดเร็กทอรีปัจจุบันเป็น DIR DIR เริ่มต้นคือค่าของตัวแปรเชลล์ HOME

ตัวแปร CDPATH กำหนดเส้นทางการค้นหาสำหรับไดเร็กทอรีที่มี DIR ชื่อไดเรกทอรีทางเลือกใน CDPATH คั่นด้วยเครื่องหมายทวิภาค : .

ชื่อไดเร็กทอรี null จะเหมือนกับไดเร็กทอรีปัจจุบันหาก DIR เริ่มต้นด้วย ... .

• ในทำนองเดียวกัน ผู้ชาย คำสั่งจะส่งคืนข้อมูลเกี่ยวกับคำสั่งเฉพาะใดๆ

    man cp // output:

    CP(1)                            User Commands                           CP(1)

    NAME
           cp - copy files and directories

    SYNOPSIS
           cp [OPTION]... [-T] SOURCE DEST
           cp [OPTION]... SOURCE... DIRECTORY
           cp [OPTION]... -t DIRECTORY SOURCE...

    DESCRIPTION
           Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.

           Mandatory  arguments  to  long  options are mandatory for short options
           too.

           -a, --archive
                  same as -dR --preserve=all

           --attributes-only
                  don't copy the file data, just the attributes
    ...

คุณยังสามารถป้อน man bash และนั่นจะส่งคืนคู่มือเล่มใหญ่เกี่ยวกับทุกสิ่งที่ควรรู้เกี่ยวกับเชลล์นี้;)

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

คุณยังสามารถเปิดไฟล์ที่กำหนดโดยส่งเป็นพารามิเตอร์:code test.txt .

หรือเปิดไฟล์ใหม่โดยส่งชื่อไฟล์ใหม่:code thisIsAJsFile.js .

• แก้ไข จะเปิดไฟล์ข้อความในโปรแกรมแก้ไขข้อความบรรทัดคำสั่งเริ่มต้นของคุณ (ซึ่งหากคุณใช้ Mac หรือ Linux อาจเป็น Nano หรือ Vim)

หากคุณเปิดไฟล์แล้วออกจากโปรแกรมแก้ไขไม่ได้ ให้ดูมีมนี้ก่อน:

![vimExit](https://www.freecodecamp.org/news/content/images/2022/03/vimExit.png)

แล้วพิมพ์ :q! แล้วกด Enter

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

• ctrl+c ให้คุณออกจากกระบวนการปัจจุบันที่เทอร์มินัลกำลังทำงานอยู่ ตัวอย่างเช่น หากคุณกำลังสร้างแอปตอบโต้ด้วย npx create-react-app และต้องการยกเลิกบิลด์ในบางจุด เพียงกด ctrl+c แล้วก็จะหยุด

• การคัดลอกข้อความจากเทอร์มินัลสามารถทำได้ด้วย ctrl+shift+c และการวางสามารถทำได้ด้วย ctrl+shift+v

• ชัดเจน จะล้างเทอร์มินัลของคุณจากเนื้อหาก่อนหน้าทั้งหมด

• ทางออก จะปิดเทอร์มินัลของคุณและ (นี่ไม่ใช่คำสั่ง แต่ก็เจ๋งเหมือนกัน) ctrl+alt+t จะเปิดเทอร์มินัลใหม่ให้คุณ

• โดยกดปุ่มขึ้นและลง คุณสามารถเลื่อนดูคำสั่งก่อนหน้าที่คุณป้อนได้

• โดยกด แท็บ คุณจะได้รับการเติมข้อความอัตโนมัติตามข้อความที่คุณเขียนจนถึงตอนนี้ โดยกด แท็บสองครั้ง คุณจะได้รับคำแนะนำตามข้อความที่คุณเขียนจนถึงตอนนี้

เช่น ถ้าฉันเขียน edit test และ แท็บสองครั้ง ฉันได้รับ testFolder/ test.txt . ถ้าฉันเขียน edit test. และกด แท็บ ข้อความของฉันเติมข้อความอัตโนมัติเพื่อ edit test.txt

คำสั่ง Git

นอกจากการทำงานกับระบบไฟล์และการติดตั้ง/ถอนการติดตั้งสิ่งต่าง ๆ การโต้ตอบกับ Git และ repos ออนไลน์อาจเป็นสิ่งที่พบบ่อยที่สุดที่คุณจะใช้เทอร์มินัลในฐานะนักพัฒนา

การดำเนินการจากเทอร์มินัลมีประสิทธิภาพมากกว่าการคลิกรอบ ๆ ดังนั้นเรามาดูคำสั่ง git ที่มีประโยชน์ที่สุดกันดีกว่า

• git init จะสร้างที่เก็บในเครื่องใหม่ให้กับคุณ

git init // output:
Initialized empty Git repository in /home/German/Desktop/testFolder/.git/

• เพิ่มคอมไพล์ เพิ่มไฟล์อย่างน้อยหนึ่งไฟล์ในการจัดเตรียม คุณสามารถให้รายละเอียดไฟล์เฉพาะเพื่อเพิ่มในการแสดงละครหรือเพิ่มไฟล์ที่เปลี่ยนแปลงทั้งหมดโดยพิมพ์ git add .

• คอมมิทคอม ยอมรับการเปลี่ยนแปลงของคุณกับที่เก็บ ภาระผูกพันจะต้องมาพร้อมกับ -m . เสมอ ตั้งค่าสถานะและยืนยันข้อความ

git commit -m 'This is a test commit' // output:
[master (root-commit) 6101dfe] This is a test commit
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.js

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

git status  // output:
On branch master
nothing to commit, working tree clean

• โคลน git ให้คุณโคลน (คัดลอก) ที่เก็บลงในไดเร็กทอรีที่คุณอยู่ได้ โปรดทราบว่าคุณสามารถโคลนทั้งที่เก็บระยะไกล (ใน GitHub, GitLab และอื่นๆ) และที่เก็บในเครื่อง (ที่เก็บอยู่ในคอมพิวเตอร์ของคุณ)

git clone https://github.com/coccagerman/MazeGenerator.git // output:
Cloning into 'MazeGenerator'...
remote: Enumerating objects: 15, done.
remote: Counting objects: 100% (15/15), done.
remote: Compressing objects: 100% (15/15), done.
remote: Total 15 (delta 1), reused 11 (delta 0), pack-reused 0
Unpacking objects: 100% (15/15), done.

• git รีโมทเพิ่มต้นทาง ใช้เพื่อดูรายละเอียด URL ของที่เก็บระยะไกลที่คุณจะใช้สำหรับโครงการของคุณ ในกรณีที่ต้องการเปลี่ยนแปลงในบางจุด คุณสามารถทำได้โดยใช้คำสั่ง git remote set-url origin .

git remote add origin https://github.com/coccagerman/testRepo.git

โปรดทราบว่าคุณต้องสร้าง repo ระยะไกลก่อนจึงจะได้รับ URL เราจะมาดูกันว่าคุณจะทำสิ่งนี้ได้อย่างไรจากบรรทัดคำสั่งพร้อมสคริปต์เล็กน้อยในภายหลัง;)

• git remote -v ให้คุณแสดงรายการที่เก็บระยะไกลปัจจุบันที่คุณใช้อยู่

git remote -v // output:
origin	https://github.com/coccagerman/testRepo.git (fetch)
origin	https://github.com/coccagerman/testRepo.git (push)

• กดกิต อัปโหลดการเปลี่ยนแปลงที่คุณผูกมัดไปยัง repo ระยะไกลของคุณ

git push // output:
Counting objects: 2, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (2/2), 266 bytes | 266.00 KiB/s, done.
Total 2 (delta 0), reused 0 (delta 0)

• สาขา git แสดงรายการสาขาทั้งหมดที่มีอยู่ใน repo ของคุณและบอกคุณว่าคุณกำลังอยู่ในสาขาใด หากคุณต้องการสร้างสาขาใหม่ คุณเพียงแค่เพิ่มชื่อสาขาใหม่เป็นพารามิเตอร์ เช่น git branch <branch name> .

git branch // output:
* main

• git ชำระเงิน ย้ายคุณจากสาขาหนึ่งไปอีกสาขาหนึ่ง มันใช้สาขาปลายทางของคุณเป็น paremeter

git checkout newBranch // output:
Switched to branch 'newBranch'

• git pull ดึง (ดาวน์โหลด) โค้ดจากที่เก็บระยะไกลของคุณและรวมเข้ากับ repo ในเครื่องของคุณ สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อทำงานเป็นทีม เมื่อนักพัฒนาหลายคนทำงานบนฐานรหัสเดียวกัน ในกรณีนี้ นักพัฒนาแต่ละรายจะดึงจาก repo ระยะไกลเป็นระยะๆ เพื่อทำงานในฐานโค้ดที่รวมการเปลี่ยนแปลงที่ทำโดยผู้พัฒนาอื่นๆ ทั้งหมด

หากมีโค้ดใหม่ใน repo ระยะไกลของคุณ คำสั่งจะส่งคืนไฟล์จริงที่แก้ไขในการดึง ถ้าไม่เช่นนั้น เราจะได้ Already up to date .

git pull // output:
Already up to date.

• git diff ให้คุณดูความแตกต่างระหว่างสาขาที่คุณอยู่และสาขาอื่นได้

git diff newBranch // output:
diff --git a/newFileInNewBranch.js b/newFileInNewBranch.js
deleted file mode 100644
index e69de29..0000000

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

• การรวมคอมไพล์ ผสาน (รวม) สาขาที่คุณอยู่ด้วยสาขาอื่น โปรดทราบว่าการเปลี่ยนแปลงจะรวมอยู่ในสาขาที่คุณอยู่เท่านั้น ไม่รวมกับสาขาอื่น

git merge newBranch // output:
Updating f15cf51..3a3d62f
Fast-forward
 newFileInNewBranch.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 newFileInNewBranch.js

• บันทึก git แสดงรายการคอมมิตก่อนหน้าทั้งหมดที่คุณทำใน repo

git log // output:
commit 3a3d62fe7cea7c09403c048e971a5172459d0948 (HEAD -> main, tag: TestTag, origin/main, newBranch)
Author: German Cocca <german.cocca@avature.net>
Date:   Fri Apr 1 18:48:20 2022 -0300

    Added new file

commit f15cf515dd3ec398210108dce092debf26ff9e12
Author: German Cocca <german.cocca@avature.net>
    ...

• --ช่วยเหลือ แฟล็กจะแสดงข้อมูลเกี่ยวกับคำสั่งที่กำหนด แบบเดียวกับที่ใช้กับ bash

git diff --help // output:
GIT-DIFF(1)                       Git Manual                       GIT-DIFF(1)

NAME
       git-diff - Show changes between commits, commit and working tree, etc

SYNOPSIS
       git diff [options] [<commit>] [--] [<path>...]
       git diff [options] --cached [<commit>] [--] [<path>...]
       ...

สคริปต์แรกของเรา

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

ดังที่ฉันได้กล่าวไว้ก่อนหน้านี้ สคริปต์ไม่มีอะไรมากไปกว่าชุดคำสั่งหรือคำสั่งที่เราสามารถดำเนินการได้ตลอดเวลา เพื่ออธิบายว่าเราจะเขียนโค้ดได้อย่างไร เราจะใช้ตัวอย่างง่ายๆ ที่จะช่วยให้เราสร้าง GitHub repo ได้โดยใช้คำสั่งเดียว;)

• สิ่งแรกที่ต้องทำคือสร้าง .sh ไฟล์. คุณสามารถวางได้ทุกที่ที่ต้องการ ฉันโทรหาฉัน newGhRepo.sh .

• จากนั้นเปิดในโปรแกรมแก้ไขข้อความ/โค้ดที่คุณเลือก

• ในบรรทัดแรก เราจะเขียนดังนี้:#! /bin/sh

สิ่งนี้เรียกว่า ชีบัง และหน้าที่ของมันคือการประกาศเชลล์ที่จะเรียกใช้สคริปต์นี้

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

ดังที่กล่าวไว้เช่นกัน เรากำลังใช้เชลล์ "ปล้น" (หรือเรียกอีกอย่างว่า sh เชลล์) เพื่อเรียกใช้สคริปต์เนื่องจากมีประสิทธิภาพมากกว่า (แม้ว่าตามจริงแล้วความแตกต่างอาจมองไม่เห็น แต่เป็นเพียงความชอบส่วนตัว) ในคอมพิวเตอร์ของฉัน ฉันมี dash เป็น sh shell

หากเราต้องการให้สคริปต์นี้ทำงานด้วย bash shebang จะเป็น #! /bin/bash

• บรรทัดถัดไปของเราคือ repoName=$1

เรากำลังประกาศ ตัวแปร เรียกว่า repoName และกำหนดค่าให้กับพารามิเตอร์แรกที่สคริปต์ได้รับ

พารามิเตอร์ คือชุดของอักขระที่ป้อนหลังสคริปต์/คำสั่ง เช่นเดียวกับ cd คำสั่ง เราต้องระบุพารามิเตอร์ไดเร็กทอรีเพื่อเปลี่ยนไดเร็กทอรี (เช่น:cd testFolder )

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

หากฉันคาดหวังมากกว่าหนึ่งพารามิเตอร์ ฉันสามารถเขียน:

paramOne=$1
paramTwo=$2
paramThree=$3
...

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

เราสามารถทำได้ดังนี้:

while [ -z "$repoName" ]
do
   echo 'Provide a repository name'
   read -r -p $'Repository name:' repoName
done

สิ่งที่เรากำลังทำอยู่คือ:

1. ในขณะที่ไม่ได้กำหนดตัวแปร repoName (while [ -z "$repoName" ] )
2. เขียนข้อความนี้ไปที่คอนโซล (echo 'Provide a repository name' )
3. จากนั้นอ่านอินพุตที่ผู้ใช้ระบุและกำหนดอินพุตให้กับตัวแปร repoName (read -r -p $'Repository name:' repoName )

• ตอนนี้เรามีชื่อ repo แล้ว เราสามารถสร้าง Git repo ในพื้นที่ได้ดังนี้:

echo "# $repoName" >> README.md
git init
git add .
git commit -m "First commit"

นี่คือการสร้างไฟล์ readme และเขียนบรรทัดเดียวด้วยชื่อ repo (echo "# $repoName" >> README.md ) จากนั้นเริ่มต้น git repo และทำการคอมมิตครั้งแรก

• ถึงเวลาอัปโหลด repo ของเราไปที่ github ในการทำเช่นนั้น เราจะใช้ประโยชน์จาก github API ในคำสั่งต่อไปนี้:

curl -u coccagerman https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}'

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

ต่อไปเราจะใช้ -u ตั้งค่าสถานะเพื่อประกาศผู้ใช้ที่เรากำลังสร้าง repo สำหรับ (-u coccagerman )

ถัดไปคือจุดปลายที่ GitHub API (https://api.github.com/user/repos ให้บริการ )

และสุดท้ายเราใช้ -d แฟล็กเพื่อส่งพารามิเตอร์ไปยังคำสั่งนี้ ในกรณีนี้ เรากำลังระบุชื่อที่เก็บ (ซึ่งเราใช้ repoName ของเรา ตัวแปร) และการตั้งค่า private ตัวเลือก false เนื่องจากเราต้องการให้ repo ของเราเป็นแบบสาธารณะ

API มีตัวเลือกการกำหนดค่าอื่นๆ มากมาย ดังนั้นโปรดตรวจสอบเอกสารเพื่อดูข้อมูลเพิ่มเติม

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

หากคุณยังไม่มีโทเค็นส่วนตัว คุณสามารถสร้างได้ใน GitHub ใน การตั้งค่า> การตั้งค่านักพัฒนา> โทเค็นการเข้าถึงส่วนบุคคล

• เจ๋ง เราใกล้เสร็จแล้ว! สิ่งที่เราต้องการตอนนี้คือ URL ระยะไกล ของ repo GitHub ที่สร้างขึ้นใหม่ของเรา

เราจะใช้ curl และ GitHub API อีกครั้งดังนี้:

GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/coccagerman/"$repoName" | jq -r '.clone_url')

Here we're declaring a variable called GIT_URL and assigning it to whatever the following command returns.

The -H flag sets the header of our request.

Then we pass the GitHub API endpoint, which should contain our user name and repo name (https://api.github.com/repos/coccagerman/"$repoName" ).

Then we're piping the return value of our request. Piping just means passing the return value of a process as the input value of another process. We can do it with the | symbol like <process1> | <process2> .

And finally we run the jq command, which is a tool for processing JSON inputs. Here we tell it to get the value of .clone_url which is where our remote git URL will be according to the data format provided by the GitHub API.

• And as last step, we rename our master branch to main, add the remote origin we just obtained, and push our code to GitHub! =D

git branch -M main
git remote add origin $GIT_URL
git push -u origin main

Our full script should look something like this:

#! /bin/sh
repoName=$1

while [ -z "$repoName" ]
do
    echo 'Provide a repository name'
    read -r -p $'Repository name:' repoName
done

echo "# $repoName" >> README.md
git init
git add .
git commit -m "First commit"

curl -u <yourUserName> https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}'

GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/<yourUserName>/"$repoName" | jq -r '.clone_url')

git branch -M main
git remote add origin $GIT_URL
git push -u origin main

• Now it's time to test our script! To execute it there're two things we can do.

One option is to enter the shell name and pass the file as parameter, like:dash ../ger/code/projects/scripts/newGhRepo.sh .

And the other is to make the file executable by running chmod u+x ../ger/code/projects/scripts/newGhRepo.sh .

Then you can just execute the file directly by running ../ger/code/projects/scripts/newGhRepo.sh .

And that's it! We have our script up and running. Everytime we need a new repo we can just execute this script from whatever directory we're in.

But there's something a bit annoying about this. We need to remember the exact route of the script directory. Wouldn't it be cool to execute the script with a single command that it's always the same independently of what directory we're at?

In come bash aliases to solve our problem.

Aliases are a way bash provides for making names for exact commands we want to run.

To create a new alias, we need to edit the bash configuration files in our system. This files are normally located in the home directory. Aliases can be defined in different files (mainly .bashrc or .bash_aliases ).

I have a .bash_aliases file on my system, so let's edit that.

• In our CLI we enter cd to go over home directory.

• Then we can enter ls -a to list all files (includen hidden ones) and check if we have either a .bashrc or .bash_aliases file in our system.

• We open the file with our text/code editor of choice.

• And we write our new alias like this:
  alias newghrepo="dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh"

Here I'm declaring the alias name, the actual command I'm going to enter to run the script (newghrepo ).

And between quotes, define what that alias is going to do ("dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh" )

See that I'm passing the absolute path of the script, so that this command works the same no matter what my current directory is.

If you don't know what the absolute path of your script is, go to the script directory on your terminal and enter readlink -f newGhRepo.sh . That should return the full path for you.;)

• After we're done editing, we save our file, restart our terminal, and voilà! Now we can run our script by just entering newghrepo , no matter in what directory we currently are. Much quicker than opening the browser and clicking around to create our repo! =D

I hope this gives you a little taste of the kind of optimizations that are possible with scripting. It certainly requires a bit more work the first time you write, test, and set up the script. But after that, you'll never have to perform that task manually again.;)

Round up

The terminal can feel like an intimidating and intricate place when you're starting out. But it's certainly worth it to put time and effort into learning the ins and outs of it. The efficiency benefits are too good to pass up!

If you're interested in learning more about the terminal and Bash, Zach Gollwitzer has an awesome crash course series on youtube.
He has also great tutorials on other topics such as Node and Javascript, so I recommend that you follow him.;)

As always, I hope you enjoyed the article and learned something new. If you want, you can also follow me on linkedin or twitter.

Cheers and see you in the next one! =D