คุณกำลังพิจารณาสร้างอินเทอร์เฟซบรรทัดคำสั่งหรือไม่? นั่นเป็นแนวคิดโครงการที่ยอดเยี่ยม! ในคู่มือนี้ เราจะพูดถึงวิธีสร้างอินเทอร์เฟซบรรทัดคำสั่งใน Ruby
ก่อนที่เราจะเริ่ม คุณควรติดตั้ง Ruby บนคอมพิวเตอร์ของคุณ และคุณควรใช้เทอร์มินัลที่ให้คุณเรียกใช้คำสั่ง Unix ได้ หากคุณใช้คอมพิวเตอร์ที่ใช้ Linux หรือ macOS คุณจะมีเทอร์มินัลที่รองรับ Unix ในตัวอยู่แล้ว เมื่อคุณปฏิบัติตามข้อกำหนดเหล่านี้แล้ว คุณก็พร้อมที่จะเริ่มต้น!
อินเทอร์เฟซบรรทัดคำสั่งคืออะไร
เมื่อคุณเริ่มต้นอาชีพการเขียนโค้ด คุณจะได้เรียนรู้เกี่ยวกับ Terminal ในไม่ช้า หน้าต่างเทอร์มินัลช่วยให้คุณสามารถโต้ตอบกับอินเทอร์เฟซบรรทัดคำสั่ง (CLI) ซึ่งคุณสามารถใช้เพื่อเรียกใช้และโต้ตอบกับโปรแกรมโดยใช้คำสั่งข้อความ
เมื่อใช้หน้าต่างเทอร์มินัล คุณสามารถให้คำแนะนำกับคอมพิวเตอร์ของคุณได้โดยไม่ต้องใช้เมาส์หรือแอปพลิเคชันภาพ สิ่งนี้จะช่วยคุณประหยัดเวลาในการเขียนโค้ดเพราะคุณสามารถมุ่งเน้นไปที่การเขียนคำสั่งเท่านั้น คุณไม่จำเป็นต้องกังวลเกี่ยวกับการเรียนรู้อินเทอร์เฟซผู้ใช้ใหม่สำหรับแต่ละเครื่องมือที่คุณใช้!
CLI ที่คุณโต้ตอบด้วยอาจได้รับการพัฒนาโดยบุคคลอื่น ตัวอย่างเช่น Python CLI อนุญาตให้คุณเรียกใช้ Python จากเทอร์มินัล ในขณะที่ Ruby CLI ให้คุณทำเช่นเดียวกันกับแอปพลิเคชัน Ruby โชคดีที่คุณสามารถสร้างของคุณเองได้เช่นกัน!
ในการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลบนเครื่องของคุณ จากนั้นใช้ mkdir คำสั่งเพื่อสร้างโฟลเดอร์สำหรับโค้ดของคุณ นี่คือตัวอย่างของคำสั่งนี้ที่ใช้งานจริง:
คำสั่งนี้จะสร้างโฟลเดอร์ชื่อ "ruby-cli" บนคอมพิวเตอร์ของเรา ตอนนี้เราสามารถใช้ cd แล้ว เพื่อเข้าไปในโฟลเดอร์นี้และสร้าง CLI ของเรา:
เยี่ยมมาก! ตอนนี้เราอยู่ในโฟลเดอร์ "ruby-cli" ใหม่ของเรา นั่นคือการตั้งค่าทั้งหมดที่เราต้องทำสำหรับบทความนี้ ขั้นตอนต่อไปคือการเริ่มเขียนอินเทอร์เฟซบรรทัดคำสั่งของเรา
คุณลักษณะแรกที่เราจะเพิ่มลงในอินเทอร์เฟซบรรทัดคำสั่งของเราคือการพิมพ์คำว่า "นี่คือ CLI ตัวอย่าง" ไปยังเทอร์มินัลของเรา เราสามารถทำได้โดยสร้างไฟล์ใหม่ชื่อ “home.rb” แล้วใส่โค้ดลงในไฟล์
หากต้องการสร้างไฟล์ใหม่ เราสามารถใช้คำสั่งต่อไปนี้:
นี่จะเป็นการเปิด nano โปรแกรมแก้ไขข้อความที่เราสามารถใส่โค้ดสำหรับโปรแกรมของเราได้ คุณสามารถใช้โปรแกรมแก้ไขข้อความอื่น เช่น vim หรือ emacs ได้หากต้องการ
ในโปรแกรมแก้ไขข้อความนาโนของเรา เราวางโค้ดต่อไปนี้:
#!/usr/bin/env ruby puts "This is an example CLI"
ตอนนี้ มาบันทึกด้วยการกด Control-X บน Mac, Y แล้วกด Enter สิ่งนี้จะสร้างไฟล์ใหม่ชื่อ "home.rb" ในโฟลเดอร์ "ruby-cli" ของเรา
ในโค้ดของเรา บรรทัดแรกบอกให้คอมพิวเตอร์ใช้ Ruby libre เพื่อรันโค้ดของเรา สิ่งนี้ทำให้มั่นใจได้ว่าโค้ดของเราทำงานใน Ruby บรรทัดที่สองสั่งให้โปรแกรมของเราพิมพ์ "นี่คือตัวอย่าง CLI" ไปยังคอนโซล
ตอนนี้เราสามารถเรียกใช้ไฟล์ของเราโดยใช้ ruby คำสั่ง:
รหัสของเราส่งคืน:
อย่างที่คุณเห็น เราเพิ่งสร้าง CLI แบบง่ายๆ เมื่อเราเรียกใช้ไฟล์ "home.rb" คำว่า "นี่คือ CLI ตัวอย่าง" จะถูกพิมพ์ลงบนคอนโซล
การยอมรับการป้อนข้อมูลของผู้ใช้โดยใช้แฟล็ก
จนถึงขณะนี้ CLI ของเราค่อนข้างเรียบง่าย โดยจะพิมพ์เฉพาะข้อความไปยังคอนโซลเท่านั้น จะทำอย่างไรถ้าคุณต้องการยอมรับการป้อนข้อมูลของผู้ใช้? เราสามารถทำได้โดยใช้ optparse ห้องสมุด ซึ่งช่วยให้เราสามารถแยกวิเคราะห์ตัวเลือกที่ให้มาจากบรรทัดคำสั่งซึ่งสามารถใช้ในโปรแกรมของเราได้
เรากำลังใช้ optparse ห้องสมุดด้วยเหตุผลบางประการ ขั้นแรก optparse ไลบรารีช่วยให้เราสามารถสร้างเมนูช่วยเหลือสำหรับแต่ละคำสั่งได้ ประการที่สอง optparse มีอยู่ใน Ruby อยู่แล้ว ดังนั้นคุณไม่จำเป็นต้องติดตั้งอะไรเลย
มาเพิ่มคุณสมบัติที่ยอมรับที่อยู่อีเมลของผู้ใช้เป็นอินพุตแล้วส่งกลับไปยังคอนโซล
เปิดไฟล์ “home.rb” ในโปรแกรมแก้ไขข้อความของคุณและแทนที่เนื้อหาด้วยโค้ดนี้:
#!/usr/bin/env ruby
require 'optparse'
options = {}
OptionParser.new do |op|
op.on("-e", "--email", "Your email address") do |value|
options[:name] = value
end
end.parse!
puts 'Your email address is: ' + options[:name]
ในโค้ดนี้ เราใช้ optparse ไลบรารีเพื่อแยกวิเคราะห์ข้อมูลที่ส่งผ่านคำสั่ง จากนั้นเราจะกำหนดค่าที่ผู้ใช้ระบุให้กับตัวแปร และพิมพ์ออกมาที่คอนโซล ในกรณีนี้ เราจะพิมพ์ “ที่อยู่อีเมลของคุณคือ:“ ตามด้วยอีเมลที่ผู้ใช้ระบุ
เราสามารถใช้คำสั่งนี้เพื่อลองใช้โค้ดของเรา:
ruby home.rb -e jack@jones.com
รหัสของเราส่งคืน:
Your email address is: jack@jones.com
สิ่งที่ยอดเยี่ยมเกี่ยวกับ optparse ไลบรารี่คือมันสร้างเมนูวิธีใช้โดยอัตโนมัติ เราสามารถดูเมนูวิธีใช้นี้ได้โดยใช้โค้ดต่อไปนี้:
รหัสของเราส่งคืน:
Usage: ruby [options] -e, --email Your email address
เมื่อคุณเรียกใช้คำสั่ง คุณสามารถใช้ -e ได้ หรือ --email ธง
"Career Karma เข้ามาในชีวิตของฉันในเวลาที่ฉันต้องการมันมากที่สุด และช่วยให้ฉันเข้ากับการฝึกปฏิบัติได้อย่างรวดเร็ว หลังจากเรียนจบได้สองเดือน ฉันพบงานในฝันที่สอดคล้องกับค่านิยมและเป้าหมายในชีวิตของฉัน!"
Venus วิศวกรซอฟต์แวร์ที่ Rockbot
ค้นหาการแข่งขัน Bootcamp ของคุณ
การยอมรับอินพุตของผู้ใช้ในโปรแกรมของคุณ
ในตัวอย่างก่อนหน้านี้ เรายอมรับอินพุตของผู้ใช้โดยใช้แฟล็ก อย่างไรก็ตาม แฟล็กอาจไม่สามารถใช้งานได้หากคุณต้องการยอมรับข้อมูลหลายส่วน
ข้อดีของการสร้าง CLI ใน Ruby ก็คือโปรแกรม Ruby ใดๆ ก็ตามสามารถกลายเป็น CLI ได้ ดังนั้นคุณไม่จำเป็นต้องเรียนรู้แบบแผนใหม่ๆ เพื่อเริ่มต้น
สมมติว่าเราต้องการสร้างแอปพลิเคชันที่ดึงชื่อผู้ใช้และอีเมล และตรวจสอบว่าพวกเขามีอายุเกิน 16 ปีหรือไม่
เริ่มต้นด้วยการรันคำสั่งต่อไปนี้เพื่อเข้าสู่ nano ของเรา โปรแกรมแก้ไขข้อความ:
ในไฟล์ที่คุณสร้างขึ้นใหม่ ให้วางโค้ดต่อไปนี้:
puts "What is your name?"
name = gets
puts "What is your age?"
age = gets
if age.to_i >= 16
puts "#{name}! You are 16 or older!"
else
puts "#{name}! You are not over the age of 16!"
end หลังจากบันทึกไฟล์แล้ว คุณสามารถเรียกใช้ CLI ใหม่ได้โดยใช้คำสั่งนี้:
รหัสของเราส่งคืน:
What is your name? James What is your age? 17 James! You are 16 or older!
หากเราแทรกค่า "14" เพื่อตอบคำถาม "คุณอายุเท่าไร" ผลลัพธ์ที่ได้จะส่งคืนดังนี้:
James! You are not over the age of 16.
คุณสามารถเขียนโค้ด Ruby ที่คุณต้องการลงใน CLI ของคุณได้ ขีดจำกัดเพียงอย่างเดียวคือจินตนาการของคุณ
บทสรุป
CLI ช่วยให้คุณสามารถโต้ตอบกับโปรแกรมโดยใช้เทอร์มินัล เป็นอีกทางเลือกหนึ่งนอกเหนือจากอินเทอร์เฟซผู้ใช้สำหรับโปรแกรม (เช่นสิ่งที่คุณเห็นเมื่อคุณเปิดโปรแกรมแก้ไขข้อความเช่น Atom หรือ Notepad)
ในคู่มือนี้ เราได้แสดงให้คุณเห็นถึงวิธีการสร้าง CLI อย่างง่ายโดยใช้ Ruby ตอนนี้คุณพร้อมที่จะเริ่มสร้าง CLI ของคุณเองเหมือนผู้เชี่ยวชาญ Ruby แล้ว!
