Aprenda como construir um programa com uma interface de linha de comando padrão usando esta biblioteca útil.

Os aplicativos CLI (Command Line Interface) são aplicativos simplistas baseados em texto que são executados no terminal para concluir tarefas específicas. Os aplicativos CLI desempenham um papel crucial no fluxo de trabalho de quase todos os desenvolvedores e profissionais de TI.

São principalmente ferramentas utilitárias que interagem com o sistema operacional ou aplicativos que são instalado localmente ou disponível na Internet para executar uma tarefa de acordo com a entrada do usuário e diretivas.

Compreendendo os aplicativos CLI

Uma interface de linha de comando permite interagir com um programa digitando linhas de texto. Muitos programas CLI são executados de maneira diferente dependendo do comando usado para iniciá-los.

Por exemplo, o programa ls exibe informações do arquivo e o conteúdo dos diretórios. Você pode executá-lo assim:

ls -l /home

Este comando inclui:

  • O nome do programa: eu.
    • instagram viewer
  • Uma opção (ou bandeira). Nesse caso, -eu é uma opção que é a abreviatura de “long” e produz informações mais detalhadas.
  • Um argumento, /home. Aqui, o argumento especifica um caminho para o diretório para o qual mostrar informações.

Embora cada programa possa definir sua própria interface de linha de comando, certos elementos são comuns e amplamente utilizados. Você deve seguir esses padrões para que alguém familiarizado com uma interface de linha de comando possa usar seus programas facilmente.

O que é Commander.js?

Commander.js é um pacote que permite criar aplicativos CLI em Node.js. Possui uma rica biblioteca de recursos que permitem construir um aplicativo CLI padrão, realizando grande parte do trabalho pesado. Você só precisa definir comandos, opções e funcionalidades para seu aplicativo CLI.

Combinando-o com outros pacotes, como Chalk.js para estilização, você pode criar rapidamente um aplicativo CLI totalmente funcional em Node.js.

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

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

Crie uma nova pasta e inicialize um novo projeto Node.js com os seguintes comandos:

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

Esta CLI usará Axios para enviar solicitações HTTP para a API do Dicionário Urbano. Você pode usar API rápida para verificar endpoints e visualizar credenciais.

Uma CLI simples com um subcomando e ajuda

Para começar a construir sua CLI, instale o Commander e o Axios com o seguinte comando:

npm install commander axios

Criar uma nova pasta, caixa, no diretório do seu projeto e um novo arquivo vazio, index.js:

mkdir bin
cd bin
touch index.js

O caixa (abreviação de "binário") é importante porque contém o arquivo de ponto de entrada que o Node chama quando você executa sua CLI. O index.js file é este arquivo de ponto de entrada. Agora, edite o arquivo index.js e comece a construir sua CLI com a API Commander.js.

Primeiro, importe o programa objeto do Comandante:

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

Você usará o programa objeto para definir a interface do seu programa, incluindo subcomandos, opções e argumentos. O objeto possui métodos correspondentes para cada um deles; por exemplo, para definir um subcomando, use o comando método.

Defina um encontrar subcomando para a CLI procurar palavras no Urban Dictionary e adicionar uma descrição usando o código abaixo:

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

Isso registra um encontrar comando, que espera uma palavra depois dele e uma descrição para ele. O uso de colchetes angulares significa que a palavra é um argumento obrigatório; use colchetes em vez disso ([]) para torná-lo opcional.

Você deve adicionar uma descrição porque Commander.js a utiliza para gerar texto de ajuda. Ao executar o aplicativo com o ajuda comando, você receberá um guia de uso padrão.

Para testar isso, adicione o seguinte:

program.parse()

Em seguida, execute o programa e passe-o para ajuda comando para obter a saída abaixo:

É assim que qualquer aplicativo CLI padrão exibirá sua ajuda aos usuários e, com o Commander, você não precisa se preocupar em criá-lo sozinho. O -h e --ajuda opções são úteis para verificar o guia de uso de um comando.

Definir Opções e Preparar o Programa Final

Você também define uma opção encadeando o opção método para a definição do comando.

Veja como definir uma opção para incluir exemplos nas definições de palavras:

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

E aqui está como definir uma opção especificando o número de definições a serem retornadas:

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

O opção O método aceita dois parâmetros de string, um para o nome da opção (formato curto e longo) e outro para sua descrição. O Extra [quantia] argumento no contar opção é o valor do número de definições a serem exibidas.

Agora, o último método a adicionar é o Ação método. Você implementará o encontrar funcionalidade do comando neste método. Adicione-o à cadeia para que seu código fique assim:

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

Com esta configuração, aqui está um comando para obter três definições de lol com exemplos será semelhante a:

urbanary-cli find lol -e -c 3

Ou, usando o formato longo de cada opção:

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

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

Implementando a Funcionalidade do Programa

Primeiro, importe o Axios para o seu index.js arquivo da seguinte forma:

const axios = require('axios');

Então, no corpo funcional de Ação, você pode implementar a lógica para fazer solicitações ao Urban Dictionary e exibir os resultados de acordo com suas opções.

Comece definindo sua solicitação:

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

Em seguida, faça a solicitação à API usando Axios com o seguinte código:

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

A única propriedade necessária dos dados de resposta é a lista propriedade que contém definições e exemplos.

Ainda no tentar bloco, adicione esta lógica para lidar com opções e exibir os resultados da seguinte forma:

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

Este código avalia os argumentos do comando usando instruções if-else para determinar como exibir a saída. Se o exemplo e contar opções são passadas, ele itera palavraDados e imprime o número especificado de definições e exemplos com eles.

Se você passar apenas contar, ele exibe essa quantidade de definições sem exemplos. Se você passar apenas exemplo, ele exibe uma definição com uma frase de exemplo. O outro instrução é o comportamento padrão para imprimir apenas a definição se você não passar nenhuma opção.

O aplicativo agora está pronto, então o próximo passo é torná-lo executável. Comece adicionando uma linha shebang ao início do seu arquivo bin/index.js para que você possa executá-lo como um script independente:

#!/usr/bin/env node

A seguir, abra seu pacote.json arquivo, edite o valor do principal propriedade e adicione um caixa propriedade depois dela assim:

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

A chave urbanary-cli, sob caixa é o comando que você inserirá em seu terminal para executar seu aplicativo. Portanto, certifique-se de usar um nome adequado ao criar seus aplicativos de linha de comando.

Correr npm instalar -g para instalar o aplicativo globalmente e você poderá executar o aplicativo como um comando do seu terminal.

A imagem abaixo mostra o processo de instalação e um comando de teste para descobrir o significado de escute:

Você também pode publicá-lo no registro do pacote npm executando publicação npm no terminal dentro do diretório do projeto. Isso o torna instalável por qualquer pessoa em qualquer lugar usando instalação npm.

É mais fácil construir e publicar seu aplicativo com Node.js, em comparação com quando você construir CLIs com tecnologias como Rust.

Crie aplicativos CLI funcionais com Node.js

Esteja você trabalhando em um pacote npm e precise de um utilitário CLI para acompanhá-lo ou apenas queira construir uma ferramenta para melhorar seu fluxo de trabalho como desenvolvedor. Você tem tudo o que precisa para dar vida à sua ideia com o pacote Node.js Commander.

Você também pode ir além usando outras bibliotecas para criar experiências CLI aprimoradas para seus aplicativos. O Node.js é robusto o suficiente para atender aos seus propósitos sem muitos problemas.