Hoe een CLI-toepassing bouwen in Node.js

CLI (Command Line Interface) toepassingen zijn simplistische tekstgebaseerde apps die in de terminal draaien om specifieke taken uit te voeren. CLI-applicaties spelen een cruciale rol in de workflow van bijna elke ontwikkelaar en IT-professional.

De meeste van deze softwareprogramma’s dienen als hulpprogramma’s die interageren met een operationeel systeem of een operationele toepassing, of die nu geïnstalleerd is op het lokale apparaat of toegankelijk is via het internet, om taken uit te voeren op basis van opdrachten en instructies van de gebruiker.

CLI-toepassingen begrijpen

Een opdrachtregelinterface vergemakkelijkt de interactie tussen de gebruiker en een programma door het invoeren van tekstuele opdrachten. Het gedrag van veel CLI-toepassingen kan aanzienlijk variëren op basis van het gebruikte initiatiecommando.

Het “ls” commando wordt gebruikt om de details van bestanden en mappen in een gebruikersvriendelijk formaat weer te geven. Je kunt het uitvoeren door het commando in te voeren gevolgd door de gewenste parameters of opties.

 ls -l /home 

Deze opdracht bevat:

Het commandoregelhulpprogramma “ls” wordt gebruikt om bestanden in een map op te sommen en te beheren in een Linux- of Unix-besturingssysteem. Het geeft gebruikers informatie over bestandsrechten, eigendom, grootte, wijzigingsdatum en andere relevante details over de bestanden die op hun systemen zijn opgeslagen.

De bovengenoemde vlag, aangeduid met ‘-l’, dient als alternatief voor de term “long”, die een grotere mate van specificiteit in de uitvoer oproept.

In deze context verwijst “een argument” naar een parameter of een gegeven dat in een programma of systeem wordt gebruikt om een bepaalde locatie of map op te geven waaruit informatie moet worden opgehaald of weergegeven. Het gegeven codefragment geeft aan dat het opgegeven pad toegankelijk is en verwerkt kan worden door het script of de toepassing in kwestie.

Bij het ontwikkelen van een opdrachtregelinterface voor een softwaretoepassing is het belangrijk om vast te houden aan gevestigde conventies om de bruikbaarheid en toegankelijkheid te garanderen voor gebruikers die gewend zijn om in dit soort omgeving te werken. Door veelgebruikte elementen op te nemen, kun je de kans vergroten dat gebruikers die niet bekend zijn met jouw specifieke programma toch effectief kunnen navigeren en interacteren.

Wat is Commander.js?

Commander.js is een npm-pakket dat de ontwikkeling van CLI-toepassingen (command line interface) met Node.js vergemakkelijkt. Het pakket biedt een uitgebreide set gereedschappen en functionaliteiten waarmee ontwikkelaars robuuste CLI-toepassingen kunnen maken met minimale inspanning. Met Commander.js kunnen ontwikkelaars eenvoudig de commando’s, opties en gedragingen specificeren die nodig zijn voor hun CLI-toepassing, zonder zich zorgen te hoeven maken over de onderliggende implementatiedetails.

Door Chalk.js naast dit pakket te integreren, kan men moeiteloos een volledig operationele commandoregelinterface-applicatie genereren binnen de Node.js-omgeving.

Een CLI-applicatie bouwen in Node.js met Commander.js

Neem een voorbeeld van een CLI-app, urbanary-cli, die de betekenis van woorden en afkortingen van sociale media opzoekt uit het Urban Dictionary . Je leert hoe je de CLI maakt en publiceert naar het npm package register zodat anderen het kunnen installeren.

Volg deze stappen om een nieuwe map te maken en een nieuw Node.js project te initialiseren met behulp van de opdrachtregelinterface:1. Open je terminal of opdrachtprompt op je computer.2. Navigeer naar de gewenste locatie waar je je nieuwe map wilt maken door het juiste directorypad in te typen. Als je bijvoorbeeld een nieuwe map met de naam “mijn-project” wilt maken in je thuismap, typ je het volgende commando in: cd ~/mijn-project .3. Zodra je naar de juiste map bent gegaan, gebruik je de opdracht mkdir gevolgd door de naam van de map die je wilt maken. In dit geval is de opdracht mkdir my-project . Dit maakt een nieuwe lege map met de naam “my-project”.4. Nadat je de nieuwe map hebt gemaakt, navigeer je terug

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

Deze CLI gebruikt Axios om HTTP-verzoeken naar de Urban Dictionary API te sturen. Je kunt Rapid API gebruiken om eindpunten te controleren en referenties te bekijken.

Een eenvoudige CLI met een subcommando en Help

Om te beginnen met het bouwen van je Command Line Interface (CLI), moet je twee essentiële onderdelen installeren - “Commander” en “Axios”. U kunt dit doen door een enkel commando uit te voeren dat beide afhankelijkheden opneemt in het installatieproces. Het vereiste commando is als volgt:

 npm install commander axios

