Guia do Node.js, parte 3: hospedagem, REPL, operações de console, módulos

Aqui está a terceira parte da tradução do manual Node.js. Hoje, falaremos sobre a escolha de uma hospedagem para projetos Node.js., como trabalhar com Node.js. no modo REPL e como executar scripts com argumentos, como interagir com o console e os módulos.

Hospedagem para aplicativos Node.js.

A escolha da hospedagem para aplicativos Node.js depende de suas necessidades. Aqui está uma pequena lista de opções de hospedagem que você pode explorar ao decidir implantar seu aplicativo e torná-lo disponível ao público. Primeiro, considere opções simples, cujos recursos são limitados e depois mais complexos, mas também com recursos mais sérios.

OptionA opção mais fácil de hospedagem: túnel local

Mesmo se um endereço IP dinâmico estiver atribuído ao seu computador ou você estiver atrás do NAT, poderá implantar seu aplicativo nele e atender a solicitações de usuários usando um túnel local.

Essa opção é adequada para organizar rapidamente os testes, para organizar uma demonstração do produto ou para dar acesso ao aplicativo a um grupo muito pequeno de pessoas.

Existe um serviço muito bom para organizar túneis locais, ngrok , disponível para muitas plataformas.

Usando o ngrok, basta executar um comando no formato ngrok PORT e a porta que você especificou estará acessível na Internet. Ao mesmo tempo, se você usar a versão gratuita do serviço, terá um endereço no domínio ngrok.io . Se você decidir obter uma assinatura paga, poderá usar seus próprios nomes de domínio e, além disso, aumentar a segurança da solução (usando o ngrok, você abre o acesso ao seu computador em toda a Internet).

Outra ferramenta que pode ser usada para organizar túneis locais é chamada de túnel local .

Ambientes para implantar projetos Node.js que não requerem configuração

Glitch

O Glitch é um ambiente interativo e uma plataforma para o rápido desenvolvimento de aplicativos que permite implantá-los nos subdomínios glitch.com. Essa plataforma ainda não suporta seus próprios domínios de usuário, existem algumas limitações ao trabalhar com ela, mas é ótima para trabalhar em protótipos de aplicativos. O design do Glitch parece bem engraçado (talvez isso possa ser explicado pelas vantagens desta plataforma), mas esse não é um tipo de ambiente de "brinquedo" que é muito limitado. Aqui você tem a oportunidade de trabalhar com o Node.js, CDN, um repositório seguro de informações confidenciais, a capacidade de trocar dados com o GitHub e muito mais.

O projeto Glitch é executado pela mesma empresa por trás do FogBugz e Trello (um dos criadores do StackOverflow). Costumo usar essa plataforma para demonstrar aplicativos.

Codepen

Codepen é uma ótima plataforma em torno da qual uma comunidade interessante se formou. Aqui você pode criar projetos que incluem muitos arquivos e implantá-los usando seu próprio domínio.

Environments Ambientes sem servidor

As plataformas sem servidor permitem publicar aplicativos sem pensar completamente em servidores, em configurá-los ou em gerenciá-los. O paradigma da computação sem servidor é que os aplicativos são publicados como funções que respondem às chamadas para um terminal de rede. Uma abordagem semelhante à implantação de aplicativos também é chamada FAAS (funções como serviço, função como serviço).

Aqui estão algumas soluções populares nessa área:

• Estrutura sem servidor .
• Biblioteca padrão .

Ambos os projetos fornecem ao desenvolvedor um certo nível de abstração, o que permite publicar aplicativos em várias plataformas FAAS, por exemplo, Amazon AWS Lambda, Microsoft Azure e Google Cloud.

Soluções ASPAAS

PAAS (Plataforma como serviço, Plataforma como serviço) são plataformas que cuidam de muitas coisas que, em circunstâncias normais, devem ser cuidadas pelo desenvolvedor que está implantando o aplicativo.

Zeit Now

Zeit é uma opção interessante para implantar aplicativos. A implantação, usando essa plataforma, resume-se a inserir o comando now no terminal. Existe uma versão gratuita do Zeit, existem algumas restrições ao trabalhar com ele. Há também uma versão paga e mais poderosa desta plataforma. Usando o Zeit, você simplesmente não consegue pensar no fato de que seu aplicativo precisa de um servidor. Você simplesmente implanta o aplicativo e tudo o mais é gerenciado por esta plataforma.

