🧗🏼 🔙 🕴🏾 Guia do Node.js, parte 10: Módulos padrão, fluxos, bancos de dados, NODE

Este material conclui a série de traduções manuais do Node.js. Hoje falaremos sobre sistemas operacionais, eventos e módulos http, discutiremos o trabalho com fluxos e bancos de dados e discutiremos o uso do Node.js no desenvolvimento e produção de aplicativos.

[Aconselhamos a ler] Outras partes do ciclo

Parte 1: Informações gerais e introdução
Parte 2: JavaScript, V8, alguns truques de desenvolvimento
Parte 3: Hospedagem, REPL, trabalho com o console, módulos
Parte 4: arquivos npm, package.json e package-lock.json
Parte 5: npm e npx
Parte 6: loop de eventos, pilha de chamadas, temporizadores
Parte 7: Programação assíncrona
Parte 8: Protocolos HTTP e WebSocket
Parte 9: trabalhando com o sistema de arquivos
Parte 10: módulos padrão, threads, bancos de dados, NODE_ENV
PDF completo do Guia Node.js.

Módulo OS do Node.js

O módulo os fornece acesso a muitas funções que podem ser usadas para obter informações sobre o sistema operacional e o hardware do computador executando o Node.js. Este é um módulo padrão, você não precisa instalá-lo, para trabalhar com ele a partir do código, basta conectá-lo:

 const os = require('os')

Existem várias propriedades úteis aqui, que, em particular, podem ser úteis ao trabalhar com arquivos.

Portanto, a propriedade os.EOL permite descobrir o separador de linhas usado no sistema (um os.EOL linha). No Linux e macOS, isso é \n , no Windows, \r\n .

Deve-se notar que, quando mencionamos “Linux e macOS” aqui, estamos falando de plataformas compatíveis com POSIX. Por uma questão de brevidade, não mencionamos plataformas menos populares aqui.

A propriedade os.constants.signals fornece informações sobre as constantes usadas para processar sinais de processo como SIGHUP , SIGKILL e assim por diante. Aqui você pode encontrar detalhes sobre eles.

A propriedade os.constants.errno contém as constantes usadas para mensagens de erro - como EADDRINUSE , EOVERFLOW .

Agora considere os principais métodos do módulo os .

▍os.arch ()

Este método retorna uma string que identifica a arquitetura do sistema, por exemplo, arm , x64 , arm64 .

▍os.cpus ()

Retorna informações sobre os processadores disponíveis no sistema. Por exemplo, essas informações podem ser assim:

 [ { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 281685380,      nice: 0,      sys: 187986530,      idle: 685833750,      irq: 0 } }, { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 282348700,      nice: 0,      sys: 161800480,      idle: 703509470,      irq: 0 } } ]

▍os.endianness ()

Retorna BE ou LE dependendo da ordem de bytes (Big Engian ou Little Endian) usada para compilar o arquivo binário Node.js.

.Fos.freemem ()

Retorna a quantidade de memória livre do sistema em bytes.

▍os.homedir ()

Retorna o caminho para o diretório inicial do usuário atual. Por exemplo, '/Users/flavio' .

▍os.hostname ()

Retorna o nome do host.

▍os.loadavg ()

Retorna, em uma matriz, os dados médios de carga calculados pelo sistema operacional. Essas informações só fazem sentido no Linux e macOS. Pode ficar assim:

 [ 3.68798828125, 4.00244140625, 11.1181640625 ]

▍os.networkInterfaces ()