Maak een nieuwe map aan met de naam “bin” in je projectmap, evenals een leeg bestand met de naam “index.js”.

 mkdir bin
cd bin
touch index.js

De map “bin”, wat staat voor “binair”, is van groot belang omdat het het invoerpuntbestand bevat dat NodeJS aanroept bij het uitvoeren van een opdrachtregelinterface (CLI) toepassing. Dit bestand wordt het “index.js” bestand genoemd. Om te beginnen met het bouwen van je eigen CLI met behulp van de Commander.js bibliotheek, voel je vrij om wijzigingen aan te brengen in het eerder genoemde “index.js” bestand.

Importeer eerst het programprogramobject van Commander:

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

Gebruik het programmaobject als een instrument om de interface van je toepassing af te bakenen, inclusief aanvullende opdrachten, keuzes en parameters. Deze entiteit heeft tegenhangerprocedures die overeenkomen met elk respectief facet; om een ondergeschikt commando te maken, gebruik je de

Zeker, hier is een voorbeeld van hoe je een find subcommando kunt definiëren in je CLI-script dat het urbandictionary-api pakket gebruikt om woorden te zoeken in Urban Dictionary en hun definities weer te geven:javascriptconst { prompt } = require(’ https://www.npmjs.com/package/prompt’);const UrbanDictionaryAPI = require(’./urban-dictionary-api’).default;// Functie om definitie van woord te krijgen door te zoeken in urban dictionary apiasync functie find(word) {const result = await UrbanDictionaryAPI.getDefinition({query: word });console.log( ${word} - ${result} );}module. exports = { find };Deze code definieert een find functie die een enkel argument neemt

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

Het gegeven codefragment demonstreert een implementatie van een find functie in JavaScript, waarbij hoekhaken ( < > ) binnen dubbele aanhalingstekens "" worden gebruikt om een parameter met een verplichte vereiste te definiëren. Als alternatief kunnen vierkante haakjes [] worden gebruikt als de aanwezigheid van de parameter optioneel is.

Het opnemen van een illustratieve account wordt sterk aangeraden omdat Commander.js deze informatie gebruikt om informatieve inhoud te produceren voor hulpdoeleinden. Wanneer het commando ‘help’ wordt uitgevoerd, wordt een conventionele richtlijn voor het gebruik weergegeven.

Om dit te testen, voegt u het volgende toe:

 program.parse() 

Na het uitvoeren van het programma en het geven van de opdracht ‘help’, is het resultaat als volgt:

Het gebruik van de conventionele methode voor het presenteren van hulp binnen een standaard Command Line Interface (CLI)-toepassing is een gebruikelijke praktijk die geen extra inspanning van ontwikkelaars vereist bij het implementeren van de Commander-bibliotheek. Gebruikers hebben eenvoudig toegang tot de geboden begeleiding door de optie “-h” of “-help” in te voeren gevolgd door de gewenste opdracht om de gebruiksinstructies van elke afzonderlijke opdracht te bekijken.

Opties definiëren en het uiteindelijke programma voorbereiden

Je kunt het gedrag van een commando verder aanpassen door de optiemethode te gebruiken in combinatie met de opdrachtdefinitie, waarbij ze effectief aan elkaar worden gekoppeld via deze techniek die bekend staat als “chaining”.

Om illustratieve voorbeelden op te nemen in de verbale uitleg van woordenschat, kun je deze procedure volgen:

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

Hier is een manier om een optie op te geven die het aantal terug te geven definities bepaalt:

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

De methode die selectie uit een reeks alternatieven mogelijk maakt, gebruikt twee strings als invoer, waarbij de ene de benaming van de keuze weergeeft in zowel beknopte als uitgebreide vorm, terwijl de tweede de bijbehorende uiteenzetting belichaamt. Bovendien specificeert een optionele parameter, aangeduid met “count”, het cijfer dat overeenkomt met het vereiste aantal synopsieën dat moet worden weergegeven.

De laatste methode om in onze implementatie op te nemen is de actie methode, die dient om de operaties uit te voeren die inherent zijn aan het find commando. Door deze methode in onze codebase op te nemen, kunnen we ervoor zorgen dat ons programma zich houdt aan een structuur die lijkt op het verstrekte sjabloon. Bijgevolg zal de resulterende configuratie van onze code een formaat hebben dat lijkt op het volgende:

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

Met de gegeven configuratie zou het uitvoeren van een verzoek voor drie instanties van “lol” met bijbehorende illustraties er als volgt uit kunnen zien:

 urbanary-cli find lol -e -c 3

Een alternatieve benadering om dit probleem aan te pakken zou kunnen bestaan uit het verkennen van een ander perspectief of een andere strategie om het probleem aan te pakken. Een mogelijkheid is het overwegen van andere beschikbare opties die gunstiger resultaten kunnen opleveren dan de opties die momenteel worden nagestreefd. Dit kan inhouden dat we aanvullende informatie zoeken over mogelijke oplossingen of overleg plegen met experts op relevante gebieden die waardevolle inzichten en aanbevelingen kunnen bieden. Door dergelijke stappen te ondernemen, kunnen we streven naar betere resultaten terwijl we negatieve gevolgen van onze huidige manier van handelen vermijden.

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

Bekijk de npm-pagina van Commander om er meer over te leren en hoe u de functies kunt aanpassen voor uw verschillende gebruikssituaties.

De functionaliteit van het programma implementeren

Integreer de bibliotheek Axios in het bestand index.js door gebruik te maken van de volgende stappen:

 const axios = require('axios');

Binnen de functionele parameters van de methode van het object “actie†kan de noodzakelijke code worden opgenomen om te communiceren met Urban Dictionary en de resultaten te presenteren op basis van vooraf bepaalde voorkeuren.

Begin met het definiëren van je verzoek:

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

Om toegang te krijgen tot de API met behulp van Axios, kun je de volgende regel code gebruiken: javascriptaxios.get(’ https://api.example.com/data’).then(response => {/handelen responsgegevens hier}).catch(error => {/handelen fout hier});

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

Een van de belangrijkste stukjes informatie die we nodig hebben van de responsgegevens is de enumerable eigenschap, die een verzameling definities en illustraties bevat.

Neem het volgende codefragment op in een bestaand try-block en zorg ervoor dat het de invoer van opties verwerkt en de overeenkomstige uitvoer weergeeft:

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

De huidige code analyseert de invoeropdrachten met behulp van voorwaardelijke verklaringen om de meest geschikte methode voor het weergeven van de resultaten vast te stellen. Als de parameters bestaan uit een illustratief voorbeeld, een scheidingsteken en een optie om te tellen, zal het programma de gegevens met betrekking tot individuele woorden doorlopen en het vereiste aantal definitie- en voorbeeldgevallen dienovereenkomstig afdrukken.

De functie toont een bepaald aantal definities en/of voorbeelden op basis van de invoer van de gebruiker. Als alleen “count” wordt doorgegeven, wordt dat specifieke aantal definities zonder voorbeelden weergegeven. Op dezelfde manier zal het opgeven van “voorbeeld” als argument één definitie samen met een voorbeeldzin weergeven. Als geen van beide opties wordt opgegeven, wordt standaard alleen de definitie getoond.

Om de applicatie uitvoerbaar te maken, begin je met het opnemen van een shebang regel aan het begin van het bin/index.js bestand, zodat het als een onafhankelijk script kan werken.

 #!/usr/bin/env node 

Navigeer vervolgens naar het bestand package.json in je projectmap en wijzig de inhoud van de eigenschap main . Voeg daarnaast een nieuwe bin eigenschap toe na de bestaande, zoals hieronder geïllustreerd:

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

In essentie ligt de crux van het uitvoeren van een op urbanary-cli gebaseerd project in het commando dat via de terminal wordt ingevoerd. Daarom is het noodzakelijk om een passende titel voor dat commando te gebruiken tijdens het ontwikkelen van commandoregelapplicaties.

Om de applicatie wereldwijd te installeren met npm, moet je het commando “npm install -g” in je terminal uitvoeren. Hierdoor kan de toepassing als een opdracht worden uitgevoerd vanaf dezelfde terminal.

De bijgevoegde illustratie toont de procedure voor het installeren en uitvoeren van een diagnostische opdracht om het doel van de lmk-module te achterhalen.

Je werk publiceren op het npm (Node Package Manager) register is een eenvoudig proces dat zorgt voor wijdverspreide distributie en eenvoudige installatie van je project. Om dit te bereiken, navigeer je naar de hoofdmap van je project en voer je het commando “npm publish” uit in de terminal. Door dit te doen, zal je project beschikbaar zijn voor anderen om gemakkelijk te installeren via de opdracht “npm install”.

Het gebruik van Node.js vergemakkelijkt de ontwikkeling en verspreiding van toepassingen in tegenstelling tot het gebruik van Rust of vergelijkbare technologieën voor het bouwen van commandoregelinterfaces.

Bouw functionele CLI-toepassingen met Node.js

Voor degenen die bezig zijn met de ontwikkeling van een npm-pakket dat een aanvullend hulpprogramma voor de opdrachtregel nodig heeft, of voor ontwikkelaars die hun workflow willen verbeteren door aangepaste tools te maken, biedt het Node.js Commander-pakket een uitgebreide oplossing om iemands visie tot bloei te brengen.

Men kan de gebruikerservaring van commandoregelinterfaces in hun applicaties gemakkelijk vergroten door gebruik te maken van aanvullende bibliotheken, dankzij de inherente veelzijdigheid en stabiliteit van Node.js, dat dient als een betrouwbare basis voor dergelijke inspanningen zonder noemenswaardige complicaties.