Hur man bygger en CLI-applikation i Node.js

CLI-applikationer (Command Line Interface) är förenklade textbaserade appar som körs i terminalen för att utföra specifika uppgifter. CLI-applikationer spelar en avgörande roll i arbetsflödet för nästan alla utvecklare och IT-proffs.

De är mestadels verktyg som interagerar med operativsystemet eller applikationer som är det installerat lokalt eller tillgängligt över internet för att utföra en uppgift enligt användarens input och direktiv.

Förstå CLI-applikationer

Ett kommandoradsgränssnitt låter dig interagera med ett program genom att skriva textrader. Många CLI-program körs olika beroende på vilket kommando du använder för att starta dem.

Till exempel, ls-programmet visar filinformation och innehållet i kataloger. Du kan köra det så här:

ls -l /home

Detta kommando inkluderar:

• Namnet på programmet: ls.
• Ett alternativ (eller flagga). I detta fall, -l är ett alternativ som är kort för "lång" och ger mer detaljerad information.
instagram viewer
• Ett argument, /home. Här anger argumentet en sökväg till katalogen att visa information om.

Även om varje program kan definiera sitt eget kommandoradsgränssnitt, är vissa element vanliga och i stor användning. Du bör följa dessa standarder så att någon som är bekant med ett kommandoradsgränssnitt lätt kan använda dina program.

Vad är Commander.js?

Commander.js är ett paket som låter dig bygga CLI-appar i Node.js. Den har ett rikt bibliotek med funktioner som låter dig bygga en standard CLI-applikation, som utför mycket av det tunga arbetet. Du behöver bara definiera kommandon, alternativ och funktionalitet för din CLI-app.

Genom att kombinera det med andra paket som Chalk.js för styling kan du snabbt skapa en fullt fungerande CLI-app i Node.js.

Bygga en CLI-applikation i Node.js med Commander.js

Tänk på ett exempel på CLI-app, urban-cli, som slår upp betydelsen av ord och sociala mediers förkortningar från Urban Dictionary. Du lär dig hur du skapar CLI och publicerar den till npm paketregistret så att andra kan installera det.

Skapa en ny mapp och initiera ett nytt Node.js-projekt med följande kommandon:

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

Denna CLI kommer att använda Axios för att skicka HTTP-förfrågningar till Urban Dictionary API. Du kan använda Snabb API för att kontrollera slutpunkter och visa referenser.

En enkel CLI med ett underkommando och hjälp

För att börja bygga din CLI, installera Commander och Axios med följande kommando:

npm install commander axios

Skapa en ny mapp, bin, i din projektkatalog och en ny tom fil, index.js:

mkdir bin
cd bin
touch index.js

De bin (förkortning av "binär") mappen är viktig eftersom den innehåller ingångspunktsfilen som Node anropar när du kör din CLI. De index.js fil är denna ingångspunktsfil. Redigera nu filen index.js och börja bygga din CLI med Commander.js API.

Importera först program objekt från Commander:

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

Du kommer att använda program objekt för att definiera ditt programs gränssnitt, inklusive underkommandon, alternativ och argument. Objektet har motsvarande metoder för var och en av dessa; till exempel, för att definiera ett underkommando, använd kommando metod.

Definiera a hitta underkommando för CLI att slå upp ord från Urban Dictionary och lägga till en beskrivning för det med koden nedan:

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

Detta registrerar en hitta kommando, som förväntar sig ett ord efter det och en beskrivning av det. Användningen av vinkelparenteser betyder att ordet är ett obligatoriskt argument; använd hakparenteser istället ([]) för att göra det valfritt.

Du bör lägga till en beskrivning eftersom Commander.js använder den för att generera hjälptext. När du kör programmet med hjälp kommando får du en standardanvändningsguide.

För att testa detta, lägg till följande:

program.parse()

Kör sedan programmet och skicka det till hjälp kommando för att få utdata nedan:

Så här kommer alla vanliga CLI-applikationer att visa sin hjälp för användarna och med Commander behöver du inte oroa dig för att skapa den själv. De -h och --hjälp alternativ är användbara för att kontrollera användningsguiden för ett kommando.

Definiera alternativ och förbereda det slutliga programmet

