Base de Conhecimento

Introdução

O Node.js é um ambiente de tempo de execução de código aberto popular que pode executar JavaScript fora do navegador usando o mecanismo JavaScript V8, que é o mesmo mecanismo usado para alimentar a execução JavaScript do navegador da web do Google Chrome. O tempo de execução do Nó é comumente usado para criar ferramentas de linha de comando e servidores da web.

Aprender o Node.js permitirá que você escreva seu código de front-end e back-end no mesmo idioma. O uso de JavaScript em toda a pilha pode ajudar a reduzir o tempo para alternância de contexto, e as bibliotecas são mais facilmente compartilhadas entre o servidor back-end e os projetos front-end.

Além disso, graças ao seu suporte à execução assíncrona, o Node.js se destaca em tarefas intensivas de E / S, o que o torna tão adequado para a web. Aplicativos em tempo real, como streaming de vídeo ou aplicativos que enviam e recebem dados continuamente, podem ser executados com mais eficiência quando escritos em Node.js.

Neste tutorial, você criará seu primeiro programa com o tempo de execução do Node.js. Você será apresentado a alguns conceitos específicos do Nó e poderá criar um programa que ajude os usuários a inspecionar variáveis ​​de ambiente em seus sistemas. Para fazer isso, você aprenderá como enviar seqüências de caracteres para o console, receber entrada do usuário e acessar variáveis ​​de ambiente.

Pré-requisitos

Para concluir este tutorial, você precisará de:

• Node.js instalado em sua máquina de desenvolvimento. Este tutorial usa o Node.js. versão 10.16.0. Para instalar isso no macOS ou no Ubuntu 18.04, siga as etapas em Como instalar o Node.js e criar um ambiente de desenvolvimento local no macOS ou na seção "Instalando usando um PPA" de Como instalar o Node.js. no Ubuntu 18.04 .

• Um conhecimento básico de JavaScript, que você pode encontrar aqui: Como codificar em JavaScript

Etapa 1 - Saída para o console

Para escrever um programa "Olá, Mundo!", Abra um editor de texto de linha de comando como nanoe crie um novo arquivo:

• nano hello.js

Com o editor de texto aberto, digite o seguinte código:

console.log("Hello World");

O consoleobjeto no Node.js fornece métodos simples para gravar em stdout, stderrou em qualquer outro fluxo do Node.js., que na maioria dos casos é a linha de comando. O logmétodo é impresso no stdoutfluxo, para que você possa vê-lo no seu console.

No contexto do Node.js, os fluxos são objetos que podem receber dados, como o stdoutfluxo, ou objetos que podem gerar dados, como um soquete de rede ou um arquivo. No caso dos fluxos stdoute stderr, quaisquer dados enviados a eles serão mostrados no console. Uma das grandes vantagens dos fluxos é que eles são facilmente redirecionados; nesse caso, você pode redirecionar a saída do seu programa para um arquivo, por exemplo.

Salve e saia nanopressionando CTRL+X, quando solicitado a salvar o arquivo, pressione Y. Agora seu programa está pronto para ser executado.

Etapa 2 - Executando o programa

Para executar este programa, use o nodecomando da seguinte maneira:

• node hello.js

O hello.jsprograma executará e exibirá a seguinte saída:

 Hello World

O intérprete Node.js lê o arquivo e é executado console.log("Hello World");chamando o logmétodo do consoleobjeto global . A cadeia "Hello World"foi passada como argumento para a logfunção.

Embora as aspas sejam necessárias no código para indicar que o texto é uma sequência, elas não são impressas na tela.

Depois de confirmar que o programa funciona, vamos torná-lo mais interativo.

Etapa 3 - Recebendo entrada do usuário por meio de argumentos da linha de comando

Toda vez que você executa o programa "Hello, World!" Do Node.js, ele produz a mesma saída. Para tornar o programa mais dinâmico, vamos receber informações do usuário e exibi-las na tela.

As ferramentas de linha de comando geralmente aceitam vários argumentos que modificam seu comportamento. Por exemplo, executar nodeo --versionargumento imprime a versão instalada em vez de executar o intérprete. Nesta etapa, você fará seu código aceitar a entrada do usuário por meio de argumentos da linha de comando.

Crie um novo arquivo arguments.jscom o nano:

• nano arguments.js

Digite o seguinte código:

console.log(process.argv);

O processobjeto é um objeto Node.j global que contém funções e dados, todos relacionados ao processo Node.js. atualmente em execução. A argvpropriedade é uma matriz de seqüências de caracteres que contém todos os argumentos de linha de comando fornecidos a um programa.

Salve e saia nanodigitando CTRL+X, quando solicitado a salvar o arquivo, pressione Y.

Agora, quando você executa este programa, fornece um argumento de linha de comando como este:

• node arguments.js hello world

A saída é semelhante à seguinte:

 [ '/usr/bin/node',
  '/home/sammy/first-program/arguments.js',
  'hello',
  'world' ]

