🐢 🙌 💔 Um guia para iniciantes do Node.js Parte 2 🕴🏿 🎒 🐻

Bom dia amigos

Eu continuo a postar uma tradução deste tutorial Node.js .

Outras partes:

Parte 1

Parte 2

Parte 3

Parte 4

Mecanismo JavaScript V8

V8 é o nome do mecanismo JavaScript suportado pelo Google Chrome. É isso que pega no seu código JavaScript e o executa no navegador.

Em outras palavras, V8 é um tempo de execução JavaScript. O DOM e outras APIs da web também são expostas pelo navegador.

O mecanismo JavaScript é independente do navegador. Foi isso que deu origem ao Node.js. A V8 foi escolhida como o mecanismo para o Node.js em 2009 e, com a crescente popularidade do Node.js., a V8 se tornou a base de muitos JavaScript do lado do servidor.

O ecossistema do Node.js. é enorme e, graças à V8, podemos criar aplicativos de desktop usando o Electron, por exemplo.

Outros mecanismos JS

Outros navegadores têm seus próprios mecanismos JavaScript:

Firefox - SpiderMonkey
Safari - JavaScriptCore (Nitro)
Edge - Chakra

etc.

Todos esses mecanismos implementam o padrão ECMA ES-262 (ECMAScript) , o padrão usado pelo JavaScript.

Sobre desempenho

V8 é escrito em C ++ e continua a evoluir. Funciona em todos os sistemas operacionais.

Não abordaremos as especificidades da implementação da V8: você pode encontrá-las aqui , elas mudam de tempos em tempos, muitas vezes radicalmente.

A V8 está em constante evolução, como outros mecanismos JavaScript, para melhorar a velocidade da Web e do ecossistema Node.js.

Há uma competição de desempenho na web que vem ocorrendo há anos, e nós (como usuários e desenvolvedores) aproveitamos bastante essa competição à medida que obtemos ferramentas mais rápidas e melhores a cada ano.

Compilação

O JavaScript geralmente é comercializado como uma linguagem interpretada, mas os mecanismos modernos não apenas interpretam o JavaScript, eles o compilam.

Isso acontece desde 2009, quando o compilador SpiderMonkey JavaScript foi adicionado no Firefox 3.5.

O JavaScript compila o V8 on-the-fly (just-in-time, JIT, compilação dinâmica) para acelerá-lo.

Pode parecer contra-intuitivo, mas com o advento do Google Maps em 2004, o JavaScript evoluiu de um idioma no qual pequenos blocos de código são gravados para um idioma no qual aplicativos completos são criados, consistindo em centenas ou milhares de linhas de código executadas no navegador.

Hoje, nossos aplicativos baseados em navegador podem funcionar por horas, não são mais ferramentas simples para resolver tarefas primitivas, como validação de formulários.

No mundo de hoje, compilar JavaScript faz sentido: embora leve mais tempo para preparar o código, seu desempenho excede significativamente o desempenho do código interpretado.

Executando scripts Node.js na linha de comandos

A maneira padrão de executar programas no Node.js é executar um comando global nodee passar o nome do arquivo executável.

Se o arquivo principal do seu aplicativo Node.js. tiver o nome app.js, você pode chamá-lo assim:

node app.js

Ao executar o comando especificado, verifique se você está no diretório com o arquivo app.js.

Como saio do Node.js?

Existem várias maneiras de parar um aplicativo Node.js.

Ao executar um programa pelo terminal, você pode fechá-lo ctrl-C, porém, vamos discutir as formas programáticas.

Vamos começar com o mais radical e falar sobre por que não deve ser usado.

O módulo principal (global, módulo do kernel) processfornece um método fácil de sair do aplicativo software-Node.js process.exit(). : .

Quando o Node.js atinge essa linha de código, o processo de execução do programa termina imediatamente.

Isso significa que todos os retornos de chamada em andamento, solicitações enviadas (pendentes), acesso aberto ao sistema de arquivos, gravações stdoutou stderr- todos eles serão interrompidos.

Se isso for aceitável para você, você pode passar exit()um número inteiro para o método - um sinal para concluir o código:

process.exit(1)

O código de saída padrão é 0, indicando sucesso. Diferentes códigos de saída têm significados diferentes; você pode usá-los para garantir que alguns programas interajam com outros.

Você pode ler mais sobre códigos de saída aqui .

Você também pode atribuir um valor apropriado à propriedade exitCode:

process.exitCode = 1

