วิธีสร้างแอปพลิเคชัน CLI ใน Node.js

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

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

ทำความเข้าใจกับแอปพลิเคชัน CLI

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

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

 ls -l /home 

คำสั่งนี้รวมถึง:

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

ธงดังกล่าวข้างต้นซึ่งแสดงด้วย’-l’ทำหน้าที่เป็นทางเลือกแทนคำว่า"ยาว"ซึ่งดึงเอาความเฉพาะเจาะจงในผลลัพธ์ที่มากขึ้น

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

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

Commander.js คืออะไร?

Commander.js เป็นแพ็คเกจ npm ที่อำนวยความสะดวกในการพัฒนาแอปพลิเคชัน command line interface (CLI) โดยใช้ Node.js แพคเกจนี้มีชุดเครื่องมือและฟังก์ชันการทำงานที่ครอบคลุมซึ่งช่วยให้นักพัฒนาสามารถสร้างแอปพลิเคชัน CLI ที่แข็งแกร่งโดยใช้ความพยายามเพียงเล็กน้อย ด้วย Commander.js นักพัฒนาสามารถระบุคำสั่ง ตัวเลือก และลักษณะการทำงานที่จำเป็นสำหรับแอปพลิเคชัน CLI ของตนได้โดยไม่ต้องกังวลกับรายละเอียดการใช้งานพื้นฐาน

ด้วยการรวม Chalk.js เข้ากับแพ็คเกจนี้ เราจึงสามารถสร้างแอปพลิเคชันอินเทอร์เฟซบรรทัดคำสั่งที่ทำงานได้อย่างครอบคลุมภายในสภาพแวดล้อม Node.js ได้อย่างง่ายดาย

การสร้างแอปพลิเคชัน CLI ใน Node.js โดยใช้ Commander.js

ลองพิจารณาตัวอย่างแอป CLI นั่นคือ urbanary-cli ซึ่งค้นหาความหมายของคำและตัวย่อโซเชียลมีเดียจาก Urban Dictionary คุณจะได้เรียนรู้วิธีสร้าง CLI และเผยแพร่ไปยังรีจิสทรีแพ็คเกจ npm เพื่อให้ผู้อื่นสามารถติดตั้งได้

โปรดทำตามขั้นตอนเหล่านี้เพื่อสร้างโฟลเดอร์ใหม่และเริ่มต้นโปรเจ็กต์ Node.js ใหม่โดยใช้อินเทอร์เฟซบรรทัดคำสั่ง:1. เปิดเทอร์มินัลหรือพรอมต์คำสั่งบนคอมพิวเตอร์ของคุณ2. นำทางไปยังตำแหน่งที่ต้องการซึ่งคุณต้องการสร้างโฟลเดอร์ใหม่โดยพิมพ์เส้นทางไดเรกทอรีที่เหมาะสม ตัวอย่างเช่น หากคุณต้องการสร้างโฟลเดอร์ใหม่ชื่อ “my-project” ภายในโฮมไดเร็กตอรี่ของคุณ ให้พิมพ์คำสั่งต่อไปนี้: cd ~/my-project.3 เมื่อคุณนำทางไปยังไดเร็กทอรีที่ถูกต้องแล้ว ให้ใช้คำสั่ง mkdir ตามด้วยชื่อโฟลเดอร์ที่คุณต้องการสร้าง ในกรณีนี้ คำสั่งจะเป็น mkdir my-project สิ่งนี้จะสร้างโฟลเดอร์ว่างใหม่ชื่อ “my-project”4. หลังจากสร้างโฟลเดอร์ใหม่แล้ว ให้นำทางกลับ

 mkdir urbanary-cli
cd urbanary-cli
npm init -y

CLI นี้จะใช้ Axios เพื่อส่งคำขอ HTTP ไปยัง Urban Dictionary API คุณสามารถใช้ Rapid API เพื่อตรวจสอบปลายทางและดูข้อมูลรับรอง

CLI อย่างง่ายพร้อมคำสั่งย่อยและความช่วยเหลือ

ในการเริ่มสร้าง Command Line Interface (CLI) คุณจะต้องติดตั้งองค์ประกอบสำคัญสองส่วน ได้แก่ “Commander” และ “Axios” คุณสามารถทำได้โดยการรันคำสั่งเดียวที่รวมการขึ้นต่อกันทั้งสองอย่างไว้ในกระบวนการติดตั้ง คำสั่งที่จำเป็นมีดังนี้:

 npm install commander axios

โปรดสร้างโฟลเดอร์ใหม่ชื่อ “bin” ภายในไดเรกทอรีโครงการของคุณ รวมถึงไฟล์ว่างชื่อ “index.js”

 mkdir bin
cd bin
touch index.js

