Så här bygger du en CLI-applikation i Node.js

CLI-applikationer (Command Line Interface) är enkla 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 flesta av dessa program fungerar som verktyg som interagerar med ett operativsystem eller en applikation, oavsett om den är installerad på den lokala enheten eller nås via Internet, för att utföra uppgifter baserat på användarens kommandon och instruktioner.

Förstå CLI-program

Ett kommandoradsgränssnitt underlättar interaktionen mellan användaren och ett program genom att ange textkommandon. Beteendet hos många CLI-program kan variera avsevärt beroende på vilket initieringskommando som används.

Kommandot “ls” används för att visa information om filer och kataloger i ett användarvänligt format. Man kan utföra det genom att ange kommandot följt av önskade parametrar eller alternativ.

 ls -l /home 

Detta kommando innehåller:

Kommandoradsverktyget “ls” används för att lista och hantera filer i en katalog i ett Linux- eller Unix-operativsystem. Det ger användarna information om filbehörigheter, ägarskap, storlek, ändringsdatum och annan relevant information om de filer som lagras på deras system.

Den ovannämnda flaggan, som betecknas med “-l”, fungerar som ett alternativ till termen “long”, som ger en högre grad av specificitet i utdata.

I detta sammanhang avser “ett argument” en parameter eller en del av data som används i ett program eller system för att ange en viss plats eller katalog från vilken information ska hämtas eller visas. Det här kodavsnittet visar att den angivna sökvägen kan nås och bearbetas av det aktuella skriptet eller programmet.

När man utvecklar ett kommandoradsgränssnitt för ett program är det viktigt att följa etablerade konventioner för att säkerställa användbarhet och tillgänglighet för användare som är vana att arbeta i den här typen av miljö. Genom att införliva vanliga element kan du öka sannolikheten för att användare som inte känner till ditt specifika program ändå kommer att kunna navigera och interagera med det på ett effektivt sätt.

Vad är Commander.js?

Commander.js är ett npm-paket som underlättar utvecklingen av CLI-program (Command Line Interface) med hjälp av Node.js. Paketet innehåller en omfattande uppsättning verktyg och funktioner som gör det möjligt för utvecklare att skapa robusta CLI-applikationer med minimal ansträngning. Med Commander.js kan utvecklare helt enkelt ange de kommandon, alternativ och beteenden som krävs för deras CLI-applikation utan att behöva oroa sig för de underliggande implementeringsdetaljerna.

Genom att integrera Chalk.js tillsammans med detta paket kan man enkelt skapa en heltäckande operativ kommandoradsgränssnittsapplikation i Node.js-miljön.

Bygga en CLI-applikation i Node.js med hjälp av Commander.js

Ta ett exempel på en CLI-app, urbanary-cli, som slår upp betydelsen av ord och förkortningar för sociala medier från the Urban Dictionary . Du får lära dig hur du skapar CLI och publicerar det i npm-paketregistret så att andra kan installera det.

Följ dessa steg för att skapa en ny mapp och initiera ett nytt Node.js-projekt med kommandoradsgränssnittet:1. Öppna din terminal eller kommandotolk på din dator.2. Navigera till önskad plats där du vill skapa din nya mapp genom att skriva in lämplig katalogsökväg. Om du t.ex. vill skapa en ny mapp med namnet “my-project” i din hemkatalog skriver du följande kommando: cd ~/mitt-projekt .3. När du har navigerat till rätt katalog använder du kommandot mkdir följt av namnet på den mapp du vill skapa. I det här fallet är kommandot mkdir my-project . Detta skapar en ny tom mapp med namnet “my-project”.4. När du har skapat den nya mappen, navigera tillbaka

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

Detta CLI använder Axios för att skicka HTTP-förfrågningar till Urban Dictionary API. Du kan använda Rapid API för att kontrollera endpoints och visa autentiseringsuppgifter.

Ett enkelt CLI med ett underkommando och hjälp

För att börja bygga ditt CLI (Command Line Interface) måste du installera två viktiga komponenter - “Commander” och “Axios”. Du kan göra det genom att utföra ett enda kommando som inkluderar båda beroendena i sin installationsprocess. Det nödvändiga kommandot är följande:

 npm install commander axios