Nanobox

Os criadores da plataforma Nanobox , que inclui a implantação de aplicativos Node.js, chamam de PAAS V2.

Heroku

Heroku é outra ótima plataforma para hospedagem de aplicativos Node.js. Aqui está um bom artigo sobre como trabalhar com ele.

Microsoft azure

O Azure é uma plataforma em nuvem da Microsoft. Sua documentação possui uma seção sobre aplicativos Node.js.

Google Cloud Platform

O Google Cloud é um ótimo ambiente para implantar aplicativos Node.js. Aqui está a seção relevante de sua documentação.

Hospedagem PSVPS

Existem muitas plataformas que fornecem serviços de hospedagem VPS . Um recurso comum dessas plataformas é o fato de o desenvolvedor ter à sua disposição um servidor virtual, instalar independentemente um sistema operacional (Linux ou Windows) e implantar aplicativos de forma independente.

Entre as plataformas que fornecem serviços VPS, das quais existem muitas, podemos observar o seguinte, que usei e que recomendo a outras pessoas:

• Oceano digital
• Linode
• Amazon Web Services (em particular, gostaria de mencionar o AWS Elastic Beanstalk , que facilita a implantação de aplicativos e o gerenciamento de recursos da AWS).

Por conta própria, acrescentamos que o RUVDS também fornece serviços de hospedagem VPS. Somos licenciados pela FSTEC, nossos clientes são segurados pela AIG, temos quatro centros de dados em diferentes países. Há seu próprio datacenter RUCLOUD nível TIER 3 na cidade de Korolev, região de Moscou, bem como zonas de pressão nos datacenters Deltalis (Suíça) , London Equinix LD8 (Grã-Bretanha) e MMTS-9 (Moscou, Rússia). Todas as zonas de contenção atendem a um nível de confiabilidade de pelo menos o NÍVEL 3.

Os parceiros da empresa são FINAM JSC, grupo financeiro BCS, National Settlement Depository (Moscow Exchange), VTsIOM JSC, empresa Gars-Telecom, operador de táxi Gett, operador de entrega do Clube de Entrega e muitos outros.

Servidor normal

Outra solução de hospedagem é comprar (ou alugar, por exemplo, usando o serviço Vultr Bare Metal ) um servidor comum, instalar o Linux e outros softwares nele, conectá-lo à Internet e hospedar aplicativos Node.js.

A hospedagem é um tópico importante, mas, esperançosamente, os materiais nesta seção permitirão que você escolha exatamente o que precisa. Agora, passamos à história sobre como trabalhar com o Node.js no modo REPL.

Usando o Node.js no modo REPL

A abreviatura REPL significa Read-Evaluate-Print-Loop (ciclo "ler - calcular - saída"). Usar o REPL é uma ótima maneira de explorar rapidamente os recursos do Node.js.

Como você já sabe, o comando node é usado para executar scripts no Node.js, fica assim:

 node script.js 

Se você digitar o mesmo comando, mas não especificar um nome de arquivo, o Node.js será iniciado no modo REPL:

 node 

Se você tentar inserir agora um comando desse tipo no seu terminal, verá como resultado o seguinte:

 > node > 

O Node.js está agora no modo de espera. O sistema espera que insira algum código JavaScript na linha de comando que será executada.

Para começar, vamos tentar algo muito simples:

 > console.log('test') test undefined > 

Aqui sugerimos que o Node.js execute o comando usado para gerar dados para o console. O primeiro valor, test , é o que console.log('test') . O segundo valor, undefined , é o que a função console.log() retornou.

Após a conclusão do comando, o prompt REPL é exibido, o que significa que podemos inserir um novo comando aqui.

CommandsConfigure comandos usando a tecla Tab

O REPL é um ambiente interativo. Se você pressionar a tecla Tab teclado enquanto escreve o código, o REPL tentará concluir automaticamente a entrada selecionando, por exemplo, um nome adequado para a variável que você já declarou ou o nome de um objeto padrão.

Explorando objetos JavaScript