e após a conclusão do programa, o Node.js retornará esse código.

A execução do programa será encerrada suavemente quando todos os processos estiverem concluídos.

No Node.js, geralmente iniciamos o servidor:

const express = require('express')
const app = express()

app.get('/', (req, res) => {
    res.send('Hi!')
})

app.listen(3000, () => console.log('Server ready'))

Este programa nunca será encerrado. Se você ligar process.exit(), todas as solicitações pendentes ou em execução serão canceladas. Não é legal.

Nesse caso, é necessário enviar um comando de sinal SIGTERMe processá-lo usando um processador de sinal ( processnão é necessário conectar, ele está disponível por padrão):

const express = require('express')

const app = express()

app.get('/', (req, res) => {
    res.send('Hi!')
})

const server = app.listen(3000, () => console.log('Server ready'))

process.on('SIGTERM', () => {
    server.close(() => {
        console.log('Process terminated')
    })
})

O que são sinais? Os sinais são um sistema de comunicação POSIX: notificando um processo de que um evento ocorreu.

SIGKILL- sinalizar sobre a conclusão imediata do processo, semelhante process.exit().

SIGTERM- sinalizar sobre o final suave do processo. Este sinal pode ser enviado por um sistema de controle de processo, como upstart, supervisordetc.

Você pode enviar este sinal dentro do programa através de outra função:

process.kill(process.id, 'SIGTERM')

Ou de outro programa Node.js. ou qualquer outro aplicativo em execução no sistema, desde que eles conheçam o PID do processo que você deseja encerrar.

Como leio variáveis de ambiente no Node.js?

O módulo principal do Node.js. processpossui uma propriedade que envcontém todas as variáveis de ambiente definidas quando o processo é iniciado.

Aqui está um exemplo de acesso à variável de ambiente NODE_ENV configurada developmentcom o valor padrão:

process.env.NODE_ENV // development

Definir um valor em produção antes de executar o script informará ao Node.js que ele possui um ambiente de produção à sua frente.

De maneira semelhante, você pode acessar qualquer variável de ambiente definida.

Como usar o REPL do Node.js

O comando é nodeusado para executar scripts Node.js.

node script.js

Se omitirmos o nome do arquivo, entraremos no modo REPL:

node

O REPL (Executar avaliação de impressão em loop) é um ambiente de execução de código (geralmente uma janela de terminal) que pega uma expressão inserida pelo usuário e retorna o resultado da avaliação dessa expressão.

Se você entrar nodeno terminal, acontece o seguinte:

O terminal entrará no modo de espera.

Para ser mais preciso, o terminal, neste caso, aguarda a inserção de algum código JavaScript.

Vamos apresentar o seguinte:

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

O primeiro valor testé o que dissemos para enviar para o console e obtemos o undefinedvalor que a execução retornou, console.log()

depois podemos inserir outra coisa.

Use `tab`para preenchimento automático

O REPL é interativo.

Se pressionado tabao escrever o código, o REPL tentará concluir o que foi escrito, escolhendo entre variáveis definidas anteriormente ou predefinidas.

Objetos JavaScript

Tente digitar o nome da classe JavaScript, por exemplo Number, adicione um ponto a ela e clique em tab.

O REPL mostrará todas as propriedades e métodos desta classe:

Objetos Globais

Você pode obter uma lista de objetos globais digitando global.e pressionando tab:

Variável especial _

Se você digitar no final do código _, o resultado da última operação será exibido.

Comandos após o ponto

O REPL contém alguns comandos especiais começando com um ponto. Aqui estão eles:

.help - mostra uma lista de comandos disponíveis
.editor- inclui o modo de edição para escrever código JavaScript de várias linhas. Para executar o código neste modo, pressionectrl-D
.break- para de inserir o código de várias linhas. Semelhante a pressionarctrl-C
.clear - redefine o contexto REPL para um objeto vazio, exclui todo o código digitado
.load - carrega um arquivo JavaScript localizado no diretório atual (ativo)
.save - salva a sessão REPL em um arquivo com o nome especificado
.exit- saia do REPL. Igual ao toque duploctrl-C

O REPL entende que você está inserindo o código de várias linhas sem chamar .editor.

Por exemplo, se você começou a implementar a iteração:

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

e pressionado enter, o REPL pulará para uma nova linha com três pontos no início, indicando que você pode continuar trabalhando com o bloco de código:

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

Se você digitar .breakno final, o modo de discagem de código com várias linhas será interrompido e a expressão não será executada.