Skapa en ny mapp med namnet “bin” i din projektkatalog, samt en tom fil med namnet “index.js”.

 mkdir bin
cd bin
touch index.js

Katalogen “bin”, som står för “binary”, är mycket viktig eftersom den innehåller den startpunktsfil som NodeJS anropar när en applikation med kommandoradsgränssnitt (CLI) körs. Denna startpunktsfil kallas för “index.js”-filen. Om du vill börja bygga ditt eget CLI med hjälp av biblioteket Commander.js kan du göra ändringar i den ovan nämnda filen “index.js”.

Importera först programobjektet från Commander:

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

Använd programobjektet som ett instrument för att avgränsa gränssnittet för din applikation, vilket omfattar underordnade kommandon, val och parametrar. Denna enhet har motsvarande procedurer som motsvarar respektive aspekt; för att skapa ett underordnat kommando använder du

Här är ett exempel på hur du kan definiera ett find underkommando i ditt CLI-skript som använder paketet urbandictionary-api för att söka efter ord på Urban Dictionary och visa deras definitioner:javascriptconst { prompt } = require(’ ) = require(’ https://www.npmjs.com/package/prompt’);const UrbanDictionaryAPI = require(’./urban-dictionary-api’).default;// Funktion för att få definition av ord genom att söka i urban dictionary apiasync function find(word) {const result = await UrbanDictionaryAPI.getDefinition({ query: word });console.log( ${word} - ${result} );}module. exports = { find };Den här koden definierar en find funktion som tar ett enda argument

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

Det medföljande kodavsnittet visar en implementering av en find funktion i JavaScript, med hjälp av vinkelparenteser ( < > ) inom dubbla citattecken "" för att definiera en parameter med ett obligatoriskt krav. Alternativt kan hakparenteser [] användas om parametern är valfri.

Att inkludera ett illustrativt konto rekommenderas starkt eftersom Commander.js använder denna information för att producera informationsinnehåll för hjälpändamål. När kommandot ‘help’ används kommer en konventionell riktlinje för användning att presenteras.

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

 program.parse() 

Efter att ha kört programmet och försett det med kommandot “help” blir resultatet följande:

Att använda den konventionella metoden för att presentera hjälp i ett standard CLI-program (Command Line Interface) är en vanlig metod som inte kräver någon extra ansträngning från utvecklarna när de implementerar Commander-biblioteket. Användare kan enkelt komma åt den vägledning som ges genom att antingen ange alternativet “-h” eller “-help” följt av önskat kommando för att granska de användningsinstruktioner som är kopplade till varje enskilt kommando.

Definiera alternativ och förbereda det slutliga programmet

Du kan anpassa ett kommandos beteende ytterligare genom att använda alternativmetoden tillsammans med kommandodefinitionen och effektivt länka samman dem genom denna teknik som kallas “chaining”.

För att inkludera illustrativa exempel i de verbala förklaringarna av vokabulären kan man följa denna procedur:

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

Här är ett sätt att ange ett alternativ som bestämmer antalet definitioner som ska returneras:

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

Metoden som underlättar val från en rad alternativ använder två strängar som indata, där den ena representerar valets beteckning i både kortfattat och utökat format, medan den andra förkroppsligar dess medföljande utläggning. Dessutom anger en valfri parameter som betecknas med “count” den siffra som motsvarar den erforderliga mängden sammanfattningar som ska visas.

Den sista metoden att införliva i vår implementering är metoden action , som används för att utföra de operationer som ingår i kommandot find . Genom att inkludera denna metod i vår kodbas kan vi säkerställa att vårt program följer en struktur som liknar den medföljande mallen. Följaktligen kommer den resulterande konfigurationen av vår kod att uppvisa ett format som liknar följande:

 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) => {});

Genom att införliva den angivna konfigurationen kan en begäran om tre förekomster av “lol” tillsammans med motsvarande illustrationer se ut på följande sätt:

 urbanary-cli find lol -e -c 3

Ett alternativt sätt att hantera detta problem skulle kunna vara att utforska ett annat perspektiv eller en annan strategi för att hantera det. En möjlighet är att överväga andra tillgängliga alternativ som kan ge mer gynnsamma resultat än de som för närvarande eftersträvas. Det kan handla om att söka ytterligare information om potentiella lösningar eller rådgöra med experter inom relevanta områden som kan erbjuda värdefulla insikter och rekommendationer. Genom att vidta sådana åtgärder kan vi sträva efter att uppnå bättre resultat samtidigt som vi undviker negativa konsekvenser som är förknippade med vår nuvarande handlingslinje.

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

