Como criar um aplicativo CLI no Node.js

As aplicações CLI (Command Line Interface) são aplicações simplistas baseadas em texto que são executadas no terminal para realizar tarefas específicas. As aplicações CLI desempenham um papel crucial no fluxo de trabalho de quase todos os programadores e profissionais de TI.

A maioria destes programas de software funciona como utilitários, que interagem com um sistema operacional ou aplicação, quer esteja instalado no dispositivo local ou acedido através da Internet, para executar tarefas com base nos comandos e instruções do utilizador.

Compreender as aplicações CLI

Uma interface de linha de comandos facilita a interação entre o utilizador e um programa através da introdução de comandos textuais. O comportamento de numerosas aplicações CLI pode variar consideravelmente com base no comando de iniciação utilizado.

De facto, o comando “ls” é utilizado para mostrar os detalhes de ficheiros e directórios num formato de fácil utilização. Para o executar, basta introduzir o comando seguido de quaisquer parâmetros ou opções pretendidos.

 ls -l /home 

Este comando inclui:

O utilitário de linha de comandos conhecido como “ls” é utilizado para listar e gerir ficheiros dentro de um diretório num sistema operativo Linux ou Unix. Fornece aos utilizadores informações sobre permissões de ficheiros, propriedade, tamanho, data de modificação e outros detalhes relevantes relativos aos ficheiros armazenados nos seus sistemas.

O sinalizador acima mencionado, denotado por ‘-l’, serve como uma alternativa ao termo “long”, que provoca um maior grau de especificidade na sua saída.

Neste contexto, “Um argumento” refere-se a um parâmetro ou dado que é utilizado num programa ou sistema para especificar uma determinada localização ou diretório a partir do qual a informação deve ser obtida ou apresentada. O fragmento de código apresentado indica que o caminho especificado pode ser acedido e processado pelo script ou aplicação em questão.

Ao desenvolver uma interface de linha de comandos para uma aplicação de software, é importante aderir às convenções estabelecidas para garantir a usabilidade e acessibilidade dos utilizadores habituados a trabalhar neste tipo de ambiente. Ao incorporar elementos normalmente utilizados, pode aumentar a probabilidade de os utilizadores não familiarizados com o seu programa específico conseguirem navegar e interagir com ele de forma eficaz.

O que é Commander.js?

Commander.js é um pacote npm que facilita o desenvolvimento de aplicativos de interface de linha de comando (CLI) usando Node.js. O pacote fornece um conjunto abrangente de ferramentas e funcionalidades que permitem aos programadores criar aplicações CLI robustas com o mínimo de esforço. Com o Commander.js, os programadores podem simplesmente especificar os comandos, as opções e os comportamentos exigidos pela sua aplicação CLI sem terem de se preocupar com os pormenores de implementação subjacentes.

Ao integrar o Chalk.js a este pacote, é possível gerar sem esforço um aplicativo de interface de linha de comando operacional abrangente dentro do ambiente Node.js.

Construindo um aplicativo CLI em Node.js usando Commander.js

Considere um exemplo de aplicativo CLI, urbanary-cli, que procura o significado de palavras e abreviações de mídia social do Dicionário Urbano . Você aprenderá como criar a CLI e publicá-la no registro de pacotes npm para que outros possam instalá-la.

Siga estas etapas para criar uma nova pasta e inicializar um novo projeto Node.js usando a interface de linha de comando:1. Abra o terminal ou o prompt de comando no computador.2. Navegue até o local desejado onde você gostaria de criar sua nova pasta digitando o caminho do diretório apropriado. Por exemplo, se pretender criar uma nova pasta com o nome “my-project” no seu diretório pessoal, digite o seguinte comando: cd ~/meu-projeto .3. Depois de ter navegado para o diretório correto, utilize o comando mkdir seguido do nome da pasta que pretende criar. Neste caso, o comando será mkdir my-project . Isso criará uma nova pasta vazia chamada “meu-projeto”.4. Depois de criar a nova pasta, navegue de volta

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

Essa CLI usará o Axios para enviar solicitações HTTP para a API do Urban Dictionary. Você pode usar Rapid API para verificar os pontos de extremidade e visualizar as credenciais.

Uma CLI simples com um subcomando e ajuda