Digite o nome de algum objeto JavaScript padrão na linha de comando, por exemplo, Number , adicione um ponto após ele e pressione Tab .

O REPL listará as propriedades e métodos do objeto com o qual o desenvolvedor pode interagir:


Examinando o objeto numérico

PlExplorando objetos globais

Para descobrir com quais objetos globais do Node.js você pode trabalhar, digite o comando global. no terminal global. e pressione Tab .


Pesquisa Global de Objetos

▍ Variável especial _

A variável _ (sublinhado) armazena o resultado da última operação executada. Essa variável pode ser usada como parte dos comandos inseridos no console.

▍ Comandos começando com um ponto

No modo REPL, você pode usar alguns comandos especiais que começam com um ponto. Aqui estão elas:

• O comando .help exibe informações de referência para comandos que começam com um ponto.
• O comando .editor sistema no modo de editor, o que facilita a inserção de código JavaScript de várias linhas. Depois de entrar neste modo, você insere tudo o que deseja, para executar o código, use o comando Ctrl+D
• O comando .break permite interromper a entrada de expressão de várias linhas. Seu uso é semelhante ao uso do atalho de teclado Ctrl+C
• O comando .clear limpa o contexto REPL e também interrompe a entrada de uma expressão de várias linhas.
• O comando .load carrega o código de um arquivo JavaScript na sessão atual.
• O comando .save salva tudo o que foi inserido durante a sessão REPL no arquivo.
• O comando .exit permite que .exit saia de uma sessão REPL; ele atua exatamente como duas teclas consecutivas da combinação de teclas Ctrl+C

Deve-se notar que o REPL reconhece a entrada de expressões de várias linhas, mesmo sem usar o .editor .

Por exemplo, começamos a inserir um código de iterador:

 [1, 2, 3].forEach(num => { 

Se, depois de inserir a chave, pressione a tecla Enter , o REPL irá para uma nova linha, o prompt no qual parecerá três pontos. Isso indica que podemos inserir o código para o bloco correspondente. É assim:

 ... console.log(num) ... }) 

Pressionar Enter após inserir o último parêntese irá executar a expressão. Se você digitar .break neste modo, a entrada será abortada e a expressão não será executada.

O modo REPL é um recurso útil do Node.js, mas seu escopo é limitado a pequenas experiências. Estamos interessados ​​em algo mais do que a capacidade de executar alguns comandos. Portanto, passamos a trabalhar com o Node.js no modo normal. Ou seja, vamos falar sobre como os scripts do Node.js. podem receber argumentos de linha de comando.

Trabalhando com argumentos de linha de comando nos scripts do Node.js.

Ao executar scripts Node.js, os argumentos podem ser transmitidos a eles. Aqui está uma chamada de script regular:

 node app.js 

Os argumentos transmitidos para o script podem ser valores independentes ou construções de valor-chave. No primeiro caso, a execução do script é assim:

 node app.js flavio 

No segundo - assim:

 node app.js name=flavio 

O método de transmissão de argumentos é usado para determinar como você pode trabalhar com eles no código do script.

Portanto, para acessar os argumentos da linha de comando, o objeto de process Node.js. padrão é usado. Possui a propriedade argv , que é uma matriz que contém, entre outras coisas, os argumentos passados ​​para o script na inicialização.

O primeiro elemento da matriz argv contém o caminho completo para o arquivo que é executado quando o comando do node é inserido na linha de comandos.

O segundo elemento é o caminho para o script executável.

Todos os outros elementos da matriz, começando na terceira, contêm o que foi passado para o script quando foi executado.

A enumeração de argumentos disponíveis no argv (isso inclui o caminho para o node e o arquivo executável do script) pode ser organizada usando o loop forEach :

 process.argv.forEach((val, index) => { console.log(`${index}: ${val}`) }) 

Se você não estiver interessado nos dois primeiros argumentos, com base no argv poderá criar uma nova matriz que incluirá tudo do argv exceto os dois primeiros elementos:

 const args = process.argv.slice(2) 

Suponha que, ao executar um script, apenas um argumento tenha sido passado para ele, na forma de um valor independente:

 node app.js flavio 

Você pode acessar este argumento assim:

 const args = process.argv.slice(2) args[0] 

Agora vamos tentar usar uma construção de tipo de valor-chave:

 node app.js name=flavio 