O primeiro argumento na process.argvmatriz é sempre o local do binário do Node.js. que está executando o programa. O segundo argumento é sempre o local do arquivo que está sendo executado. Os argumentos restantes são os que o usuário digitou, neste caso: helloe world.

Estamos interessados ​​principalmente nos argumentos que o usuário inseriu, não nos argumentos padrão que o Node.js fornece. Abra o arguments.jsarquivo para edição:

• nano arguments.js

Mude console.log(process.arg);para o seguinte:

console.log(process.argv.slice(2));

Por argvser uma matriz, você pode usar o slicemétodo interno do JavaScript que retorna uma seleção de elementos. Quando você fornece a slicefunção 2como argumento, obtém todos os elementos argvque vêm após o segundo elemento; isto é, os argumentos que o usuário inseriu.

Execute o programa novamente com o nodecomando e os mesmos argumentos da última vez:

• node arguments.js hello world

Agora, a saída fica assim:

 [ 'hello', 'world' ]

Agora que você pode coletar informações do usuário, vamos coletar informações do ambiente do programa.

Etapa 4 - Acessando variáveis ​​de ambiente

As variáveis ​​de ambiente são dados de valor-chave armazenados fora de um programa e fornecidos pelo sistema operacional. Eles geralmente são definidos pelo sistema ou usuário e estão disponíveis para todos os processos em execução para fins de configuração ou estado. Você pode usar o processobjeto do Node para acessá-los.

Use nanopara criar um novo arquivo environment.js:

• nano environment.js

Adicione o seguinte código:

console.log(process.env);

O envobjeto armazena todas as variáveis ​​de ambiente disponíveis quando o Node.js está executando o programa.

Salve e saia como antes e execute o environment.jsarquivo com o nodecomando

• node environment.js

Ao executar o programa, você verá uma saída semelhante à seguinte:

{ SHELL: '/bin/bash',
  SESSION_MANAGER:
   'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003',
  COLORTERM: 'truecolor',
  SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh',
  XMODIFIERS: '@im=ibus',
  DESKTOP_SESSION: 'ubuntu',
  SSH_AGENT_PID: '1150',
  PWD: '/home/sammy/first-program',
  LOGNAME: 'sammy',
  GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1',
  GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG',
  WINDOWPATH: '2',
  HOME: '/home/sammy',
  USERNAME: 'sammy',
  IM_CONFIG_PHASE: '2',
  LANG: 'en_US.UTF-8',
  VTE_VERSION: '5601',
  CLUTTER_IM_MODULE: 'xim',
  GJS_DEBUG_OUTPUT: 'stderr',
  LESSCLOSE: '/usr/bin/lesspipe %s %s',
  TERM: 'xterm-256color',
  LESSOPEN: '| /usr/bin/lesspipe %s',
  USER: 'sammy',
  DISPLAY: ':0',
  SHLVL: '1',
  PATH:
   '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin',
  DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus',
  _: '/usr/bin/node',
  OLDPWD: '/home/sammy' }

Lembre-se de que muitas das variáveis ​​de ambiente que você vê dependem da configuração do sistema e sua saída pode parecer substancialmente diferente da que você vê aqui. Em vez de visualizar uma longa lista de variáveis ​​de ambiente, convém recuperar uma específica.

Etapa 5 - Acessando uma variável de ambiente especificada

Nesta etapa, você visualizará variáveis ​​de ambiente e seus valores usando o process.envobjeto global e imprimirá seus valores no console.

O process.envobjeto é um mapeamento simples entre nomes de variáveis ​​de ambiente e seus valores armazenados como seqüências de caracteres. Como todos os objetos em JavaScript, você acessa uma propriedade individual referenciando seu nome entre colchetes.

Abra o environment.jsarquivo para edição:

• nano environment.js

Mude console.log(process.env);para:

console.log(process.env["HOME"]);

Salve o arquivo e saia. Agora execute o environment.jsprograma:

• node environment.js

A saída agora fica assim:

 /home/sammy

Em vez de imprimir o objeto inteiro, agora você imprime apenas a HOMEpropriedade de process.env, que armazena o valor da $HOMEvariável de ambiente.

Novamente, lembre-se de que a saída desse código provavelmente será diferente da que você vê aqui, porque é específica para o seu sistema. Agora que você pode especificar a variável de ambiente a recuperar, pode aprimorar seu programa solicitando ao usuário a variável que deseja ver.

Etapa 6 - Recuperando um argumento em resposta à entrada do usuário

Em seguida, você poderá ler argumentos da linha de comando e variáveis ​​de ambiente para criar um utilitário de linha de comando que imprima o valor de uma variável de ambiente na tela.

Use nanopara criar um novo arquivo echo.js:

• nano echo.js

Adicione o seguinte código:

const args = process.argv.slice(2);
console.log(process.env[args[0]]);