Para começar a construir a sua interface de linha de comandos (CLI), terá de instalar dois componentes essenciais - “Commander” e “Axios”. Pode fazê-lo executando um único comando que incorpora ambas as dependências no seu processo de instalação. O comando necessário é o seguinte:

 npm install commander axios

Crie uma nova pasta com o nome “bin” no diretório do seu projeto, bem como um ficheiro vazio com o título “index.js”.

 mkdir bin
cd bin
touch index.js

O diretório “bin”, que significa “binário”, tem uma importância significativa, pois abriga o arquivo de ponto de entrada que o NodeJS invoca ao executar um aplicativo de interface de linha de comando (CLI). Este ficheiro de ponto de entrada é referido como o ficheiro “index.js”. Para começar a construir sua própria CLI usando a biblioteca Commander.js, sinta-se à vontade para fazer modificações no arquivo “index.js” mencionado acima.

Primeiro, importe theprogramobject do Commander:

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

Utilize o objeto program como um instrumento para delinear a interface da sua aplicação, englobando comandos subsidiários, escolhas e parâmetros. Esta entidade possui procedimentos de contrapartida que correspondem a cada faceta respectiva; nomeadamente, para estabelecer um comando subordinado, utilize o

Certamente, eis um exemplo de como pode definir um subcomando find no seu script CLI que utiliza o pacote urbandictionary-api para procurar palavras no Urban Dictionary e apresentar as respectivas definições:javascriptconst { prompt } = require(’ https://www.npmjs.com/package/prompt’);const UrbanDictionaryAPI = require(’./urban-dictionary-api’).default;// Função para obter a definição de uma palavra pesquisando no urban dictionary apiasync function find(word) {const result = await UrbanDictionaryAPI.getDefinition({ query: word });console.log( ${word} - ${result} );}module. exports = { find };Este código define uma função find que recebe um único argumento

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

O trecho de código fornecido demonstra uma implementação de uma função find em JavaScript, utilizando colchetes angulares ( < > ) entre aspas duplas "" para definir um parâmetro com um requisito obrigatório. Em alternativa, podem ser utilizados parênteses rectos [] se a presença do parâmetro for opcional.

A incorporação de uma conta ilustrativa é altamente recomendada, uma vez que o Commander.js utiliza esta informação para produzir conteúdo informativo para efeitos de assistência. Quando executado através do comando ‘help’, será apresentada uma diretriz convencional de utilização.

Para testar isso, adicione o seguinte:

 program.parse() 

Depois de executar o programa e de lhe dar o comando “help”, o resultado subsequente é o seguinte:

A utilização do método convencional de apresentação de assistência numa aplicação CLI (Command Line Interface) padrão é uma prática comum que não requer qualquer esforço adicional por parte dos programadores quando implementam a biblioteca Commander. Os utilizadores podem aceder facilmente à orientação fornecida introduzindo a opção “-h” ou “-help” seguida do comando pretendido para rever as instruções de utilização associadas a cada comando individual.

Definir opções e preparar o programa final

Pode adaptar ainda mais o comportamento de um comando empregando o método de opção em conjunto com a definição do comando, ligando-os efetivamente através desta técnica conhecida como “encadeamento”.

Para incorporar exemplos ilustrativos nas explicações verbais do vocabulário, pode-se seguir este procedimento:

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

Eis uma forma de especificar uma opção que determina o número de definições a devolver:

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

O método que permite selecionar entre uma série de alternativas utiliza duas cadeias de caracteres como entrada, uma das quais representa a designação da escolha, tanto em formato conciso como alargado, enquanto a segunda representa a exposição que a acompanha. Adicionalmente, um parâmetro opcional denotado por “count” especifica o número correspondente à quantidade necessária de sinopses a serem exibidas.

O último método a incorporar na nossa implementação é o método action , que serve para executar as operações inerentes ao comando find . Ao incluir este método na nossa base de código, podemos garantir que o nosso programa adere a uma estrutura semelhante ao modelo fornecido. Consequentemente, a configuração resultante do nosso código apresentará um formato semelhante ao seguinte:

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

Incorporando a configuração fornecida, a execução de um pedido de três instâncias de “lol” juntamente com as ilustrações correspondentes pode assemelhar-se ao seguinte:

 urbanary-cli find lol -e -c 3

Uma abordagem alternativa para resolver esse problema poderia ser explorar uma perspetiva ou estratégia diferente para lidar com ele. Uma possibilidade é considerar outras opções disponíveis que possam proporcionar resultados mais favoráveis do que os que estão a ser seguidos atualmente. Isto pode implicar a procura de informações adicionais sobre potenciais soluções ou a consulta de especialistas em domínios relevantes que possam oferecer ideias e recomendações valiosas. Ao tomar estas medidas, podemos esforçar-nos por obter melhores resultados, evitando as consequências negativas associadas ao nosso curso de ação atual.

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

Confira a página npm do Commander para saber mais sobre ele e como adaptar suas funções para seus diferentes casos de uso.

Implementando a funcionalidade do programa

Incorpore a biblioteca Axios no arquivo index.js utilizando as seguintes etapas:

 const axios = require('axios');

Dentro dos parâmetros funcionais do método do objeto “action”, é possível incorporar o código necessário para interagir com o Urban Dictionary e apresentar os resultados com base em preferências predeterminadas.

Comece por definir o seu pedido:

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

Para aceder à API através do Axios, pode utilizar a seguinte linha de código: javascriptaxios.get(’ https://api.example.com/data’).then(response => {// tratar os dados da resposta aqui}).catch(error => {// tratar o erro aqui});

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

Uma das principais informações que necessitamos dos dados da resposta é a propriedade enumerable, que contém uma coleção de definições e ilustrações.

Incorpore o seguinte trecho de código num bloco de tentativas existente, assegurando que trata a entrada de opções e apresenta o resultado correspondente em conformidade:

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

O código atual analisa os comandos de entrada utilizando instruções condicionais para determinar o método mais adequado para apresentar os resultados. No caso de serem fornecidos os parâmetros que incluem uma instância ilustrativa, um carácter delimitador e uma opção de contagem, o programa irá iterar sobre os dados relativos a palavras individuais e imprimir o número necessário de instâncias de definição e amostra em conformidade.

A função apresenta um determinado número de definições e/ou exemplos com base na entrada do utilizador. Se for passado apenas “count”, será apresentado esse número específico de definições sem exemplos. Do mesmo modo, se passar “example” como argumento, apresentará uma definição juntamente com uma frase de exemplo. No caso de não ser especificada nenhuma opção, o comportamento predefinido será o de apresentar simplesmente a definição.

Para tornar a aplicação executável, comece por incorporar uma linha shebang no início do ficheiro bin/index.js, permitindo o seu funcionamento como um script independente.

 #!/usr/bin/env node 

Em seguida, navegue até o arquivo package.json no diretório do projeto e modifique o conteúdo da propriedade main . Além disso, anexe uma nova propriedade bin após a existente, conforme ilustrado abaixo:

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

Em essência, o ponto crucial da execução de um projeto baseado na urbanary-cli reside no comando introduzido através do terminal. Consequentemente, é imperativo que se empregue um título apropriado para esse comando enquanto se desenvolvem aplicações de linha de comandos.

Para instalar com sucesso a aplicação globalmente usando o npm, deve ser executado o comando “npm install -g” no seu terminal. Esta ação permitirá a execução da aplicação como um comando a partir do mesmo terminal.

A ilustração apresentada mostra o procedimento de instalação e execução de um comando de diagnóstico para verificar o objetivo do módulo lmk.

Publicar o seu trabalho no registo npm (Node Package Manager) é um processo simples que permite uma distribuição generalizada e uma instalação fácil do seu projeto. Para isso, navegue até a pasta raiz do seu projeto e execute o comando “npm publish” no terminal. Ao fazê-lo, o seu projeto estará disponível para que outros o instalem facilmente através do comando “npm install”.

A utilização do Node.js facilita o desenvolvimento e a disseminação de aplicações, em vez de utilizar Rust ou tecnologias semelhantes para construir interfaces de linha de comandos.

Construa aplicações CLI funcionais com o Node.js

De facto, para aqueles envolvidos no desenvolvimento de um pacote npm que requer um utilitário de linha de comandos complementar, ou para os programadores que procuram melhorar o seu fluxo de trabalho através da criação de ferramentas personalizadas, o pacote Node.js Commander oferece uma solução abrangente para concretizar a sua visão.

É possível aumentar a experiência do utilizador de interfaces de linha de comandos nas suas aplicações através da utilização de bibliotecas adicionais com facilidade devido à versatilidade e estabilidade inerentes fornecidas pelo Node.js, que serve como uma base fiável para tais empreendimentos sem complicações significativas.