Com essa abordagem, após a formação do array args , o name=flavio da string name=flavio em args[0] . Antes de usar o argumento, essa sequência deve ser analisada. A maneira mais conveniente de fazer isso é usar a biblioteca minimista , projetada para facilitar o trabalho com argumentos de linha de comando:

 const args = require('minimist')(process.argv.slice(2)) args['name'] //flavio 

Agora considere a saída para o console.

Saída de dados para o console usando o módulo do console

O módulo do console padrão do Node.js. oferece ao desenvolvedor muitas oportunidades para interagir com a linha de comando durante a execução do programa. Em geral, é o mesmo que o objeto do console usado no JavaScript baseado em navegador. Talvez o método mais simples e mais usado do módulo console seja console.log() , que é usado para enviar dados de cadeia para o console. Além disso, se você passar um objeto para ele, ele, antes da saída, será convertido em sua representação de string.

O método console.log() pode receber vários valores:

 const x = 'x' const y = 'y' console.log(x, y) 

Após executar esta sequência de instruções, o valor x e o valor y chegarão ao console.

Para formar cadeias complexas, o comando console.log() suporta o uso de curingas, que, ao enviar dados, são substituídos pelos valores correspondentes em ordem de prioridade.

Por exemplo, aqui está um comando que exibe o texto My cat has 2 years :

 console.log('My %s has %d years', 'cat', 2) 

Considere os recursos dos curingas:

• %s formata o valor como uma sequência.
• %d ou %i formata o valor como um número inteiro.
• %f formata o valor como um número de ponto flutuante.
• %O usado para exibir representações de string de objetos.

Aqui está outro exemplo de uso de curingas:

 console.log('%O', Number) 

▍Limpeza do console

Para limpar o console, use o comando console.clear() (seu comportamento em diferentes terminais pode variar).

OuntContando elementos

Agora, veremos o método console.count() útil. Dê uma olhada neste código:

 const x = 1 const y = 2 const z = 3 console.count( 'The value of x is ' + x + ' and has been checked .. how many times?' ) console.count( 'The value of x is ' + x + ' and has been checked .. how many times?' ) console.count( 'The value of y is ' + y + ' and has been checked .. how many times?' ) 

O método count() conta o número de saídas de linha e exibe o resultado próximo a elas.
Usando esse método, no exemplo a seguir, você pode contar maçãs e laranjas:

 const oranges = ['orange', 'orange'] const apples = ['just one apple'] oranges.forEach(fruit => { console.count(fruit) }) apples.forEach(fruit => { console.count(fruit) }) 

▍Exibindo resultados de rastreamento de pilha no console

Às vezes, é útil imprimir um rastreamento da pilha de funções no console. Por exemplo, para responder à pergunta de como chegamos a um determinado local do programa. Você pode fazer isso com o seguinte comando:

 console.trace() 

Aqui está um exemplo de seu uso:

 const function2 = () => console.trace() const function1 = () => function2() function1() 

Aqui está o que aconteceu quando eu executei esse código no modo REPL:

 Trace   at function2 (repl:1:33)   at function1 (repl:1:25)   at repl:1:1   at ContextifyScript.Script.runInThisContext (vm.js:44:33)   at REPLServer.defaultEval (repl.js:239:29)   at bound (domain.js:301:14)   at REPLServer.runBound [as eval] (domain.js:314:12)   at REPLServer.onLine (repl.js:440:10)   at emitOne (events.js:120:20)   at REPLServer.emit (events.js:210:7) 

EasComo medir o tempo necessário para concluir uma ação