ไดเร็กทอรี “bin” ซึ่งย่อมาจาก “binary” มีความสำคัญอย่างยิ่ง เนื่องจากเป็นที่เก็บไฟล์จุดเริ่มต้นที่ NodeJS เรียกใช้เมื่อรันแอปพลิเคชัน command line interface (CLI) ไฟล์จุดเริ่มต้นนี้เรียกว่าไฟล์"index.js"หากต้องการเริ่มสร้าง CLI ของคุณเองโดยใช้ไลบรารี Commander.js อย่าลังเลที่จะแก้ไขไฟล์ “index.js” ที่กล่าวมาข้างต้น

ขั้นแรก นำเข้าโปรแกรมอ็อบเจ็กต์จาก Commander:

 const { program } = require('commander');

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

แน่นอนว่า นี่คือตัวอย่างวิธีที่คุณสามารถกำหนดคำสั่งย่อย find ในสคริปต์ CLI ของคุณที่ใช้แพ็คเกจ urbandictionary-api เพื่อค้นหาคำใน Urban Dictionary และแสดงคำจำกัดความ:javascriptconst { prompt }=need(’https//www.npmjs.com/package/prompt’);const UrbanDictionaryAPI=need(’./urban-dictionary-api’).default;//ฟังก์ชั่นเพื่อรับคำจำกัดความของคำโดยการค้นหาในพจนานุกรมในเมือง ฟังก์ชั่น apiasync find(word) {const result=await UrbanDictionaryAPI.getDefinition({ query: word });console.log( ${word}-${result} );}module.exports={ find };โค้ดนี้กำหนดฟังก์ชัน find ที่รับอาร์กิวเมนต์ตัวเดียว

 // index.js
program
    .command('find <word>')
    .description('find meaning of a word or abbreviation or slang')

ข้อมูลโค้ดที่ให้มาสาธิตการใช้งานฟังก์ชัน find ใน JavaScript โดยใช้วงเล็บเหลี่ยม ( <> ) ภายในเครื่องหมายคำพูดคู่ "" เพื่อกำหนดพารามิเตอร์ที่มีข้อกำหนดบังคับ หรืออาจใช้วงเล็บเหลี่ยม [] ได้ หากการมีอยู่ของพารามิเตอร์เป็นทางเลือก

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

เมื่อต้องการทดสอบ ให้เพิ่มสิ่งต่อไปนี้:

 program.parse() 

หลังจากรันโปรแกรมและระบุคำสั่ง"help"แล้ว ผลลัพธ์ที่ตามมาจะเป็นดังนี้:

การใช้วิธีการทั่วไปในการนำเสนอความช่วยเหลือภายในแอปพลิเคชัน Command Line Interface (CLI) มาตรฐานเป็นวิธีปฏิบัติทั่วไปที่ไม่ต้องใช้ความพยายามเพิ่มเติมจากนักพัฒนาเมื่อใช้งานไลบรารี Commander ผู้ใช้สามารถเข้าถึงคำแนะนำที่ให้มาได้อย่างง่ายดายโดยการป้อนตัวเลือก “-h” หรือ “–help” ตามด้วยคำสั่งที่ต้องการ เพื่อตรวจสอบคำแนะนำการใช้งานที่เกี่ยวข้องกับแต่ละคำสั่ง

การกำหนดตัวเลือกและการเตรียมโปรแกรมขั้นสุดท้าย

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

หากต้องการรวมตัวอย่างที่มีภาพประกอบไว้ในคำอธิบายคำศัพท์ด้วยวาจา เราสามารถทำตามขั้นตอนนี้ได้:

 program.option('-e,--example', "Display examples")

ต่อไปนี้เป็นวิธีระบุตัวเลือกที่กำหนดจำนวนคำจำกัดความที่จะส่งคืน:

 program.option(
    '-c,--count [amount]',
    'amount of definitions to display (max is 10)'
)

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

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

 program
    .command('find <word>')
    .description('find meaning of a word or abbreviation or slang')
    .option('-e,--example', "Display examples")
    .option(
        '-c,--count [amount]',
        'amount of definitions to display (max is 10)'
    )
    .action(async (word, options) => {});

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

 urbanary-cli find lol -e -c 3

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

 urbanary-cli find lol --example --count 3

ลองดู หน้า npm ของ Commander€™ เพื่อเรียนรู้เพิ่มเติมและวิธีปรับฟังก์ชันให้เหมาะกับกรณีการใช้งานที่แตกต่างกันของคุณ

การใช้ฟังก์ชันการทำงานของโปรแกรม

รวมไลบรารี Axios เข้ากับไฟล์ index.js โดยใช้ขั้นตอนต่อไปนี้:

 const axios = require('axios');

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

เริ่มต้นด้วยการกำหนดคำขอของคุณ:

 let requestOptions = {
    method: 'GET',
    URL: "https://mashape-community-urban-dictionary.p.rapidapi.com/define",
    params: { term: word },
    headers: {
        'X-RapidAPI-Key': YOUR_RAPID_API_KEY,
        'X-RapidAPI-Host': 'mashape-community-urban-dictionary.p.rapidapi.com'
    }
}

หากต้องการเข้าถึง API โดยใช้ Axios คุณสามารถใช้บรรทัดโค้ดต่อไปนี้:javascriptaxios.get(’https://api.example.com/data’).then(response=> {//จัดการข้อมูลการตอบสนองที่นี่}).catch(error=> {//จัดการข้อผิดพลาดที่นี่});

 try {
    let resp = await axios.request(requestOptions);
    console.log(`Definitions for ${word} fetched`);
    wordData = resp.data.list;
} catch (err) {
    console.error(err.message)
}

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

รวมข้อมูลโค้ดต่อไปนี้ภายใน try-block ที่มีอยู่ เพื่อให้แน่ใจว่าจะจัดการอินพุตตัวเลือกและแสดงเอาต์พุตที่สอดคล้องกันตามนั้น:

 if (options.example && options.count) {
    let cnt = 1;
    let definitions = wordData.slice(0, options.count);

    definitions.forEach((elem) => {
        console.log(`Definition ${cnt\+\+}: ${elem.definition}`);
        console.log(`Example:\n${elem.example}\n`);
    });
} else if (options.count && !options.example) {
    let cnt = 1;
    let definitions = wordData.slice(0, options.count);

    definitions.forEach((elem) => {
        console.log(`Definition ${cnt\+\+}: ${elem.definition}`);
    });
} else if (options.example) {
    console.log(`Definition: ${wordData[0].definition}`);
    console.log(`Example:\n${wordData[0].example}`);
} else {
    console.log(`Definition: ${wordData[0].definition}`);
}

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

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

หากต้องการเรนเดอร์แอปพลิเคชันที่ปฏิบัติการได้ ให้เริ่มต้นด้วยการรวมบรรทัด shebang ที่ส่วนเริ่มต้นของไฟล์ bin/index.js เพื่อเปิดใช้งานการดำเนินการเป็นสคริปต์อิสระ

 #!/usr/bin/env node 

จากนั้น ไปที่ไฟล์ package.json ภายในไดเร็กทอรีโปรเจ็กต์ของคุณ และแก้ไขเนื้อหาของคุณสมบัติ main นอกจากนี้ ให้เพิ่มคุณสมบัติ bin ใหม่ต่อท้ายคุณสมบัติที่มีอยู่ ดังภาพประกอบด้านล่าง:

 "main": "./bin/index.js",
"bin": {
  "urbanary-cli": "./bin/index.js"
},

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

หากต้องการติดตั้งแอปพลิเคชันทั่วโลกโดยใช้ npm ให้สำเร็จ ควรรันคำสั่ง “npm install-g” ในเทอร์มินัล การดำเนินการนี้จะทำให้สามารถดำเนินการแอปพลิเคชันเป็นคำสั่งจากเทอร์มินัลเดียวกันได้

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

การเผยแพร่งานของคุณบนรีจิสทรี npm (Node Package Manager) เป็นกระบวนการที่ไม่ซับซ้อนซึ่งช่วยให้เผยแพร่ในวงกว้างและติดตั้งโปรเจ็กต์ของคุณได้ง่าย เพื่อให้บรรลุเป้าหมายนี้ ให้นำทางไปยังโฟลเดอร์รูทของโปรเจ็กต์ของคุณ และดำเนินการคำสั่ง “npm publish” ในเทอร์มินัล เมื่อทำเช่นนี้ โครงการของคุณจะพร้อมให้ผู้อื่นติดตั้งได้อย่างง่ายดายผ่านคำสั่ง"การติดตั้ง npm"

การใช้ Node.js ช่วยอำนวยความสะดวกในการพัฒนาและการเผยแพร่แอปพลิเคชัน ซึ่งต่างจากการใช้ Rust หรือเทคโนโลยีที่คล้ายกันในการสร้างอินเทอร์เฟซบรรทัดคำสั่ง

สร้างแอปพลิเคชั่น CLI ที่ใช้งานได้ด้วย Node.js

แท้จริงแล้ว สำหรับผู้ที่มีส่วนร่วมในการพัฒนาแพ็คเกจ npm ที่ต้องใช้ยูทิลิตีบรรทัดคำสั่งเสริม หรือสำหรับนักพัฒนาที่ต้องการปรับปรุงเวิร์กโฟลว์ผ่านการสร้างเครื่องมือแบบกำหนดเอง แพ็คเกจ Node.js Commander นำเสนอโซลูชันที่ครอบคลุมเพื่อนำวิสัยทัศน์มาสู่การบรรลุผล.

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