Passando argumentos usando a linha de comando

Ao iniciar um aplicativo Node.js., você pode transmitir qualquer número de argumentos para ele.

Os argumentos podem ser autônomos ou chave e valor.

Por exemplo:

node app.js joe

node app.js name=joe

Como você recupera o valor no código Node.js depende disso.

Um objeto interno é usado para recuperar valores process.

A propriedade argvdeste objeto contém uma matriz de argumentos transmitidos pela linha de comando.

O primeiro argumento é o caminho completo do comando node.

O segundo é o caminho completo do arquivo executável.

Os argumentos de interesse para nós começam na terceira posição (índice da matriz).

Você pode iterar sobre os argumentos (incluindo o caminho do nó e o caminho do arquivo) com um loop:

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

Os argumentos transmitidos podem ser obtidos criando uma nova matriz sem os dois primeiros parâmetros:

const args = process.argv.slice(2)

Se tivermos um argumento sem índice (chave):

node app.js joe

podemos obtê-lo assim:

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

Nesse caso:

node app.js name=joe

args[0]- name=joeé por isso que precisamos analisá-lo. A melhor maneira de fazer isso é usar uma biblioteca minimista projetada para trabalhar com argumentos:

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

Aqui você precisa usar um traço duplo antes de cada argumento:

node app.js --name=joe

Saída de resultados para a linha de comandos usando o Node.js

Saída padrão via módulo `console`

O Node.js fornece um módulo de console que contém muitas maneiras muito úteis de interagir com a linha de comando.

Parece um objeto de consolenavegador.

Um dos principais métodos deste módulo é console.log(), que imprime a cadeia passada no console.

Se você passar um objeto, ele será convertido em uma sequência.

Podemos passar console.logvárias variáveis:

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

e o Node.js produzirá ambos.

Também podemos formatar a string usando especificadores:

Por exemplo:

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

%s - formata a variável como uma sequência
%d - formata a variável como um número
%i - converte uma variável em um número inteiro
%o - formata uma variável como um objeto

Por exemplo:

console.log('%o', Number)

Limpando o console

console.clear() limpa o console (o comportamento depende do console usado).

Contando elementos

console.count()É um método conveniente.

Confira este 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 contador conta o número de linhas exibidas e exibe esse número.

The value of x is 1 and has been checked .. how many times?: 1
The value of x is 1 and has been checked .. how many times?: 2
The value of y is 2 and has been checked .. how many times?: 1

Então você pode contar o número de 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 o rastreamento de pilha

Há situações em que você precisa exibir o rastreamento de pilha de uma função, por exemplo, para responder à pergunta "Como chegamos a esse trecho de código?"

Você pode fazer isso com console.trace():

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

Isso imprimirá o rastreamento de pilha no console. É isso que veremos na linha de comando se executarmos o código no Node.js. 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)

Contando o tempo de execução do código

Você pode calcular facilmente há quanto tempo uma função está sendo executada usando time()e timeEnd():

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

stdout e stderr

Como sabemos, o console.log é ótimo para enviar mensagens para o console. Isso é chamado de saída padrão ou stdout.

console.errorexibe o fluxo stderr.

Esse fluxo não é produzido no console, mas gravado no log de erros.

Saída de estilo

Você pode colorir a saída de texto para o console usando sequências de escape . Essas seqüências são um conjunto de símbolos que identificam uma cor.

Por exemplo:

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

Se você digitar o código acima no REPL do Node.js., ele hi!será amarelo.

O método considerado é bastante trabalhoso. A maneira mais simples de colorir a saída do console é usar uma biblioteca. Uma dessas bibliotecas é o Chalk , que, além de definir a cor, permite colocar o texto em negrito, itálico ou sublinhado.

Instale a biblioteca usando npm install chalke use-a da seguinte maneira:

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

O uso é chalk.yellowmuito mais fácil do que memorizar seqüências complexas. Também torna o código mais legível.

Criando uma barra de progresso

O Progress é uma ótima biblioteca para criar indicadores de progresso no terminal. Instale-o com npm install progress.

Esse snippet cria uma barra de progresso de 10 etapas. Uma etapa é executada a cada 100 ms. Ao preencher o indicador, desabilitamos o contador:

const ProgressBar = require('progress')

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

Obrigado pela atenção, amigos. Se você encontrar erros e erros de digitação, não hesite em escrever no PM, serei grato.

Continua…

Um guia para iniciantes do Node.js Parte 2