Você pode medir o tempo que leva, por exemplo, para executar uma função, usando os métodos console.time() e console.timeEnd() . É assim:

 const doSomething = () => console.log('test') const measureDoingSomething = () => { console.time('doSomething()') //    ,     doSomething() console.timeEnd('doSomething()') } measureDoingSomething() 

OrkTrabalhando com stdout e stderr

Como vimos, o comando console.log() é ótimo para enviar mensagens para o console. Ao usá-lo, é utilizado o chamado fluxo de saída padrão, ou stdout .

O comando console.error() despeja dados no fluxo de erros padrão, stderr . Os dados enviados ao stderr chegam ao console, embora o que é produzido para esse fluxo possa, por exemplo, ser redirecionado para o arquivo de log de erros.

ColorUtilize cores ao enviar dados para o console

Para colorir os textos exibidos no console, você pode usar seqüências de escape que identificam cores:

 console.log('\x1b[33m%s\x1b[0m', 'hi!') 

Se você executar este comando, por exemplo, no modo REPL, o texto hi será exibido em amarelo.
Essa abordagem, no entanto, não é particularmente conveniente. Será conveniente usar uma biblioteca especializada, por exemplo, giz, para exibir texto colorido no console . Essa biblioteca, além da formatação de textos em cores, suporta outras formas de estilizá-los. Por exemplo, com sua ajuda, é possível criar o texto em negrito, itálico ou sublinhado.

Para instalá-lo a partir do npm, use o seguinte comando:

 npm install chalk 

Você pode usá-lo assim:

 const chalk = require('chalk') console.log(chalk.yellow('hi!')) 

Usar o comando chalk.yellow() é muito mais conveniente do que seqüências de escape, e o texto do programa com essa abordagem é muito mais fácil de ler.

Para saber mais sobre giz, consulte esta página da biblioteca no GitHub.

ReaCriar uma barra de progresso

A barra de progresso pode ser útil em diferentes situações. Você pode usar o pacote de progresso para criar indicadores de progresso em execução no console. Você pode instalá-lo assim:

 npm install progress 

Abaixo está um exemplo de código no qual é criado um indicador que pode ser usado para exibir informações sobre uma tarefa que consiste em 10 etapas. No nosso caso, são necessários 100 ms para concluir cada etapa. Depois que o indicador estiver cheio, o comando clearItnerval() é clearItnerval() e o programa termina.

 const ProgressBar = require('progress') const bar = new ProgressBar(':bar', { total: 10 }) const timer = setInterval(() => { bar.tick() if (bar.complete) {   clearInterval(timer) } }, 100) 

EceRecepção da entrada do usuário a partir da linha de comando

Como tornar interativos os aplicativos de linha de comando escritos para a plataforma Node.js. A partir da versão 7, o Node.js contém um módulo de linha de leitura que permite receber dados de fluxos que podem ser lidos, por exemplo, a partir de process.stdin . Esse encadeamento, durante a execução do programa Node.js., é o que é inserido no terminal. Os dados são inseridos uma linha por vez.

Considere o seguinte snippet de código:

 const readline = require('readline').createInterface({ input: process.stdin, output: process.stdout }) readline.question(`What's your name?`, (name) => { console.log(`Hi ${name}!`) readline.close() }) 

Aqui, solicitamos o nome do usuário e, depois de inserir o texto e pressionar a tecla Enter no teclado, exibimos uma saudação.

O método question() exibe o que é passado como o primeiro parâmetro (ou seja, a pergunta feita ao usuário) e aguarda a conclusão da entrada. Depois de pressionar Enter ele chama o retorno de chamada passado a ele no segundo parâmetro e processa o que foi inserido. No mesmo retorno de chamada, fechamos a interface readline .

readline , , .

, , , , , , — * .

, readline-sync , , readline , .

, . inquirer . :

 npm install inquirer 

:

 const inquirer = require('inquirer') var questions = [{ type: 'input', name: 'name', message: "What's your name?", }] inquirer.prompt(questions).then(answers => { console.log(`Hi ${answers['name']}!`) }) 

inquirer . , .

Node.js. readline , readline-sync inquirer. , , .

Node.js, exports

, API module.exports , . Node.js , . , require , :

 const library = require('./library') 

library.js , , , .

, , - , . , , . , API module.exports , .

.

module.exports , , . :

 const car = { brand: 'Ford', model: 'Fiesta' } module.exports = car //..   const car = require('./car') 

, exports . , , — :

 const car = { brand: 'Ford', model: 'Fiesta' } exports.car = car 

:

 exports.car = { brand: 'Ford', model: 'Fiesta' } 

, , :

 const items = require('./items') items.car 

:

 const car = require('./items').car 

module.exports exports ?

, module.exports . .

Node.js-, REPL, , Node.js. npm, , , package.json package-lock.json .

Caros leitores! Node.js-?