Du definierar också ett alternativ genom att koppla ihop alternativ metod till kommandodefinitionen.

Så här definierar du ett alternativ för att inkludera exempel i definitionerna av ord:

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

Och så här definierar du ett alternativ som anger antalet definitioner som ska returneras:

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

De alternativ metod accepterar två strängparametrar, en för alternativets namn (både korta och långa former) och den andra för dess beskrivning. Det extra [belopp] argument i räkna alternativet är värdet för antalet definitioner som ska visas.

Nu är den sista metoden att lägga till handling metod. Du kommer att implementera hitta kommandots funktionalitet inom denna metod. Lägg till den i kedjan så att din kod nu ser ut så här:

program
 .command('find ')
 .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) => {});

Med denna inställning, här är vad ett kommando att få tre definitioner av LOL med exempel kommer att se ut så här:

urbanary-cli find lol -e -c 3

Eller använd den långa formen för varje alternativ:

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

Kolla upp Befälhavarens npm-sida för att lära dig mer om det och hur du anpassar dess funktioner för dina olika användningsfall.

Implementera programmets funktionalitet

Importera först Axios till din index.js fil enligt följande:

const axios = require('axios');

Sedan, i funktionskroppen för handlings parameter kan du implementera logiken för att göra förfrågningar till Urban Dictionary och visa resultat enligt dina alternativ.

Börja med att definiera din begäran:

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'
 }
}

Gör sedan begäran till API: t med Axios med följande kod:

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

Den enda egenskap du behöver från svarsdata är lista egendom som innehåller definitioner och exempel.

Fortfarande i Prova blockera, lägg till denna logik för att hantera alternativ och visa resultaten enligt följande:

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`);
 });
} elseif (options.count && !options.example) {
let cnt = 1;
let definitions = wordData.slice(0, options.count);
 definitions.forEach((elem) => {
console.log(`Definition ${cnt++}: ${elem.definition}`);
 });
} elseif (options.example) {
console.log(`Definition: ${wordData[0].definition}`);
console.log(`Example:\n${wordData[0].example}`);
} else {
console.log(`Definition: ${wordData[0].definition}`);
}

Den här koden utvärderar kommandoargumenten med hjälp av if-else-satser för att bestämma hur utdata ska visas. Om exempel och räkna alternativ passeras, det itererar igenom wordData och skriver ut det angivna antalet definitioner och exempel med dem.

Om du bara passerar räkna, visar den mängden definitioner utan exempel. Om du bara passerar exempel, visar den en definition med en exempelmening. De annan uttalande är standardbeteendet för att bara skriva ut definitionen om du inte godkänner några alternativ.

Applikationen är nu klar, så nästa steg är att göra den körbar. Börja med att lägga till en shebang linje till början av din bin/index.js-fil så att du kan köra den som ett fristående skript:

#!/usr/bin/env node

Öppna sedan din package.json fil, redigera värdet på huvud egendom och lägg till en bin egendom efter det så här:

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

Nyckeln urban-cli, under bin är kommandot du anger i din terminal för att köra din applikation. Så se till att använda ett passande namn där när du bygger dina kommandoradsapplikationer.

Springa npm installera -g för att installera programmet globalt, och du kommer att kunna köra programmet som ett kommando från din terminal.

Bilden nedan visar installationsprocessen och ett testkommando att hitta innebörden av lmk:

Du kan också publicera det till npm-paketregistret genom att köra npm publicera i terminalen i projektkatalogen. Detta gör att den kan installeras av vem som helst från var som helst som använder npm installera.

Det är lättare att bygga och publicera din applikation med Node.js, jämfört med när du bygga CLI: er med teknologier som Rust.

Bygg funktionella CLI-applikationer med Node.js

Oavsett om du arbetar med ett npm-paket och behöver ett CLI-verktyg som medföljer det, eller om du bara vill bygga ett verktyg för att förbättra ditt arbetsflöde som utvecklare. Du har allt du behöver för att förverkliga din idé med Node.js Commander-paketet.

Du kan också gå längre genom att använda andra bibliotek för att skapa förbättrade CLI-upplevelser för dina applikationer, Node.js är tillräckligt robust för att tjäna dina syften utan mycket krångel.