Kolla in Commander’s npm page för att lära dig mer om den och hur du anpassar dess funktioner för dina olika användningsfall.

Implementera programmets funktionalitet

Inkorporera biblioteket Axios i index.js-filen genom att använda följande steg:

 const axios = require('axios');

Inom de funktionella parametrarna för “action”-objektets metod kan man införliva den nödvändiga koden för att interagera med Urban Dictionary och presentera resultaten baserat på förutbestämda preferenser.

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

För att komma åt API:et med hjälp av Axios kan man använda följande kodrad:javascriptaxios.get(’ https://api.example.com/data’).then(response => {// hantera responsdata här}).catch(error => {// hantera fel här});

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

En av de viktigaste delarna av informationen som vi behöver från responsdata är egenskapen enumerable, som innehåller en samling av definitioner och illustrationer.

Införliva följande kodavsnitt i ett befintligt try-block och se till att det hanterar alternativinmatning och visar motsvarande utdata i enlighet med detta:

 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}`);
}

Den aktuella koden analyserar de inmatade kommandona med hjälp av villkorliga satser för att fastställa den lämpligaste metoden för att visa resultaten. Om parametrarna som består av ett illustrativt exempel, ett avgränsande tecken och ett summeringsalternativ tillhandahålls, kommer programmet att iterera över data som rör enskilda ord och skriva ut det erforderliga antalet definitioner och exempelfall i enlighet med detta.

Funktionen kommer att visa ett visst antal definitioner och/eller exempel baserat på användarens inmatning. Om endast “count” anges, kommer funktionen att visa det specifika antalet definitioner utan exempel. Om “example” anges som argument kommer en definition att visas tillsammans med en exempelmening. Om inget av alternativen anges kommer standardbeteendet att vara att bara visa definitionen.

För att göra programmet körbart börjar du med att infoga en shebang-rad i början av filen bin/index.js, vilket gör att den fungerar som ett självständigt skript.

 #!/usr/bin/env node 

Navigera sedan till filen package.json i din projektkatalog och ändra innehållet i egenskapen main . Lägg dessutom till en ny bin -egenskap efter den befintliga, som illustreras nedan:

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

I grund och botten ligger kärnan i att utföra ett urbanary-cli-baserat projekt i det kommando som anges via terminalen. Följaktligen är det absolut nödvändigt att man använder en lämplig titel för kommandot när man utvecklar kommandoradsapplikationer.

För att framgångsrikt installera applikationen globalt med npm, bör man köra kommandot “npm install -g” i sin terminal. Denna åtgärd gör det möjligt att exekvera applikationen som ett kommando från samma terminal.

Den medföljande illustrationen visar hur man installerar och kör ett diagnostiskt kommando för att fastställa syftet med lmk-modulen.

Att publicera ditt arbete i registret för npm (Node Package Manager) är en enkel process som möjliggör omfattande distribution och enkel installation av ditt projekt. För att åstadkomma detta navigerar du till rotmappen för ditt projekt och kör kommandot “npm publish” i terminalen. På så sätt blir ditt projekt tillgängligt för andra som enkelt kan installera det med kommandot “npm install”.

Att använda Node.js underlättar utvecklingen och spridningen av applikationer i motsats till att använda Rust eller liknande tekniker för att konstruera kommandoradsgränssnitt.

Bygg funktionella CLI-program med Node.js

För dem som är engagerade i utvecklingen av ett npm-paket som kräver ett kompletterande kommandoradsverktyg, eller för utvecklare som vill förbättra sitt arbetsflöde genom att skapa anpassade verktyg, erbjuder Node.js Commander-paketet en omfattande lösning för att förverkliga sin vision.

Man kan enkelt förbättra användarupplevelsen av kommandoradsgränssnitt i sina program genom att använda ytterligare bibliotek tack vare den inneboende mångsidigheten och stabiliteten i Node.js, som fungerar som en pålitlig grund för sådana försök utan betydande komplikationer.