A primeira linha de echo.jsarmazena todos os argumentos de linha de comando que o usuário forneceu em uma variável constante chamada args. A segunda linha imprime a variável de ambiente armazenada no primeiro elemento de args; isto é, o primeiro argumento da linha de comandos que o usuário forneceu.

Salve e saia e nano, em seguida, execute o programa da seguinte maneira:

• node echo.js HOME

Agora, a saída seria:

 /home/sammy

O argumento HOMEfoi salvo na argsmatriz, que foi usada para encontrar seu valor no ambiente por meio do process.envobjeto.

Neste ponto, agora você pode acessar o valor de qualquer variável de ambiente em seu sistema. Para verificar isso, tente visualizar as seguintes variáveis: PWD, USER, PATH.

Recuperar variáveis ​​únicas é bom, mas permitir que o usuário especifique quantas variáveis ​​ele deseja seria melhor.

Etapa 7 - Vendo várias variáveis ​​de ambiente

Atualmente, o aplicativo pode inspecionar apenas uma variável de ambiente por vez. Seria útil se pudéssemos aceitar vários argumentos de linha de comando e obter seu valor correspondente no ambiente. Use nanopara editar echo.js:

• nano echo.js

Edite o arquivo para que ele tenha o seguinte código:

const args = process.argv.slice(2);

args.forEach(arg => {
  console.log(process.env[arg]);
});

O forEachmétodo é um método JavaScript padrão em todos os objetos de matriz. Ele aceita uma função de retorno de chamada que é usada porque itera sobre todos os elementos da matriz. Você usa forEachna argsmatriz, fornecendo uma função de retorno de chamada que imprime o valor do argumento atual no ambiente.

Salve e saia do arquivo. Agora execute novamente o programa com dois argumentos:

• node echo.js HOME PWD

Você veria a seguinte saída:

 /home/sammy
/home/sammy/first-program

A forEachfunção garante que todos os argumentos de linha de comando na argsmatriz sejam impressos.

Agora você tem uma maneira de recuperar as variáveis ​​solicitadas pelo usuário, mas ainda precisamos lidar com o caso em que o usuário insere dados incorretos.

Etapa 8 - Manipulação de entrada indefinida

Para ver o que acontece se você der ao programa um argumento que não é uma variável de ambiente válida, execute o seguinte:

• node echo.js HOME PWD NOT_DEFINED

A saída será semelhante à seguinte:

 /home/sammy
/home/sammy/first-program
undefined

As duas primeiras linhas são impressas conforme o esperado e a última linha apenas undefined. Em JavaScript, um undefinedvalor significa que uma variável ou propriedade não recebeu um valor atribuído. Como NOT_DEFINEDnão é uma variável de ambiente válida, é mostrada como undefined.

Seria mais útil para um usuário ver uma mensagem de erro se o argumento da linha de comando não fosse encontrado no ambiente.

Aberto echo.jspara edição:

• nano echo.js

Edite echo.jspara que ele tenha o seguinte código:

const args = process.argv.slice(2);

args.forEach(arg => {
  let envVar = process.env[arg];
  if (envVar === undefined) {
    console.error(`Could not find "${arg}" in environment`);
  } else {
    console.log(envVar);
  }
});

Aqui, você modificou a função de retorno de chamada fornecida forEachpara fazer o seguinte:

1. Obtenha o valor do argumento da linha de comandos no ambiente e armazene-o em uma variável envVar.
2. Verifique se o valor de envVaré undefined.
3. Se envVarfor undefined, imprimiremos uma mensagem útil indicando que ela não foi encontrada.
4. Se uma variável de ambiente foi encontrada, imprimimos seu valor.

Nota : A console.errorfunção imprime uma mensagem na tela via stderrfluxo, enquanto console.logimprime na tela através do stdoutfluxo. Ao executar esse programa pela linha de comando, você não notará a diferença entre os fluxos stdoute stderr, mas é uma boa prática imprimir erros por meio do stderrfluxo, para que possam ser mais facilmente identificados e processados ​​por outros programas, o que pode indicar ao diferença.

Agora execute o seguinte comando mais uma vez:

• node echo.js HOME PWD NOT_DEFINED

Desta vez, a saída será:

 /home/sammy
/home/sammy/first-program
Could not find "NOT_DEFINED" in environment

Agora, quando você fornece um argumento de linha de comando que não é uma variável de ambiente, você recebe uma mensagem de erro clara afirmando isso.

Conclusão

Seu primeiro programa exibiu “Hello World” na tela e agora você gravou um utilitário de linha de comando do Node.js. que lê os argumentos do usuário para exibir variáveis ​​de ambiente.

Se você quiser levar isso adiante, pode alterar ainda mais o comportamento deste programa. Por exemplo, convém validar os argumentos da linha de comando antes de imprimir. Se um argumento não estiver definido, você poderá retornar um erro e o usuário obterá a saída apenas se todos os argumentos forem variáveis ​​de ambiente válidas.