Retorna informações sobre as interfaces de rede disponíveis no sistema. Por exemplo:

 { lo0:  [ { address: '127.0.0.1',      netmask: '255.0.0.0',      family: 'IPv4',      mac: 'fe:82:00:00:00:00',      internal: true },    { address: '::1',      netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 0,      internal: true },    { address: 'fe80::1',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 1,      internal: true } ], en1:  [ { address: 'fe82::9b:8282:d7e6:496e',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: '06:00:00:02:0e:00',      scopeid: 5,      internal: false },    { address: '192.168.1.38',      netmask: '255.255.255.0',      family: 'IPv4',      mac: '06:00:00:02:0e:00',      internal: false } ], utun0:  [ { address: 'fe80::2513:72bc:f405:61d0',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:80:00:20:00:00',      scopeid: 8,      internal: false } ] }

▍os.platform ()

Retorna informações sobre a plataforma para a qual o Node.js. foi compilado. Aqui estão alguns dos possíveis valores de retorno:

darwin
freebsd
linux
openbsd
win32

▍os.release ()

Retorna uma sequência identificando o número da versão do sistema operacional.

▍os.tmpdir ()

Retorna o caminho para o diretório especificado no sistema para armazenar arquivos temporários.

▍os.totalmem ()

Retorna a quantidade total de memória do sistema em bytes.

▍os.type ()

Retorna informações que identificam o sistema operacional. Por exemplo:

Linux - Linux.
Darwin - macOS.
Windows_NT - Windows.

▍os.uptime ()

Retorna o tempo de atividade do sistema em segundos desde a última reinicialização.

Módulo de eventos Node.js.

O módulo de events fornece a classe EventEmitter , projetada para funcionar com eventos na plataforma Node.js. Já conversamos um pouco sobre esse módulo no sétimo desta série de materiais. Aqui está a documentação para isso. Aqui nós olhamos para a API deste módulo. Lembre-se de que, para usá-lo no código, é necessário conectá-lo, como geralmente ocorre nos módulos padrão. Depois disso, você precisa criar um novo objeto EventEmitter . É assim:

 const EventEmitter = require('events') const door = new EventEmitter()

O objeto da classe EventEmitter usa mecanismos padrão, em particular, os seguintes eventos:

newListener - esse evento é newListener quando um manipulador de eventos é adicionado.
removeListener - chamado quando o manipulador é removido.

Considere os métodos mais úteis de objetos da classe EventEmitter (um objeto semelhante nos nomes dos métodos é indicado como emitter ).

▍emitter.addListener ()

Um alias para o método emitter.on() .

▍emitter.emit ()

Gera um evento. Invoca todos os manipuladores de eventos de forma síncrona na ordem em que foram registrados.

▍emitter.eventNames ()

Retorna uma matriz que contém os eventos registrados.

▍emitter.getMaxListeners ()

Retorna o número máximo de manipuladores que podem ser adicionados a um objeto da classe EventEmitter . O padrão é 10. Se necessário, esse parâmetro pode ser aumentado ou diminuído usando o método setMaxListeners() .

▍emitter.listenerCount ()

Retorna o número de manipuladores de eventos cujo nome é passado para este método como um parâmetro:

 door.listenerCount('open')

▍emitter.listeners ()

Retorna uma matriz de manipuladores de eventos para o evento correspondente, cujo nome é passado para este método:

 door.listeners('open')

▍emitter.off ()

Um alias para o método emitter.removeListener() , introduzido no Nó 10.

▍emitter.on ()

Registre um retorno de chamada que é chamado quando um evento é gerado. Veja como usá-lo:

 door.on('open', () => { console.log('Door was opened') })

▍emitter.once ()

Ele registra um retorno de chamada chamado apenas uma vez - na primeira ocorrência de um evento para o qual esse retorno de chamada está registrado. Por exemplo:

 const EventEmitter = require('events') const ee = new EventEmitter() ee.once('my-event', () => { //         })

▍emitter.prependListener ()

Ao registrar um manipulador usando os métodos on() ou addListener() , esse manipulador é adicionado ao final da fila do manipulador e é chamado por último para manipular o evento correspondente. Ao usar o método prependListener() , o manipulador é adicionado à frente da fila, o que faz com que seja chamado primeiro para processar o evento.

▍emitter.prependOnceListener ()

Este método é semelhante ao anterior. Ou seja, quando um manipulador destinado a uma única chamada é registrado usando o método once() , ele acaba sendo o último na fila de manipuladores e o último a ser chamado. O método prependOnceListener() permite adicionar um manipulador à frente da fila.

▍emitter.removeAllListeners ()

Este método exclui todos os manipuladores de um determinado evento registrado no objeto correspondente. Eles usam assim:

 door.removeAllListeners('open')

▍emitter.removeListener ()

Exclui o manipulador especificado a ser passado para esse método. Para salvar o manipulador para exclusão subsequente, o retorno de chamada correspondente pode ser atribuído a uma variável. É assim:

 const doSomething = () => {} door.on('open', doSomething) door.removeListener('open', doSomething)

▍emitter.setMaxListeners ()

Este método permite especificar o número máximo de manipuladores que podem ser adicionados a um único evento em uma instância da classe EventEmitter . Por padrão, como já mencionado, você pode adicionar até 10 manipuladores para um evento específico. Este valor pode ser alterado. Use este método da seguinte maneira:

 door.setMaxListeners(50)

Módulo http Node.js.

Na oitava parte desta série de materiais, já falamos sobre o módulo http padrão do Node.js. Ele coloca à disposição os mecanismos de desenvolvedor projetados para criar servidores HTTP. É o principal módulo usado para resolver os problemas de troca de dados pela rede no Node.js. Você pode conectá-lo no código assim:

 const http = require('http')

Consiste em propriedades, métodos e classes. Vamos conversar sobre eles.

▍Propriedades

http.METHODS

Esta propriedade lista todos os métodos HTTP suportados:

 > require('http').METHODS [ 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE' ]

http.STATUS_CODES

Ele contém os códigos de status HTTP e suas descrições:

 > require('http').STATUS_CODES { '100': 'Continue', '101': 'Switching Protocols', '102': 'Processing', '200': 'OK', '201': 'Created', '202': 'Accepted', '203': 'Non-Authoritative Information', '204': 'No Content', '205': 'Reset Content', '206': 'Partial Content', '207': 'Multi-Status', '208': 'Already Reported', '226': 'IM Used', '300': 'Multiple Choices', '301': 'Moved Permanently', '302': 'Found', '303': 'See Other', '304': 'Not Modified', '305': 'Use Proxy', '307': 'Temporary Redirect', '308': 'Permanent Redirect', '400': 'Bad Request', '401': 'Unauthorized', '402': 'Payment Required', '403': 'Forbidden', '404': 'Not Found', '405': 'Method Not Allowed', '406': 'Not Acceptable', '407': 'Proxy Authentication Required', '408': 'Request Timeout', '409': 'Conflict', '410': 'Gone', '411': 'Length Required', '412': 'Precondition Failed', '413': 'Payload Too Large', '414': 'URI Too Long', '415': 'Unsupported Media Type', '416': 'Range Not Satisfiable', '417': 'Expectation Failed', '418': 'I\'ma teapot', '421': 'Misdirected Request', '422': 'Unprocessable Entity', '423': 'Locked', '424': 'Failed Dependency', '425': 'Unordered Collection', '426': 'Upgrade Required', '428': 'Precondition Required', '429': 'Too Many Requests', '431': 'Request Header Fields Too Large', '451': 'Unavailable For Legal Reasons', '500': 'Internal Server Error', '501': 'Not Implemented', '502': 'Bad Gateway', '503': 'Service Unavailable', '504': 'Gateway Timeout', '505': 'HTTP Version Not Supported', '506': 'Variant Also Negotiates', '507': 'Insufficient Storage', '508': 'Loop Detected', '509': 'Bandwidth Limit Exceeded', '510': 'Not Extended', '511': 'Network Authentication Required' }

http.globalAgent

Esta propriedade aponta para a instância global da classe http.Agent . É usado para gerenciar conexões. Pode ser considerado um componente-chave do subsistema HTTP Node.js. Falaremos mais sobre a classe http.Agent abaixo.

▍Métodos

http.createServer ()

Retorna uma nova instância da classe http.Server . Veja como usar esse método para criar um servidor HTTP:

 const server = http.createServer((req, res) => { //      })

http.request ()

Permite que você faça uma solicitação HTTP ao servidor criando uma instância da classe http.ClientRequest .

http.get ()

Esse método é semelhante ao http.request() , mas define automaticamente o método HTTP como GET e chama automaticamente um comando no formato req.end() .

▍ Classes

O módulo HTTP fornece 5 classes - Agent , ClientRequest , Server , ServerResponse e IncomingMessage . Considere-os.

http.Agent

A instância global da classe http.Agent criada por Node.js é usada para gerenciar conexões. É usado como o valor padrão para todas as solicitações HTTP e fornece enfileiramento e reutilização de soquetes. Além disso, ele suporta um pool de soquetes, que permite alto desempenho do subsistema de rede Node.js. Se necessário, você pode criar seu próprio objeto http.Agent .

http.ClientRequest

Um objeto da classe http.ClientRequest , que é uma solicitação em execução, é criado quando os http.request() ou http.get() são chamados. Quando uma resposta a uma solicitação é recebida, o evento de resposta é gerado, no qual a resposta é transmitida - uma instância de http.IncomingMessage . Os dados obtidos após a execução da consulta podem ser processados de duas maneiras:

Você pode chamar o método response.read() .
No manipulador de eventos de response , você pode configurar um ouvinte para o evento de data , o que permite trabalhar com dados de streaming.

http.Server

Instâncias dessa classe são usadas para criar servidores usando o comando http.createServer() . Depois de termos um objeto de servidor, podemos usar seus métodos:

O método listen() é usado para iniciar o servidor e aguardar e processar solicitações recebidas.
O método close() para o servidor.

http.ServerResponse

Este objeto é criado pela classe http.Server e passado como o segundo parâmetro para o evento de request quando ele ocorre. Normalmente, esses objetos no código recebem o nome res :

 const server = http.createServer((req, res) => { //res -   http.ServerResponse })

Nesses manipuladores, depois que a resposta do servidor estiver pronta para ser enviada ao cliente, o método end() é chamado, que completa a resposta. Este método deve ser chamado após a conclusão de cada resposta.

Aqui estão os métodos usados para trabalhar com cabeçalhos HTTP:

getHeaderNames() - retorna uma lista de nomes de cabeçalhos instalados.
getHeaders() - retorna uma cópia dos cabeçalhos HTTP definidos.
setHeader('headername', value) - define o valor para o cabeçalho especificado.
getHeader('headername') - retorna o cabeçalho definido.
removeHeader('headername') - remove o cabeçalho instalado.
hasHeader('headername') - retorna true se a resposta já tiver um cabeçalho cujo nome é passado para esse método.
headersSent() - retorna true se os cabeçalhos já foram enviados ao cliente.

Após o processamento dos cabeçalhos, eles podem ser enviados ao cliente chamando o método response.writeHead() , que, como primeiro parâmetro, recebe um código de status. Como segundo e terceiro parâmetros, uma mensagem correspondente ao código de status e cabeçalhos pode ser passada para ele.

Para enviar dados para o cliente, o método write() é usado no corpo da resposta. Ele envia dados em buffer para o fluxo de resposta HTTP.

Se os cabeçalhos ainda não tiverem sido definidos com o comando response.writeHead() , os cabeçalhos com o código de status e a mensagem especificados na solicitação serão enviados primeiro. Você pode definir seus valores definindo valores para as statusMessage e statusMessage :

 response.statusCode = 500 response.statusMessage = 'Internal Server Error'

http.IncomingMessage

Um objeto da classe http.IncomingMessage é criado no curso dos seguintes mecanismos:

http.Server - ao processar o evento de request .
http.ClientRequest - ao manipular o evento de response .

Pode ser usado para trabalhar com dados de resposta. Ou seja:

Para descobrir o código de status da resposta e a mensagem correspondente, as propriedades statusMessage e statusMessage são usadas.
Você pode ver os headers resposta rawHearders headers ou rawHearders (para obter uma lista de cabeçalhos brutos).
Você pode descobrir o método de solicitação usando a propriedade method
Para descobrir qual versão do HTTP está sendo usada, use a propriedade httpVersion .
A propriedade url é usada para obter o URL.
A propriedade socket permite que você obtenha o objeto net.Socket associado à conexão.

Os dados de resposta são apresentados como um fluxo, já que o objeto http.IncomingMessage implementa a interface Readable Stream .

Trabalhar com fluxos no Node.js

Threads são um dos conceitos fundamentais usados nos aplicativos Node.js. Os fluxos são ferramentas que permitem ler e gravar arquivos, organizar a interação de rede entre sistemas e, em geral, implementar efetivamente operações de troca de dados.

O conceito de threads não é exclusivo do Node.js. Eles apareceram na família de sistemas operacionais Unix décadas atrás. Em particular, os programas podem interagir entre si, transmitindo fluxos de dados usando pipelines (usando o caractere de pipe - | ).

Se imaginarmos, digamos, lendo um arquivo sem usar fluxos, durante a execução do comando correspondente, o conteúdo do arquivo será completamente lido na memória, após o qual será possível trabalhar com esse conteúdo.

Graças ao uso do mecanismo de fluxo, os arquivos podem ser lidos e processados em partes, o que elimina a necessidade de armazenar grandes quantidades de dados na memória.

O módulo de fluxo Node.js. é a base sobre a qual todas as APIs que suportam o fluxo são construídas.

▍Sobre os pontos fortes do uso de fluxos

Os fluxos, em comparação com outros métodos de processamento de dados, têm as seguintes vantagens:

Uso eficiente de memória. Trabalhar com um fluxo não implica armazenar na memória grandes quantidades de dados carregadas com antecedência, antes que seja possível processá-las.
Economia de tempo. Os dados recebidos do fluxo podem ser processados muito mais rapidamente do que quando você precisa esperar que eles sejam totalmente carregados para começar a processá-los.

▍ Exemplo de trabalho com fluxos

Um exemplo tradicional de trabalho com fluxos demonstra a leitura de um arquivo do disco.

Primeiro, considere o código no qual os threads não são usados. O módulo fs padrão do Node.js permite ler um arquivo, após o qual ele pode ser transferido via HTTP em resposta a uma solicitação recebida por um servidor HTTP:

 const http = require('http') const fs = require('fs') const server = http.createServer(function (req, res) { fs.readFile(__dirname + '/data.txt', (err, data) => {   res.end(data) }) }) server.listen(3000)

O método readFile() usado aqui permite ler o arquivo inteiro. Quando a leitura é concluída, ele chama o retorno de chamada correspondente.

O res.end(data) , chamado no retorno de chamada, envia o conteúdo do arquivo para o cliente.

Se o tamanho do arquivo for grande, essa operação levará muito tempo. Aqui está o mesmo exemplo reescrito usando fluxos:

 const http = require('http') const fs = require('fs') const server = http.createServer((req, res) => { const stream = fs.createReadStream(__dirname + '/data.txt') stream.pipe(res) }) server.listen(3000)

Em vez de esperar o momento em que o arquivo é totalmente lido, começamos a transferir seus dados para o cliente imediatamente após a primeira parte desses dados estar pronta para o envio.

Método ipePipe ()

No exemplo anterior, usamos uma construção do formulário stream.pipe(res) , na qual o método de fluxo de arquivo pipe() é chamado. Este método pega os dados de sua origem e os envia para o destino.

É chamado para um fluxo que representa uma fonte de dados. Nesse caso, esse é o fluxo de arquivos enviado para a resposta HTTP.

O valor de retorno do método pipe() é o fluxo de destino. Isso é muito conveniente, pois permite encadear várias chamadas para o método pipe() :

 src.pipe(dest1).pipe(dest2)

Isso é equivalente a esse design:

 src.pipe(dest1) dest1.pipe(dest2)

IAPI Node.js que usam fluxos

Os fluxos são um mecanismo útil; como resultado, muitos módulos do kernel do Node.js. fornecem recursos padrão para trabalhar com fluxos. Listamos alguns deles:

process.stdin - retorna um thread conectado ao stdin .
process.stdout - Retorna o thread conectado ao stdout .
process.stderr - retorna um encadeamento conectado ao stderr .
fs.createReadStream() - cria um fluxo legível para trabalhar com um arquivo.
fs.createWriteStream() - cria um fluxo gravável para trabalhar com um arquivo.
net.connect() - inicia uma conexão baseada em fluxo.
http.request() - retorna uma instância da classe http.ClientRequest que fornece acesso ao fluxo que está sendo gravado.
zlib.createGzip() - compacta dados usando o algoritmo gzip e os envia para o fluxo.
zlib.createGunzip() - descompacta um fluxo gzip .
zlib.createDeflate() - compacta dados usando o algoritmo deflate e os envia para o fluxo.
zlib.createInflate() - descompacta um fluxo deflate .

TypesVários tipos de fluxos

Existem quatro tipos de fluxos:

Um fluxo legível é um fluxo a partir do qual os dados podem ser lidos. Você não pode gravar dados nesse fluxo. Quando os dados chegam nesse fluxo, eles são armazenados em buffer até que o consumidor de dados comece a lê-los.
Um fluxo para gravação ( Writable ) é um fluxo no qual você pode enviar dados. Você não pode ler dados dele.
Fluxo duplex ( Duplex ) - nesse fluxo, você pode enviar dados e lê-los. Essencialmente, essa é uma combinação de um fluxo para leitura e um fluxo para escrita.
Transformar fluxo ( Transform ) - esses fluxos são semelhantes aos fluxos duplex, a diferença é que o que vem à entrada desses fluxos transformará o que pode ser lido deles.

Criar um fluxo de leitura

, stream :

 const Stream = require('stream') const readableStream = new Stream.Readable()

, :

 readableStream.push('hi!') readableStream.push('ho!')

▍

Writable _write() . :

 const Stream = require('stream') const writableStream = new Stream.Writable()

_write() :

 writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() }

, :

 process.stdin.pipe(writableStream)

▍

, , :

 const Stream = require('stream') const readableStream = new Stream.Readable() const writableStream = new Stream.Writable() writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() } readableStream.pipe(writableStream) readableStream.push('hi!') readableStream.push('ho!') readableStream.push(null)

readableStream.push(null) .

, readable :

 readableStream.on('readable', () => { console.log(readableStream.read()) })

▍

write() :

 writableStream.write('hey!\n')

▍ ,

, , end() :

 writableStream.end()

. , , .

MySQL Node.js

MySQL . Node.js , MySQL-, — , .

mysqljs/mysql . , , 12000 GitHub. , MySQL-.

▍

 npm install mysql

▍

 const mysql = require('mysql')

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' } const connection = mysql.createConnection(options)

 connection.connect(err => { if (err) {   console.error('An error occurred while connecting to the DB')   throw err } }

▍

options :

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' }

. — :

host — , MySQL-, — localhost .
port — , — 3306 .
socketPath — Unix .
debug — , .
trace — , .
ssl — SSL- .

▍ SELECT

SQL- . query , . — , . . :

 connection.query('SELECT * FROM todos', (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) })

, :

 const id = 223 connection.query('SELECT * FROM todos WHERE id = ?', [id], (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) })