Machine Translated by Google

Machine Translated by Google

[Link]

Sobre o tutorial
[Link] é uma estrutura/plataforma baseada em JavaScript muito poderosa, construída no JavaScript V8
Engine do Google Chrome. Ele é usado para desenvolver aplicativos da Web com uso intensivo de E/S,
como sites de streaming de vídeo, aplicativos de página única e outros aplicativos da Web. O [Link] é de
código aberto, totalmente gratuito e usado por milhares de desenvolvedores em todo o mundo.

Público
Este tutorial foi desenvolvido para programadores de software que desejam aprender os conceitos básicos
do [Link] e seus conceitos de arquitetura. Este tutorial fornecerá uma compreensão suficiente de todos os
componentes necessários do [Link] com exemplos adequados.

Pré-requisitos
Antes de prosseguir com este tutorial, você deve ter um entendimento básico de JavaScript.
Como vamos desenvolver aplicativos baseados na web usando [Link], será bom se você tiver algum
conhecimento de outras tecnologias da web, como HTML, CSS, AJAX, etc.

Executar [Link] Online

Para a maioria dos exemplos fornecidos neste tutorial, você encontrará uma opção Experimente , então
use essa opção para executar seus programas [Link] na hora e aproveitar seu aprendizado.

Experimente o exemplo a seguir usando a opção Experimente disponível no canto superior direito da caixa
de código de amostra abaixo (em nosso site):

/* Olá Mundo! programa em [Link] */

[Link]("Olá Mundo!");

Direitos autorais e isenção de responsabilidade

ÿ Copyright 2016 por Tutoriais Point (I) Unip. Ltda.

Todo o conteúdo e gráficos publicados neste e-book são de propriedade da Tutorials Point (I)
Unip. Ltd. O usuário deste e-book está proibido de reutilizar, reter, copiar, distribuir ou republicar qualquer
conteúdo ou parte do conteúdo deste e-book de qualquer maneira sem o consentimento por escrito do editor.

Nós nos esforçamos para atualizar o conteúdo de nosso site e tutoriais o mais rápido e preciso possível, no
entanto, o conteúdo pode conter imprecisões ou erros. Ponto de Tutoriais (I) Unip.
Ltd. não oferece garantia quanto à precisão, pontualidade ou integridade de nosso site ou de seu conteúdo,
incluindo este tutorial. Se você descobrir algum erro em nosso site ou neste tutorial, avise-nos em
contact@[Link]

eu
Machine Translated by Google

[Link]

Índice
Sobre o Tutorial ........................................................ .................................................. ........................................... eu
Público................................................. .................................................. .................................................. ...... eu

Pré-requisitos ....................................... .................................................. .................................................. i Executar o [Link]

Online.............................................. .................................................. ....................................... Direitos autorais e isenção de
responsabilidade...... .................................................. .................................................. ......................... i
Índice .............................. .................................................. .................................................. ................... ii

1. Introdução............................................... .................................................. ............................................. 1

O que é o [Link]?................................................ .................................................. ................................................. 1 Recursos de

[Link] .............................................. .................................................. .........................................1 Quem usa o
[Link]?.. .................................................. .................................................. .................................... 2
Conceitos .................... .................................................. .................................................. .............................................2 Onde usar o
[Link]? .................................................. .................................................. .........................2 Onde não usar o
[Link]?......... .................................................. .................................................. ................2

2. Configuração do Ambiente ............................................. .................................................. .........................3 Experimente a Opção

Online .......... .................................................. .................................................. .........................3 Configuração do Ambiente
Local......... .................................................. .................................................. ..........3 Editor de
Texto .................................. .................................................. .................................................. ..............3
O tempo de execução do [Link] ............................................. .................................................. .........................3 Baixar o arquivo
[Link] .... .................................................. .................................................. .......................4 Instalação em UNIX/Linux/Mac OS X e
SunOS................ .................................................. .............................. 4 Instalação no
Windows .......... .................................................. .................................................. .........4
Verificar a instalação: Executando um arquivo ............................................. .................................................. ................... 5

3. Primeira aplicação ............................................. .................................................. .........................6 Criando aplicativo

[Link] .... .................................................. .................................................. ................... 6

4. Terminal REPL ............................................. .................................................. .......................................... 9

Terminal REPL on-line ............................................. .................................................. ......................... 9
Comandos REPL.............................................. .................................................. .......................................... 11

Parando o REPL................................................ .................................................. ............................................. 11

5. NPM ............................................. .................................................. .................................................. .....12

Instalando Módulos usando NPM.............................................. .................................................. ....................... 12

Instalação global versus local ............................................. .................................................. ..............................12

Usando o [Link] .................................................. .................................................. .......................................14 Atributos de

[Link].... .................................................. .................................................. .......................19 Desinstalando um
módulo ........................ .................................................. .................................................. ......19 Atualizando um
Módulo........................................ .................................................. .............................................19 Pesquisar um
módulo .................................................. .................................................. ....................................... 19
Criar um módulo................................................ .................................................. .......................................... 19

6. Conceito de retorno de chamada ............................................. .................................................. ..............................21 O que é o

retorno de chamada?........ .................................................. .................................................. ..............................21
Exemplo de código de bloqueio.............................................. .................................................. .........................21 Exemplo de código
sem bloqueio........... .................................................. .................................................. ........... 22

ii
Machine Translated by Google

[Link]

7. Ciclo de Eventos................................................. .................................................. .............................................23 Orientado a Eventos

Programação .................................................. .................................................. .......................23
Exemplo ........................ .................................................. .................................................. ..................................24 Como funcionam os
aplicativos de nó? .................................................. .................................................. ..................25

8. Emissor de Eventos................................................. .................................................. .......................................... 26

Classe Emissora de Eventos................................................. .................................................. .......................................26
Métodos ................................................. .................................................. .................................................. ...26
Métodos de classe ........................................................ .................................................. .............................................27
Eventos................................................. .................................................. .................................................. ....28

Exemplo ................................................. .................................................. .................................................. ....28

9. Tampões............................................. .................................................. .................................................. 0,30

Criando buffers................................................. .................................................. ....................................30 Gravando em

Buffers... .................................................. .................................................. ....................................30 Lendo de
Buffers........... .................................................. .................................................. .......................31 Converter Buffer para
JSON........................ .................................................. .................................................. ....32
Concatenar Buffers................................................. .................................................. ....................................33

Comparar buffers................................................. .................................................. .......................................33 Copiar

Buffer..... .................................................. .................................................. ....................................34 Buffer de
fatia.... .................................................. .................................................. ............................................. 35

Comprimento do buffer................................................ .................................................. .........................................36 Referência de

Métodos .................................................. .................................................. ....................................36
Métodos de classe ........................................................ .................................................. ............................................. 41

10. Fluxos................................................. .................................................. .................................................. 43

O que são Streams? .................................................. .................................................. .................................... 43

Lendo a partir de um fluxo ............................................. .................................................. .........................43 Gravando em um

fluxo ........... .................................................. .................................................. .......................44 Canalizando os
córregos......................... .................................................. .................................................. ...............45 Encadeando os
fluxos.............................. .................................................. .................................................. ..46

11. Sistema de arquivos............................................. .................................................. ............................................. 48 Síncrono vs

Assíncrono .................................................. .................................................. ....48 Abrir um
arquivo .................................... .................................................. .................................................. .......................49 Obter informações
do arquivo .................................. .................................................. .................................................. .........51

Escrevendo um arquivo .................................................. .................................................. ......................................... 53 Leitura um

arquivo................................................ .................................................. ............................................. 54 Fechando um
Arquivo................................................. .................................................. .........................................56 Truncar um
Arquivo ................................................. .................................................. .......................................... 57
Excluir um arquivo................................................ .................................................. .................................................. 59

Criar um diretório ............................................. .................................................. .......................................60 Ler um

Diretório ...... .................................................. .................................................. .........................61 Remover um
diretório ......... .................................................. .................................................. .......................62 Referência de
Métodos ........................ .................................................. .................................................. ........... 63

12. Objetos Globais ............................................. .................................................. ........................................69

__nomedoarquivo........ .................................................. .................................................. .........................................69
__dirname ......... .................................................. .................................................. ..............................69 setTimeout(cb,
ms). .................................................. .................................................. .........................70 clearTimeout
(t).......... .................................................. .................................................. ..............................70 setInterval(cb,
ms)............ .................................................. .................................................. ......................... 71 Objetos
Globais ......................... ..... .................................................. .................................................. ........ 71
iii
Machine Translated by Google

[Link]

Objeto de console ................................................. .................................................. ......................................... 72 Processar

Objeto... .................................................. .................................................. ....................................... 74

13. Módulos Utilitários............................................. .................................................. .......................................81 Módulo do

SO........ .................................................. .................................................. ......................................... 81
Módulo de caminho ....................................... .................................................. ....................................... 83
Módulo de rede ............................................. .................................................. .................................................. 85
Módulo DNS................................................ .................................................. ......................................... 92
Módulo de domínio................................................ .................................................. .......................................... 95

14. Módulo Web.............................................. .................................................. .......................................... 99

O que é um servidor web? .................................................. .................................................. .............................. 99

Arquitetura de aplicativos da Web .................................................. .................................................. .........................99 Criando um

servidor Web usando o Node......... .................................................. .........................................100 Faça uma solicitação ao servidor
[Link] .. .................................................. .................................................. .........102 Criando um cliente Web usando o
Node ......................... .................................................. .......................... 102

15. Estrutura Expressa ............................................. .................................................. ......................... 104 Visão geral

expressa ............... .................................................. .................................................. ..........104 Instalando o
Express .......................... .................................................. .................................................. ..........104 Exemplo Olá
mundo .................................. .................................................. ............................................. 104 Solicitação e
Resposta .................................................. .................................................. ......................... 106 Objeto de
solicitação ............... .................................................. .................................................. ......................... 106 Objeto de
Resposta ........................ .................................. .................................................. ......................................... 109 Roteamento
Básico ......... .................................................. .................................................. ......................... 115 Servindo Arquivos
Estáticos ............ .................................................. .................................................. ......................... 118 Método
GET ........................ .................................................. .................................................. ....................... 119
Método POST................................................................ .................................................. ............................................. 121

Carregamento de arquivo ......................................... .................................................. .................................................. 123 Gerenciamento

de cookies ........................................ .................................................. ......................... 125

16. API RESTful ............................................. .................................................. .......................................... 126

O que é Arquitetura REST? .................................................. .................................................. ....................... 126
Métodos HTTP ........................................................ .................................................. .......................................... 126
Serviços Web RESTful .................................................. .................................................. ......................... 126

Criando RESTful para uma biblioteca ............................................. .................................................. ....................... 126 Listar
usuários ........................ .................................................. .................................................. ....................... 128
Adicionar usuários ................................................. .................................................. .................................................. 129
Mostrar detalhes................................................ .................................................. ......................................... 130
Excluir um usuário................................................ .................................................. ............................................. 131

17. Dimensionando um aplicativo............................................. .................................................. ......................... 133 O método

exec() ........ .................................................. .................................................. ....133 O método
spawn() .................................... .................................................. .................................................. ......135 O método
fork() ...................................... .................................................. .............................................. 137

18. Embalagem................................................. .................................................. ............................................. 139

Instalação do JXcore .................................................. .................................................. ....................................... 139

Empacotando o código ......................................... .................................................. .................................... 140 Iniciando o arquivo

JX......... .................................................. .................................................. .......................... 140

4
Machine Translated by Google

1. Introdução [Link]

O que é o [Link]?
[Link] é uma plataforma do lado do servidor construída no JavaScript Engine do Google Chrome (V8 Engine).
O [Link] foi desenvolvido por Ryan Dahl em 2009 e sua versão mais recente é a v0.10.36. A definição de [Link]
conforme fornecida por sua documentação oficial é o seguinte:

[Link] é uma plataforma criada no tempo de execução JavaScript do Chrome para criar facilmente
e aplicativos de rede escaláveis. O [Link] usa um modelo de E/S sem bloqueio e orientado a eventos
que o torna leve e eficiente, perfeito para aplicativos em tempo real com uso intenso de dados executados
em dispositivos distribuídos.

O [Link] é um ambiente de tempo de execução de plataforma cruzada de código aberto para o desenvolvimento
de aplicativos de rede e do lado do servidor. Os aplicativos [Link] são escritos em JavaScript e podem ser
executados no tempo de execução do [Link] no OS X, Microsoft Windows e Linux.

O [Link] também fornece uma rica biblioteca de vários módulos JavaScript que simplificam bastante o
desenvolvimento de aplicativos da Web usando [Link].

[Link] = ambiente de tempo de execução + biblioteca JavaScript

Recursos do [Link]
A seguir estão alguns dos recursos importantes que fazem do [Link] a primeira escolha dos arquitetos de software.

• Assíncrona e Orientada a Eventos - Todas as APIs da biblioteca [Link] são assíncronas,

ou seja, sem bloqueio. Isso significa essencialmente que um servidor baseado em [Link] nunca espera
que uma API retorne dados. O servidor passa para a próxima API depois de chamá-la e um mecanismo de
notificação de Eventos do [Link] ajuda o servidor a obter uma resposta da chamada da API anterior.

• Muito rápido - Sendo construído no motor JavaScript V8 do Google Chrome, biblioteca [Link]
é muito rápido na execução do código.

• Thread único, mas altamente escalável – [Link] usa um modelo de thread único com loop de eventos. O
mecanismo de eventos ajuda o servidor a responder de maneira não bloqueante e torna o servidor
altamente escalável em oposição aos servidores tradicionais que criam threads limitados para lidar com
solicitações. O [Link] usa um único programa encadeado e o mesmo programa pode fornecer serviço
para um número muito maior de solicitações do que servidores tradicionais como o Apache HTTP Server.

• Sem buffer – Os aplicativos [Link] nunca armazenam em buffer nenhum dado. Esses aplicativos
simplesmente emitem os dados em pedaços.

• Licença – O [Link] é lançado sob a licença do MIT.

1
Machine Translated by Google

[Link]

Quem usa o [Link]?

A seguir está o link no wiki do github contendo uma lista exaustiva de projetos, aplicativos e empresas que
estão usando [Link]. Esta lista inclui eBay, General Electric, GoDaddy, Microsoft, PayPal, Uber, Wikipins,
Yahoo! e Yammer, para citar alguns.

• Projetos, aplicativos e empresas usando o Node

Conceitos
O diagrama a seguir descreve algumas partes importantes do [Link] que discutiremos em detalhes nos
capítulos subsequentes.

Onde usar o [Link]?

A seguir estão as áreas em que o [Link] está provando ser um parceiro de tecnologia perfeito.

• Aplicativos vinculados a E/S

• Aplicativos de streaming de dados
• Aplicativos em tempo real intensivos em dados (DIRT)
• Aplicativos baseados em APIs JSON
• Aplicativos de página única

Onde não usar o [Link]?

Não é aconselhável usar [Link] para aplicativos com uso intensivo de CPU.

2
Machine Translated by Google

[Link]
2. Configuração do Ambiente

Experimente a Opção Online

Você realmente não precisa configurar seu próprio ambiente para começar a aprender [Link]. O motivo é
muito simples, já configuramos o ambiente [Link] online, para que você possa executar todos os exemplos
disponíveis online e aprender na prática. Sinta-se à vontade para modificar qualquer exemplo e verificar os
resultados com diferentes opções.

Experimente o exemplo a seguir usando a opção Experimente disponível no canto superior direito da caixa
de código de amostra abaixo (em nosso site):

/* Olá Mundo! programa em [Link] */

[Link]("Olá Mundo!");

Para a maioria dos exemplos fornecidos neste tutorial, você encontrará uma opção Experimente, então faça
uso dela e aproveite seu aprendizado.

Configuração do ambiente local

Se você deseja configurar seu ambiente para [Link], você precisa ter os dois softwares a seguir em seu
computador, (a) um Editor de Texto e (b) os instaláveis binários [Link].

Editor de texto

Você precisa ter um editor de texto para digitar seu programa. Exemplos de editores de texto incluem
Windows Notepad, comando OS Edit, Brief, Epsilon, EMACS e vim ou vi.

O nome e a versão dos editores de texto podem variar de um sistema operacional para outro. Por exemplo,
o Bloco de Notas será usado no Windows, e o vim ou vi pode ser usado no Windows, assim como no Linux
ou UNIX.

Os arquivos que você cria com seu editor são chamados de arquivos-fonte e contêm o código-fonte do
programa. Os arquivos de origem para programas [Link] geralmente são nomeados com a extensão ".js".

Antes de começar a programar, certifique-se de ter um editor de texto instalado e ter experiência suficiente
em como escrever um programa de computador, salvá-lo em um arquivo e, finalmente, executá-lo.

O ambiente de execução do [Link]

O código fonte que você escreveria em um arquivo fonte é simplesmente javascript. O interpretador [Link]
interpreta e executa seu código javascript.

A distribuição [Link] vem como um binário instalável para sistemas operacionais SunOS, Linux, Mac OS
X e Windows com arquiteturas de processador x86 de 32 bits (386) e 64 bits (amd64).

3
Machine Translated by Google

[Link]

A seção a seguir explica como instalar a distribuição binária do [Link] em vários sistemas operacionais.

Baixar arquivo [Link]

Baixe a versão mais recente do arquivo instalável do [Link] em Downloads do [Link]. No momento de escrever este
tutorial, a seguir estão as versões disponíveis em diferentes sistemas operacionais.

OS Nome do arquivo

janelas [Link]

Linux [Link]

Mac [Link]

SunOS [Link]

Instalação em UNIX/Linux/Mac OS X e SunOS

Com base na arquitetura do seu sistema operacional, baixe e extraia o arquivo node-v0.12.0-
[Link] para /tmp e, em seguida, mova os arquivos extraídos para o diretório /usr/local/nodejs. Por exemplo:

$ cd /tmp

$ wget [Link]

$ tar xvfz [Link]

$ mkdir -p /usr/local/nodejs

$ mv node-v6.3.1-linux-x64 / * / usr / local / nodejs

Adicione /usr/local/nodejs/bin à variável de ambiente PATH.

OS Saída

Linux export PATH=$PATH:/usr/local/nodejs/bin

Mac export PATH=$PATH:/usr/local/nodejs/bin

FreeBSD export PATH=$PATH:/usr/local/nodejs/bin

Instalação no Windows
Use o arquivo MSI e siga os prompts para instalar o [Link]. Por padrão, o instalador usa a distribuição [Link] em C:
\Program Files\nodejs. O instalador deve definir o diretório C:\Program Files\nodejs\bin na variável de ambiente PATH do
Windows. Reinicie qualquer prompt de comando aberto para que a alteração tenha efeito.

4
Machine Translated by Google

[Link]

Verificar instalação: Executando um arquivo

Crie um arquivo js chamado [Link] em sua máquina (Windows ou Linux) com o seguinte código.

/* Olá Mundo! programa em [Link] */

[Link]("Olá, Mundo!")

Agora execute [Link] usando o interpretador [Link] para ver o resultado:

$ nó [Link]

Se tudo estiver bem com sua instalação, deve produzir o seguinte resultado:

Olá Mundo!

5
Machine Translated by Google

3. Primeira aplicação [Link]

Antes de criar um "Hello, World!" aplicativo usando [Link], vamos ver os componentes de um aplicativo [Link]. Um
aplicativo [Link] consiste nos três componentes importantes a seguir:

1. Importe os módulos necessários: usamos a diretiva require para carregar o [Link]

módulos.

2. Criar servidor: Um servidor que ouvirá as solicitações do cliente semelhante ao Apache

Servidor HTTP.

3. Ler solicitação e retornar resposta: O servidor criado em uma etapa anterior lerá a solicitação HTTP feita pelo
cliente que pode ser um navegador ou um console e retornará a resposta.

Criando aplicativo [Link]

Etapa 1 - Importar Módulo Necessário

Usamos a diretiva require para carregar o módulo http e armazenar a instância HTTP retornada em uma variável http da
seguinte forma:

var http = require("http");

Etapa 2-Criar servidor

Usamos a instância http criada e chamamos o método [Link]() para criar uma instância do servidor e, em
seguida, a vinculamos à porta 8081 usando o método listen associado à instância do servidor. Passe uma função com os
parâmetros request e response. Escreva a implementação de amostra para sempre retornar "Hello World".

[Link](função (solicitação, resposta) {

//Envia o cabeçalho HTTP

// Status HTTP: 200 : OK

// Tipo de conteúdo: text/plain

[Link](200, {'Content-Type': 'text/plain'});

// Envia o corpo da resposta como "Hello World"

[Link]('Olá Mundo\n');

}).listen(8081);

6
Machine Translated by Google

[Link]

// O console imprimirá a mensagem

[Link]('Servidor rodando em [Link]

O código acima é suficiente para criar um servidor HTTP que escuta, ou seja, espera uma requisição pela porta 8081 na
máquina local.

Etapa 3-Teste de solicitação e resposta

Vamos juntar as etapas 1 e 2 em um arquivo chamado [Link] e iniciar nosso servidor HTTP conforme mostrado
abaixo:

var http = require("http");

[Link](função (solicitação, resposta) {

//Envia o cabeçalho HTTP

// Status HTTP: 200 : OK

// Tipo de conteúdo: text/plain

[Link](200, {'Content-Type': 'text/plain'});

// Envia o corpo da resposta como "Hello World"

[Link]('Olá Mundo\n');

}).listen(8081);

// O console imprimirá a mensagem

[Link]('Servidor rodando em [Link]

Agora execute o [Link] para iniciar o servidor da seguinte forma:

$ nó [Link]

Verifique a saída. O servidor foi iniciado.

Servidor rodando em [Link]

7
Machine Translated by Google

[Link]

Faça uma solicitação ao servidor [Link]

Abra [Link] em qualquer navegador e observe o seguinte resultado.

Parabéns, você tem seu primeiro servidor HTTP em funcionamento que está respondendo a todas
as solicitações HTTP na porta 8081.

8
Machine Translated by Google

4. Terminal REPL [Link]

REPL significa Read Eval Print Loop e representa um ambiente de computador como um console Windows ou shell Unix/
Linux onde um comando é inserido e o sistema responde com uma saída em modo interativo. [Link] ou Node vem com
um ambiente REPL. Ele executa as seguintes tarefas:

• Read - Lê a entrada do usuário, analisa a entrada na estrutura de dados JavaScript e armazena na memória.

• Eval - Pega e avalia a estrutura de dados.

• Imprimir - Imprime o resultado.

• Loop - Faz um loop no comando acima até que o usuário pressione ctrl-c duas vezes.

O recurso REPL do Node é muito útil para experimentar códigos [Link] e para depurar códigos JavaScript.

Terminal REPL Online

Para simplificar seu aprendizado, configuramos um ambiente [Link] REPL on-line fácil de usar,
onde você pode praticar a sintaxe do [Link]: Inicie o [Link] REPL Terminal

Iniciando REPL
O REPL pode ser iniciado simplesmente executando o node no shell/console sem nenhum argumento da
seguinte forma.

$ nó

Você verá o prompt de comando REPL > onde você pode digitar qualquer comando [Link]:

$ nó

>

Expressão Simples
Vamos tentar uma matemática simples no prompt de comando do [Link] REPL:

$ nó

>1+3

>1+(2*3)-4

9
Machine Translated by Google

[Link]

>

Usar variáveis

Você pode usar variáveis para armazenar valores e imprimir posteriormente como qualquer script convencional.
Se a palavra-chave var não for usada, o valor será armazenado na variável e impresso. Considerando que, se
a palavra-chave var for usada, o valor será armazenado, mas não impresso. Você pode imprimir variáveis
usando [Link]().

$ nó
> x = 10

10

> var y = 10
Indefinido

>x+y
20

> [Link]("Olá Mundo")

Olá Trabalhado

Indefinido

Expressão de várias linhas

O Node REPL suporta expressão multilinha semelhante ao JavaScript. Vamos verificar o seguinte loop do-while
em ação:

$ nó
> var x = 0

Indefinido

> faça {
... x++;

... [Link]("x: " + x);

... } while (x < 5);

x: 1

x: 2

x: 3

x: 4

x: 5

Indefinido

>

... vem automaticamente quando você pressiona Enter após o colchete de abertura. O nó verifica automaticamente
a continuidade das expressões.
10
Machine Translated by Google

[Link]

Variável de sublinhado

Você pode usar sublinhado (_) para obter o último resultado:

$ nó

> var x = 10

Indefinido

> var y = 20

Indefinido

>x+y

30

> var soma = _

Indefinido

> [Link](soma)

30

Indefinido

>

Comandos REPL
• ctrl + c - encerra o comando atual.

• ctrl + c duas vezes - encerra o Node REPL.

• ctrl + d - encerra o Node REPL.

• Teclas para cima/para baixo - veja o histórico de comandos e modifique os comandos anteriores.

• Teclas de tabulação - lista de comandos atuais.

• .help - lista de todos os comandos.

• .break - sai da expressão multilinha.

• .clear - sai da expressão multilinha.

• .save filename - salva a sessão atual do Node REPL em um arquivo.

• .load filename - carrega o conteúdo do arquivo na sessão atual do Node REPL.

Parando REPL
Como mencionado acima, você precisará usar ctrl-c duas vezes para sair do [Link] REPL.

$ nó

>

(^C novamente para sair)

>

11
Machine Translated by Google

5. NPM [Link]

O Node Package Manager (NPM) fornece duas funcionalidades principais:

• Repositórios online para pacotes/módulos [Link] que podem ser pesquisados em

[Link]

• Utilitário de linha de comando para instalar pacotes [Link], fazer gerenciamento de versão e
gerenciamento de dependência de pacotes [Link].

O NPM vem com os instaláveis do [Link] após a versão v0.6.3. Para verificar o mesmo, abra o console e digite o
seguinte comando e veja o resultado:

$ npm --versão
2.7.1

Se você estiver executando uma versão antiga do NPM, é muito fácil atualizá-lo para a versão mais recente. Basta
usar o seguinte comando do root:

$ sudo npm install npm -g

/usr/bin/npm -> /usr/lib/node_modules/npm/bin/[Link]

[email protected] /usr/lib/node_modules/npm

Instalando módulos usando NPM

Existe uma sintaxe simples para instalar qualquer módulo [Link]:

$ npm instalar <Nome do módulo>

Por exemplo, a seguir está o comando para instalar um famoso módulo de estrutura da Web [Link] chamado
express:

$ npm instalar expresso

Agora você pode usar este módulo em seu arquivo js da seguinte forma:

var expresso = require('expresso');

Instalação Global x Local

Por padrão, o NPM instala qualquer dependência no modo local. Aqui o modo local refere-se à instalação do pacote
no diretório node_modules localizado na pasta onde o aplicativo Node está presente. Os pacotes implantados
localmente são acessíveis através do método require(). Por exemplo,
quando instalamos o módulo express, ele criou o diretório node_modules no diretório atual onde instalou o módulo
express.

12
Machine Translated by Google

[Link]

$ ls -l
total 0

drwxr-xr-x 3 root root 20 mar 17 02:23 node_modules

Alternativamente, você pode usar o comando npm ls para listar todos os módulos instalados localmente.

Os pacotes/dependências instalados globalmente são armazenados no diretório do sistema. Tais

dependências podem ser usadas na função CLI (Command Line Interface) de qualquer [Link], mas não
podem ser importadas usando require() no aplicativo Node diretamente. Agora vamos tentar instalar o módulo
express usando a instalação global.

$ npm instalar expresso -g

Isso produzirá um resultado semelhante, mas o módulo será instalado globalmente. Aqui, a primeira linha
mostra a versão do módulo e o local onde está sendo instalado.

[email protected] /usr/lib/node_modules/express

ÿÿÿ [email protected] ÿÿÿ

[email protected] ÿÿÿ cookie-

[email protected] ÿÿÿ [email protected]
ÿÿÿ [email protected] ÿÿÿ cookie @0.1.2

ÿÿÿ [email protected] ÿÿÿ range-

[email protected] ÿÿÿ content-
[email protected] ÿÿÿ [email protected]

ÿÿÿ [email protected] ÿÿÿ [email protected]

ÿÿÿ [email protected] ÿÿÿ
[email protected] ÿÿÿ
[email protected] ÿÿÿ [email protected] ÿÿÿ on

[email protected] ([email protected])
ÿÿÿ [email protected] ([email protected]) ÿÿÿ
[email protected] ([email protected]) ÿÿÿ proxy-

[email protected] ([email protected],
[Link]@0.1.9) ÿÿÿ [email protected]
([email protected], [email protected], [email protected]) ÿÿÿ

[email protected] ([email protected]) ÿÿÿ

[email protected] ([email protected], mime-
[email protected])

ÿÿÿ
[email protected] ([email protected], [email protected])

13
Machine Translated by Google

[Link]

Você pode usar o seguinte comando para verificar todos os módulos instalados globalmente:

$ npm ls -g

Usando o [Link]
[Link] está presente no diretório raiz de qualquer aplicativo/módulo Node e é usado para definir as
propriedades de um pacote. Vamos abrir o [Link] do pacote express presente em node_modules/
express/

"nome": "expresso",

"description": "Framework web rápido, sem opinião e minimalista",

"versão": "4.11.2",

"autor": {

"nome": "TJ Holowaychuk",

"email": "tj@[Link]"

},

"colaboradores": [

{
"nome": "Aaron Heckmann",

"email": "[Link]+github@[Link]"

},

"name": "Ciaran Jessup",

"email": "ciaranj@[Link]"

},

"nome": "Douglas Christopher Wilson",

"email": "doug@[Link]"

},

{
"nome": "Guillermo Rauch",

"email": "rauchg@[Link]"

},

"nome": "Jonathan Ong",

"email": "me@[Link]"

},

14
Machine Translated by Google

[Link]

"name": "Roman Shtylman",

"email": "shtylman+expressjs@[Link]"

},

"name": "Jovem Jae Sim",

"email": "hanul@[Link]"

],

"licença": "MIT",

"repositório": {

"tipo": "git",

"url": "[Link]

},

"homepage": "[Link]

"palavras-chave": [

"expressar",

"estrutura",

"sinatra",

"rede",

"descanso",

"repousante",

"roteador",

"aplicativo",

"api"

],

"dependências": {

"aceita": "~1.2.3",

"disposição de conteúdo": "0.5.0",

"assinatura de cookie": "1.0.5",

"depurar": "~2.1.1",

"depd": "~1.0.0",

"escape-html": "1.0.1",

"etag": "~1.5.1",
"finalhandler": "0.3.3",

"fresco": "0.2.4",

"tipos de mídia": "0.3.0",

15
Machine Translated by Google

[Link]

"métodos": "~1.1.1",

"concluído": "~2.2.0",

"parserl": "~1.3.0",

"path-to-regexp": "0.1.3",

"proxy-addr": "~1.0.6",

"qs": "2.3.3",

"range-parser": "~1.0.2",
"enviar": "0.11.1",

"serve-static": "~1.8.1",

"type-is": "~1.5.6",

"variar": "~1.0.0",
"cookie": "0.1.2",

"merge-descriptors": "0.0.2",

"utils-merge": "1.0.0"

},

"devDependencies": {
"depois": "0.8.1",

"ejs": "2.1.4",
"istambul": "0.3.5",

"marcado": "0.3.3",

"mocha": "~2.1.0",

"deveria": "~4.6.2",

"superteste": "~ 0.15.0",

"hjs": "~ 0.0.6",

"body-parser": "~1.11.0",
"connect-redis": "~2.2.0",

"cookie-parser": "~1.3.3",

"express-session": "~1.10.2",

"jade": "~ 1.9.1",

"method-override": "~2.3.1",

"morgan": "~1.5.1",

"multipartidário": "~4.1.1",
"vhost": "~ 3.0.0"

},

"motores": {
"nó": ">= 0.10.0"

},
16
Machine Translated by Google

[Link]

"arquivos": [

"LICENÇA",

"Histó[Link]",

"[Link]",

"[Link]",
"lib/"

],

"roteiros": {

"test": "mocha --require test/support/env --reporter spec --bail –

teste de vazamentos/teste/aceitação/",

"test-cov": "istambul cobre node_modules/mocha/bin/_mocha -- --

require test/support/env --reporter dot --check-leaks test/

teste/aceitação/",

"test-tap": "mocha --require test/support/env --reporter tap –

teste de vazamentos/teste/aceitação/",

"test-travis": "istambul capa node_modules/mocha/bin/_mocha –

report lcovonly -- --require test/support/env --reporter spec –

teste de vazamentos/teste/aceitação/"

},

"gitHead": "63ab25579bda70b4927a179b580a9c580b6c7ada",

"insetos": {

"url": "[Link]

},

"_id": "[email protected]",

"_shasum": "8df3d5a9ac848585f00a07777601823faecd3b148",

"_from": "express@*",

"_npmVersion": "1.4.28",

"_npmUser": {

"nome": "dougwilson",

"email": "doug@[Link]"

},

"mantenedores": [

"nome": "tjholowaychuk",
17
Machine Translated by Google

[Link]

"email": "tj@[Link]"

},

"nome": "jongleberry",

"email": "jonathanrichardong@[Link]"

},

"name": "shtylman",

"email": "shtylman@[Link]"

},

"nome": "dougwilson",

"email": "doug@[Link]"

},

{
"nome": "aredridel",

"email": "aredridel@[Link]"

},

"nome": "strongloop",

"email": "callback@[Link]"

},

"nome": "rfeng",

"email": "enjoyjava@[Link]"

],

"dist": {
"shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
"tarball": "[Link]

},

"diretórios": {},
"_resolved": "[Link]
"readme": "ERRO: Nenhum dado README encontrado!"

18
Machine Translated by Google

[Link]

Atributos do [Link]
• nome - nome do pacote

• versão - versão do pacote

• descrição - descrição do pacote

• homepage - página inicial do pacote

• autor - autor do pacote

• contribuidores - nome dos contribuidores do pacote

• dependências - lista de dependências. O NPM instala automaticamente todas as dependências

mencionadas aqui na pasta node_module do pacote.

• repositório - tipo de repositório e URL do pacote

• main - ponto de entrada do pacote

• palavras -chave - palavras-chave

Desinstalando um módulo
Use o comando a seguir para desinstalar um módulo [Link].

$ npm desinstalar expresso

Depois que o NPM desinstala o pacote, você pode verificá-lo examinando o conteúdo do diretório /
node_modules/ ou digitando o seguinte comando:

$ npm ls

Atualizando um módulo
Atualize [Link] e altere a versão da dependência a ser atualizada e execute o comando a seguir.

$ npm atualização expressa

Pesquisar um módulo

Pesquise um nome de pacote usando o NPM.

$ npm pesquisa expressa

Criar um módulo
A criação de um módulo requer que o [Link] seja gerado. Vamos gerar o [Link] usando o
NPM, que irá gerar o esqueleto básico do [Link].
19
Machine Translated by Google

[Link]

$ npm inicial

Este utilitário orientará você na criação de um arquivo [Link].

Ele cobre apenas os itens mais comuns e tenta adivinhar padrões sãos.

Veja 'npm help json' para documentação definitiva sobre esses campos

e exatamente o que eles fazem.

Use 'npm install <pkg> --save' depois para instalar um pacote e

salve-o como uma dependência no arquivo [Link].

Pressione ^C a qualquer momento para sair.

nome: (webmaster)

Você precisará fornecer todas as informações necessárias sobre seu módulo. Você pode obter ajuda do
arquivo [Link] mencionado acima para entender os significados de várias informações exigidas. Depois
que o [Link] for gerado, use o comando a seguir para se registrar no site do repositório do NPM usando
um endereço de email válido.

$ npm adduser
Nome de usuário: mcmhd

Senha:

E-mail: (este é público) mcmohd@[Link]

Agora é hora de publicar seu módulo:

$ npm publicar

Se tudo estiver bem com seu módulo, ele será publicado no repositório e poderá ser instalado usando o NPM
como qualquer outro módulo [Link].

20
Machine Translated by Google

[Link]
6. Conceito de retorno de chamada

O que é retorno de chamada?

O retorno de chamada é um equivalente assíncrono para uma função. Uma função de retorno de chamada é
chamada na conclusão de uma determinada tarefa. Node faz uso pesado de callbacks. Todas as APIs do Node
são escritas de tal forma que suportam callbacks.

Por exemplo, uma função para ler um arquivo pode iniciar a leitura de um arquivo e retornar o controle ao ambiente
de execução imediatamente para que a próxima instrução possa ser executada. Quando a E/S do arquivo estiver
concluída, ele chamará a função de retorno de chamada enquanto passa a função de retorno de chamada, o
conteúdo do arquivo como parâmetro. Portanto, não há bloqueio ou espera por E/S de arquivo. Isso torna o [Link]
altamente escalável, pois pode processar um grande número de solicitações sem esperar que nenhuma função
retorne resultados.

Exemplo de código de bloqueio

Crie um arquivo de texto chamado [Link] com o seguinte conteúdo:

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

var dados = [Link]('[Link]');

[Link]([Link]());

[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Programa encerrado

21
Machine Translated by Google

[Link]

Exemplo de código sem bloqueio

Crie um arquivo de texto chamado [Link] com o conteúdo a seguir.

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Atualize [Link] para ter o seguinte código:

var fs = require("fs");

[Link]('[Link]', function (err, dados) {

if (err) return [Link](err);
[Link]([Link]());
});

[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Programa encerrado

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Esses dois exemplos explicam o conceito de chamadas com e sem bloqueio.

• O primeiro exemplo mostra que o programa bloqueia até ler o arquivo e só então prossegue para
finalizar o programa.

• O segundo exemplo mostra que o programa não espera a leitura do arquivo e passa a imprimir
"Program Ended" e ao mesmo tempo, o programa sem bloqueio continua lendo o arquivo.

Assim, um programa de bloqueio executa muito em sequência. Do ponto de vista da programação, é mais
fácil implementar a lógica, mas os programas não bloqueantes não são executados em sequência. Caso
um programa precise utilizar algum dado para ser processado, deve-se mantê-lo dentro do mesmo bloco
para que seja executado sequencialmente.

22
Machine Translated by Google

[Link]
7. Ciclo de Eventos

O [Link] é um aplicativo de thread único, mas pode oferecer suporte à simultaneidade por meio do conceito
de evento e retornos de chamada. Cada API do [Link] é assíncrona e de thread único, elas usam chamadas
de função assíncronas para manter a simultaneidade. O nó usa o padrão observador.
O thread do nó mantém um loop de eventos e sempre que uma tarefa é concluída, ele dispara o evento
correspondente que sinaliza a execução da função ouvinte de eventos.

Programação orientada a eventos

O [Link] usa eventos muito e é também uma das razões pelas quais o [Link] é bastante rápido em
comparação com outras tecnologias semelhantes. Assim que o Node inicia seu servidor, ele simplesmente
inicia suas variáveis, declara funções e então simplesmente espera que o evento ocorra.

Em um aplicativo orientado a eventos, geralmente há um loop principal que escuta eventos e, em seguida,
aciona uma função de retorno de chamada quando um desses eventos é detectado.

Embora os eventos pareçam bastante semelhantes aos retornos de chamada, a diferença está no fato de que
as funções de retorno de chamada são chamadas quando uma função assíncrona retorna seu resultado,
enquanto a manipulação de eventos funciona no padrão observador. As funções que escutam os eventos
atuam como Observadores. Sempre que um evento é acionado, sua função de ouvinte começa a ser
executada. O [Link] tem vários eventos integrados disponíveis por meio do módulo de eventos e da classe
EventEmitter que são usados para vincular eventos e ouvintes de eventos da seguinte forma:

// Importar módulo de eventos

var eventos = require('eventos');

// Cria um objeto eventEmitter

var eventEmitter = new [Link]();

23
Machine Translated by Google

[Link]

A seguir está a sintaxe para vincular um manipulador de eventos a um evento:

// Bind event e even handler da seguinte forma

[Link]('eventName', eventHandler);

Podemos disparar um evento programaticamente da seguinte forma:

// Dispara um evento

[Link]('eventName');

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

// Importar módulo de eventos

var eventos = require('eventos');

// Cria um objeto eventEmitter

var eventEmitter = new [Link]();

// Cria um manipulador de eventos da seguinte forma

var connectHandler = function conectado() {

[Link]('conexão bem sucedida.');

// Dispara o evento data_received

[Link]('data_received');

// Vincula o evento de conexão com o manipulador

[Link]('conexão', connectHandler);

// Vincula o evento data_received com a função anônima

[Link]('data_received', function(){

[Link]('dados recebidos com sucesso.');

});

// Dispara o evento de conexão

[Link]('conexão');

24
Machine Translated by Google

[Link]

[Link]("Programa Finalizado.");

Agora vamos tentar executar o programa acima e verificar sua saída:

$ mnode [Link]

Deve produzir o seguinte resultado:

conexão bem-sucedida.

dados recebidos com sucesso.

Programa encerrado.

Como funcionam os aplicativos de nó?

No Node Application, qualquer função assíncrona aceita um retorno de chamada como o último parâmetro e
uma função de retorno de chamada aceita um erro como o primeiro parâmetro. Vamos revisitar o exemplo
anterior novamente. Crie um arquivo de texto chamado [Link] com o conteúdo a seguir.

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]('[Link]', function (err, dados) {

se (erro){

[Link]([Link]);
Retorna;

[Link]([Link]());

});

[Link]("Programa Finalizado");

Aqui [Link]() é uma função assíncrona cujo propósito é ler um arquivo. Se ocorrer um erro durante a
operação de leitura, o objeto err conterá o erro correspondente, caso contrário, os dados conterão o conteúdo
do arquivo. readFile passa err e dados para a função de retorno de chamada após a conclusão da operação
de leitura, que finalmente imprime o conteúdo.

Programa encerrado

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

25
Machine Translated by Google

[Link]
8. Emissor de Eventos

Muitos objetos em um Node emitem eventos, por exemplo, um [Link] emite um evento cada vez que um peer se
conecta a ele, um [Link] emite um evento quando o arquivo é aberto. Todos os objetos que emitem eventos são
as instâncias de [Link].

Classe Emissora de Eventos

Como vimos na seção anterior, a classe EventEmitter está no módulo de eventos. É acessível através do seguinte código:

// Importar módulo de eventos

var eventos = require('eventos');

// Cria um objeto eventEmitter

var eventEmitter = new [Link]();

Quando uma instância de EventEmitter enfrenta algum erro, ela emite um evento de 'erro'. Quando um novo ouvinte é
adicionado, o evento 'newListener' é acionado e quando um ouvinte é removido, o evento 'removeListener' é acionado.

EventEmitter fornece várias propriedades como on e emit. on é usado para vincular uma função ao evento e emit é
usado para disparar um evento.

Métodos

[Link]. Método e Descrição

addListener(evento, ouvinte)

Adiciona um ouvinte no final da matriz de ouvintes para o evento especificado. Nenhuma verificação
1 é feita para ver se o ouvinte já foi adicionado. Várias chamadas passando a mesma combinação de
evento e ouvinte resultarão na adição do ouvinte várias vezes. Retorna o emissor, para que as
chamadas possam ser encadeadas.

on(evento, ouvinte)

Adiciona um ouvinte no final da matriz de ouvintes para o evento especificado. Nenhuma verificação
2 é feita para ver se o ouvinte já foi adicionado. Várias chamadas passando a mesma combinação de
evento e ouvinte resultarão na adição do ouvinte várias vezes. Retorna o emissor, para que as
chamadas possam ser encadeadas.

uma vez (evento, ouvinte)

Adiciona um ouvinte único ao evento. Este ouvinte é invocado apenas na próxima vez que o evento for
acionado, após o que será removido. Retorna o emissor, para que as chamadas possam ser encadeadas.
3

26
Machine Translated by Google

[Link]

removeListener(evento, ouvinte)

Remove um ouvinte da matriz de ouvintes para o evento especificado. Cuidado: Ele altera os
índices de matriz na matriz de ouvintes atrás do ouvinte. removeListener removerá, no
4 máximo, uma instância de um ouvinte da matriz de ouvintes. Se um único ouvinte tiver sido
adicionado várias vezes à matriz de ouvintes para o evento especificado, removeListener
deverá ser chamado várias vezes para remover cada instância. Retorna o emissor, para que
as chamadas possam ser encadeadas.

removeAllListeners([evento])
Remove todos os ouvintes ou os do evento especificado. Não é uma boa idéia remover ouvintes
5 que foram adicionados em outro lugar no código, especialmente quando está em um emissor
que você não criou (por exemplo, soquetes ou fluxos de arquivos). Retorna o emissor, para que
as chamadas possam ser encadeadas.

setMaxListeners(n)
Por padrão, EventEmitters imprimirá um aviso se mais de 10 ouvintes forem adicionados a
6
um determinado evento. Este é um padrão útil que ajuda a encontrar vazamentos de memória.
Obviamente nem todos os emissores devem ser limitados a 10. Esta função permite que isso
seja aumentado. Defina como zero para ilimitado.

ouvintes (evento)
7
Retorna uma matriz de ouvintes para o evento especificado.

emit(evento, [arg1], [arg2], [...])

8 Execute cada um dos ouvintes em ordem com os argumentos fornecidos. Retorna true se
o evento tiver ouvintes, caso contrário, false.

Métodos de classe

[Link]. Método e Descrição

1 listenerCount(emissor, evento)
Retorna o número de ouvintes para um determinado evento.

27
Machine Translated by Google

[Link]

Eventos

S. Não. Eventos e Descrição

novoOuvinte

• evento – String; o nome do evento

1 • ouvinte – Função; a função do manipulador de eventos

Este evento é emitido sempre que um ouvinte é adicionado. Quando este evento é acionado, o ouvinte

pode ainda não ter sido adicionado à matriz de ouvintes

para o evento.

removeListener

• event - String O nome do evento

• listener - Função A função do manipulador de eventos

2

Este evento é emitido sempre que alguém remove um ouvinte. Quando este evento é acionado, o ouvinte

pode ainda não ter sido removido do array de

ouvintes do evento.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código [Link]:

var eventos = require('eventos');

var eventEmitter = new [Link]();

// ouvinte #1

var listner1 = função listner1 () {

[Link]('listner1 executado.');

// ouvinte #2

var listner2 = função listner2 () {

[Link]('listner2 executado.');

28
Machine Translated by Google

[Link]

// Vincula o evento de conexão com a função listner1

[Link]('conexão', listner1);

// Vincula o evento de conexão com a função listner2

[Link]('conexão', listner2);

var eventListeners =
require('events').[Link](eventEmitter,'connection');

[Link](eventListeners + " Listner(es) ouvindo o evento de conexão");

// Dispara o evento de conexão

[Link]('conexão');

// Remove a ligação da função listner1

[Link]('conexão', listner1);

[Link]("Listner1 não escutará agora.");

// Dispara o evento de conexão

[Link]('conexão');

eventListeners =
require('eventos').[Link](eventEmitter,'connection');

[Link](eventListeners + " Listner(es) ouvindo o evento de conexão");

[Link]("Programa Finalizado.");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

2 Ouvintes ouvindo o evento de conexão

listner1 executado.

listner2 executado.

Listner1 não ouvirá agora.

listner2 executado.

1 Ouvinte(s) ouvindo o evento de conexão

Programa encerrado.

29
Machine Translated by Google

9. Tampões [Link]

O JavaScript puro é amigável para Unicode, mas não é assim para dados binários. Ao lidar com fluxos TCP
ou o sistema de arquivos, é necessário lidar com fluxos de octetos. Node fornece a classe Buffer que
fornece instâncias para armazenar dados brutos semelhantes a uma matriz de inteiros, mas corresponde a
uma alocação de memória bruta fora do heap V8.

A classe de buffer é uma classe global que pode ser acessada em um aplicativo sem importar o módulo de
buffer.

Criando buffers
Node Buffer pode ser construído de várias maneiras.

Método 1
A seguir está a sintaxe para criar um buffer não iniciado de 10 octetos:

var buff = new Buffer (10);

Método 2
A seguir está a sintaxe para criar um Buffer de um determinado array:

var buff = new Buffer ([10, 20, 30, 40, 50]);

Método 3
A seguir está a sintaxe para criar um Buffer de uma determinada string e opcionalmente tipo de codificação:

var buf = new Buffer("Aprendizagem Simples", "utf-8");

Embora "utf8" seja a codificação padrão, você pode usar qualquer uma das seguintes codificações "ascii",
"utf8", "utf16le", "ucs2", "base64" ou "hex".

Escrevendo em buffers

Sintaxe
A seguir está a sintaxe do método para gravar em um buffer de nó:

[Link](string[, offset][, length][, encoding])

30
Machine Translated by Google

[Link]

Parâmetros

Segue a descrição dos parâmetros utilizados:

• string - Estes são os dados de string a serem gravados no buffer. •

offset - Este é o índice do buffer para começar a escrever. O valor padrão é 0. • comprimento -
Este é o número de bytes a serem gravados. O padrão é [Link].
• codificação - Codificação a ser usada. 'utf8' é a codificação padrão.

Valor de retorno

Este método retorna o número de octetos gravados. Se não houver espaço suficiente no buffer para caber na
string inteira, ele gravará uma parte da string.

Exemplo

buff = new Buffer(256);

len = [Link]("Aprendizagem Simples Fácil");

[Link]("Octetos escritos: "+ len);

Quando o programa acima é executado, ele produz o seguinte resultado:

Octetos escritos: 20

Leitura de buffers
Sintaxe
A seguir está a sintaxe do método para ler dados de um Node Buffer:

[Link]([codificação][, início][, fim])

Parâmetros

Segue a descrição dos parâmetros utilizados:

• codificação - Codificação a ser usada. 'utf8' é a codificação padrão. •

start - Iniciando o índice para iniciar a leitura, o padrão é 0. • end -
Finalizando o índice para finalizar a leitura, o padrão é buffer completo.

Valor de retorno

Este método decodifica e retorna uma string de dados de buffer codificados usando a codificação do conjunto
de caracteres especificado.

31
Machine Translated by Google

[Link]

Exemplo

buff = new Buffer(26);

for (var i = 0; i <26; i ++) {
buf[i] = i + 97;

[Link]([Link]('ascii'));

// saídas: abcdefghijklmnopqrstuvwxyz
[Link]( [Link]('ascii',0,5));
// saídas: abcde
[Link]([Link]('utf8',0,5));

// saídas: abcde
[Link]([Link](undefined,0,5));
// codificação padrão para 'utf8', saídas abcde

Quando o programa acima é executado, ele produz o seguinte resultado:

aBCDeFGHIJKLMNopqRSTUVWxyZ

abcde

abcde

abcde

Converter buffer para JSON

Sintaxe

A seguir está a sintaxe do método para converter um Node Buffer em objeto JSON:

[Link]()

Valor de retorno

Esse método retorna uma representação JSON da instância Buffer.

Exemplo

var buf = new Buffer('Aprendizagem Simples Fácil');

var json = [Link](buf);

[Link](json);

Quando o programa acima é executado, ele produz o seguinte resultado:

32
Machine Translated by Google

[Link]

[83, 105, 109, 112, 108, 121, 32, 69, 97, 115, 121, 32, 76, 101, 97, 114, 110, 105, 110, 103]

Concatenar buffers

Sintaxe

A seguir está a sintaxe do método para concatenar buffers de nó em um único buffer de nó:

[Link](list[, totalLength])

Parâmetros

Segue a descrição dos parâmetros utilizados:

• list - Array List de objetos Buffer a serem concatenados. • totalLength

- Este é o comprimento total dos buffers quando concatenados.

Valor de retorno

Este método retorna uma instância de Buffer.

Exemplo

var buffer1 = new Buffer ('TutorialsPoint');

var buffer2 = new Buffer('Simply Easy Learning');

var buffer3 = [Link]([buffer1,buffer2]);

"
[Link]("buffer3 content: + [Link]());

Quando o programa acima é executado, ele produz o seguinte resultado:

conteúdo do buffer3: TutorialsPoint Simply Easy Learning

Comparar buffers

Sintaxe

A seguir está a sintaxe do método para comparar dois buffers de nó:

[Link](otherBuffer);

Parâmetros

Segue a descrição dos parâmetros utilizados:

33
Machine Translated by Google

[Link]

• otherBuffer - Este é o outro buffer que será comparado com o buff.

Valor de retorno

Retorna um número indicando se vem antes ou depois ou é igual ao otherBuffer na ordem de classificação.

Exemplo

var buffer1 = new Buffer('ABC');

var buffer2 = new Buffer('ABCD');

var resultado = [Link](buffer2);

if(resultado < 0) {

[Link](buffer1 +" vem antes de " + buffer2);

} senão if(resultado == 0){

"
[Link](buffer1 +" é o mesmo que + buffer2);

}senão {

[Link](buffer1 +" vem depois de " + buffer2);

Quando o programa acima é executado, ele produz o seguinte resultado:

ABC vem antes do ABCD

Copiar buffer

Sintaxe
A seguir está a sintaxe do método para copiar um buffer de nó:

[Link](targetBuffer[, targetStart][, sourceStart][, sourceEnd])

Parâmetros

Segue a descrição dos parâmetros utilizados:

• targetBuffer - Objeto de buffer onde o buffer será copiado.

• targetStart - Número, Opcional, Padrão: 0 • sourceStart

- Número, Opcional, Padrão: 0

• sourceEnd - Número, Opcional, Padrão: [Link]

34
Machine Translated by Google

[Link]

Valor de retorno

Sem valor de retorno. Copia dados de uma região desse buffer para uma região no buffer de destino,
mesmo que a região de memória de destino se sobreponha à origem. Se indefinido, os parâmetros
targetStart e sourceStart são padronizados para 0, enquanto sourceEnd é padronizado como [Link].

Exemplo

var buffer1 = new Buffer('ABC');

//copia um buffer

var buffer2 = novo Buffer (3);

[Link](buffer2);
"
[Link]("buffer2 content: + [Link]());

Quando o programa acima é executado, ele produz o seguinte resultado:

conteúdo do buffer2 : ABC

Buffer de fatia

Sintaxe

A seguir está a sintaxe do método para obter um subbuffer de um buffer de nó:

[Link]([início][, fim])

Parâmetros

Segue a descrição dos parâmetros utilizados:

• início - Número, Opcional, Padrão: 0

• end - Número, Opcional, Padrão: [Link]

Valor de retorno

Retorna um novo buffer que faz referência à mesma memória que o antigo, mas deslocado e cortado pelos
índices inicial (o padrão é 0) e final (o padrão é [Link]). Os índices negativos começam no final do buffer.

Exemplo

var buffer1 = new Buffer ('TutorialsPoint');

//cortando um buffer

var buffer2 = [Link] (0,9);

"
[Link]("buffer2 content: + [Link]());

35
Machine Translated by Google

[Link]

Quando o programa acima é executado, ele produz o seguinte resultado:

conteúdo do buffer2: tutoriais

Comprimento do buffer

Sintaxe
A seguir está a sintaxe do método para obter o tamanho de um buffer de nó em bytes:

[Link];

Valor de retorno

Retorna o tamanho de um buffer em bytes.

Exemplo

var buffer = new Buffer ('TutorialsPoint');

//comprimento do buffer

[Link]("comprimento do buffer: " + [Link]);

Quando o programa acima é executado, ele produz o seguinte resultado:

comprimento do buffer: 14

Referência de métodos

Segue uma referência do módulo Buffers disponível em [Link]. Para mais detalhes, você pode consultar a
documentação oficial.

S. Não. Método e Descrição

novo Buffer (tamanho)

1 Aloca um novo buffer de octetos de tamanho. Observe que o tamanho não deve ser maior que
kMaxLength. Caso contrário, um RangeError será lançado aqui.

2 novo buffer (buffer)

Copia os dados de buffer passados em uma nova instância de Buffer.

3 new Buffer(str[, codificação])

Aloca um novo buffer contendo o dado str. codificação padrão para 'utf8'.

[Link]
Retorna o tamanho do buffer em bytes. Observe que isso não é necessariamente o tamanho
4 do conteúdo. length refere-se à quantidade de memória alocada para o objeto de buffer. Ele
não muda quando o conteúdo do buffer é alterado.

36
Machine Translated by Google

[Link]

[Link](string[, offset][, length][, encoding])

Grava uma string no buffer no deslocamento usando a codificação fornecida. o padrão de deslocamento é 0,
5
o padrão de codificação é 'utf8'. comprimento é o número de bytes para escrever.
Retorna o número de octetos gravados.

[Link](valor, deslocamento, byteLength[, noAssert])

Grava um valor no buffer no deslocamento e byteLength especificados. Suporta até 48 bits de precisão.
6
Defina noAssert como true para ignorar a validação de valor e deslocamento. O padrão é falso.

[Link](valor, deslocamento, byteLength[, noAssert])

7 Grava um valor no buffer no deslocamento e byteLength especificados. Suporta até 48 bits de precisão.
Defina noAssert como true para ignorar a validação de valor e deslocamento. O padrão é falso.

[Link](valor, deslocamento, byteLength[, noAssert])

Grava um valor no buffer no deslocamento e byteLength especificados. Suporta até 48 bits de precisão.
8
Defina noAssert como true para ignorar a validação de valor e deslocamento. O padrão é falso.

[Link](valor, deslocamento, byteLength[, noAssert])

Grava um valor no buffer no deslocamento e byteLength especificados. Suporta até 48 bits de precisão.
9
Defina noAssert como true para ignorar a validação de valor e deslocamento. O padrão é falso.

[Link](offset, byteLength[, noAssert])

Uma versão generalizada de todos os métodos numéricos de leitura. Suporta até 48 bits de precisão.
10
Defina noAssert como true para ignorar a validação do deslocamento. Isso significa que o deslocamento
pode estar além do final do buffer. O padrão é falso.

[Link](deslocamento, byteLength[, noAssert])

Uma versão generalizada de todos os métodos numéricos de leitura. Suporta até 48 bits de precisão.
11
Defina noAssert como true para ignorar a validação do deslocamento. Isso significa que o deslocamento
pode estar além do final do buffer. O padrão é falso.

[Link](offset, byteLength[, noAssert])

12 Uma versão generalizada de todos os métodos numéricos de leitura. Suporta até 48 bits de precisão.
Defina noAssert como true para ignorar a validação do deslocamento. Isso significa que o deslocamento
pode estar além do final do buffer. O padrão é falso.

[Link](offset, byteLength[, noAssert])

Uma versão generalizada de todos os métodos numéricos de leitura. Suporta até 48 bits de precisão.
13
Defina noAssert como true para ignorar a validação do deslocamento. Isso significa que o deslocamento
pode estar além do final do buffer. O padrão é falso.

[Link]([codificação][, início][, fim])

14 Decodifica e retorna uma string de dados de buffer codificados usando a codificação do conjunto de
caracteres especificado.

[Link]()
15 Retorna uma representação JSON da instância Buffer. [Link] chama essa função
implicitamente ao stringificar uma instância de Buffer.

37
Machine Translated by Google

[Link]

buf[índice]
16 Obtenha e defina o octeto em index. Os valores referem-se a bytes individuais, portanto,
o intervalo legal é entre 0x00 e 0xFF hex ou 0 e 255.

17 [Link](otherBuffer)
Retorna um booleano se este buffer e otherBuffer tiverem os mesmos bytes.

[Link](otherBuffer)
18 Retorna um número indicando se esse buffer vem antes ou depois ou é igual ao otherBuffer
na ordem de classificação.

[Link](targetBuffer[, targetStart][, sourceStart][, sourceEnd])

Copia dados de uma região desse buffer para uma região no buffer de destino, mesmo que a
19 região de memória de destino se sobreponha à origem. Se indefinido, os parâmetros targetStart
e sourceStart são padronizados para 0, enquanto sourceEnd é padronizado como [Link].

[Link]([início][, fim])
20 Retorna um novo buffer que faz referência à mesma memória que o antigo, mas
deslocado e cortado pelos índices inicial (o padrão é 0) e final (o padrão é [Link]).
Os índices negativos começam no final do buffer.

buf.readUInt8(offset[, noAssert])
21 Lê um inteiro de 8 bits sem sinal do buffer no deslocamento especificado. Defina noAssert
como true para ignorar a validação do deslocamento. Isso significa que o deslocamento
pode estar além do final do buffer. O padrão é falso.

buf.readUInt16LE(offset[, noAssert])
22 Lê um inteiro de 16 bits sem sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento.
Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readUInt16BE(offset[, noAssert])
23 Lê um inteiro de 16 bits sem sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento.
Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readUInt32LE(offset[, noAssert])
24 Lê um inteiro de 32 bits sem sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento.
Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readUInt32BE(offset[, noAssert])
25 Lê um inteiro de 32 bits sem sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento.
Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readInt8(offset[, noAssert])
26 Lê um inteiro de 8 bits com sinal do buffer no deslocamento especificado. Defina
noAssert como true para ignorar a validação do deslocamento. Isso significa que o
deslocamento pode estar além do final do buffer. O padrão é falso.

27 buf.readInt16LE(offset[, noAssert])
Lê um inteiro de 16 bits com sinal do buffer no deslocamento especificado com o

38
Machine Translated by Google

[Link]

formato endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readInt16BE(offset[, noAssert])
28 Lê um inteiro de 16 bits com sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readInt32LE(offset[, noAssert])
29 Lê um inteiro de 32 bits com sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.readInt32BE(offset[, noAssert])
30 Lê um inteiro de 32 bits com sinal do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

[Link](offset[, noAssert])
31 Lê um float de 32 bits do buffer no deslocamento especificado com o formato endian
especificado. Defina noAssert como true para ignorar a validação do deslocamento. Significa o
deslocamento pode estar além do final do buffer. O padrão é falso.

[Link](offset[, noAssert])
32 Lê um float de 32 bits do buffer no deslocamento especificado com o formato endian
especificado. Defina noAssert como true para ignorar a validação do deslocamento. Significa o
deslocamento pode estar além do final do buffer. O padrão é falso.

[Link](offset[, noAssert])
33 Lê um duplo de 64 bits do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

[Link](offset[, noAssert])
34 Lê um duplo de 64 bits do buffer no deslocamento especificado com o formato
endian especificado. Defina noAssert como true para ignorar a validação do deslocamento. Isto
significa que o deslocamento pode estar além do final do buffer. O padrão é falso.

buf.writeUInt8(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado. Observe que o valor deve ser um
inteiro de 8 bits sem sinal válido. Defina noAssert como true para ignorar a validação de valor
35 e deslocamento. Isso significa que o valor pode ser muito grande para a função específica e o
deslocamento pode estar além do final do buffer, fazendo com que os valores sejam descartados
silenciosamente. Não deve ser usado a menos que você tenha certeza de sua exatidão. O
padrão é falso.

buf.writeUInt16LE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 16 bits sem sinal válido. Defina noAssert como
36 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

37 buf.writeUInt16BE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o endian especificado

39
Machine Translated by Google

[Link]

formato. Observe que o valor deve ser um inteiro de 16 bits sem sinal válido. Defina
noAssert como true para ignorar a validação de valor e deslocamento. Isso significa que
o valor pode ser muito grande para a função específica e o deslocamento pode estar além
do final do buffer, fazendo com que os valores sejam eliminados silenciosamente. Não
deve ser usado a menos que você tenha certeza de sua exatidão. O padrão é falso.

buf.writeUInt32LE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 32 bits sem sinal válido. Defina noAssert como
38 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

buf.writeUInt32BE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 32 bits sem sinal válido. Defina noAssert como
39 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

buf.writeInt8(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 8 bits com sinal válido. Defina noAssert como true
40 para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser muito
grande para a função específica e o deslocamento pode estar além do final do buffer, fazendo
com que os valores sejam eliminados silenciosamente. Não deve ser usado a menos que
você tenha certeza de sua exatidão. O padrão é falso.

buf.writeInt16LE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 16 bits com sinal válido. Defina noAssert como
41 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

buf.writeInt16BE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 16 bits com sinal válido. Defina noAssert como
42 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam descartados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

buf.writeInt32LE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um inteiro de 32 bits com sinal válido. Defina noAssert como
43 true para ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser
muito grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a
menos que você tenha certeza de sua exatidão. O padrão é falso.

44 buf.writeInt32BE(valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o endian especificado

40
Machine Translated by Google

[Link]

formato. Observe que o valor deve ser um inteiro de 32 bits com sinal válido. Defina
noAssert como true para ignorar a validação de valor e deslocamento. Isso significa que
o valor pode ser muito grande para a função específica e o deslocamento pode estar além
do final do buffer, fazendo com que os valores sejam eliminados silenciosamente. Não deve
ser usado a menos que você tenha certeza de sua exatidão. O padrão é falso.

[Link](valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um float de 32 bits válido. Defina noAssert como true para
45 ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser muito grande
para a função específica e o deslocamento pode estar além do final do buffer, fazendo com
que os valores sejam descartados silenciosamente. Não deve ser usado a menos que você
tenha certeza de sua exatidão. O padrão é falso.

[Link](valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um float de 32 bits válido. Defina noAssert como true para
46 ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser muito grande
para a função específica e o deslocamento pode estar além do final do buffer, fazendo com
que os valores sejam eliminados silenciosamente. Não deve ser usado a menos que você
tenha certeza de sua exatidão. O padrão é falso.

[Link](valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um duplo de 64 bits válido. Defina noAssert como true para
47 ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser muito grande
para a função específica e o deslocamento pode estar além do final do buffer, fazendo com
que os valores sejam descartados silenciosamente. Não deve ser usado a menos que você
tenha certeza de sua exatidão. O padrão é falso.

[Link](valor, deslocamento[, noAssert])

Grava um valor no buffer no deslocamento especificado com o formato endian especificado.
Observe que o valor deve ser um duplo de 64 bits válido. Defina noAssert como true para
48 ignorar a validação de valor e deslocamento. Isso significa que o valor pode ser muito
grande para a função específica e o deslocamento pode estar além do final do buffer,
fazendo com que os valores sejam eliminados silenciosamente. Não deve ser usado a menos
que você tenha certeza de sua exatidão. O padrão é falso.

[Link](valor[, deslocamento][, fim])

49 Preenche o buffer com o valor especificado. Se o deslocamento (o padrão é 0) e o final (o
padrão é [Link]) não forem fornecidos, ele preencherá todo o buffer.

Métodos de classe

[Link]. Método e Descrição

1 [Link](codificação)
Retorna true se a codificação for um argumento de codificação válido, false caso contrário.

2 [Link](obj)
Testa se obj é um Buffer.

41
Machine Translated by Google

[Link]

3 [Link](string[, codificação])
Fornece o comprimento real de bytes de uma string. codificação padrão para 'utf8'. Não é o mesmo
que [Link], pois [Link] retorna o número de caracteres em uma
string.

4 [Link](list[, totalLength])
Retorna um buffer que é o resultado da concatenação de todos os buffers da lista.

5 [Link](buf1, buf2)
O mesmo que [Link](buf2). Útil para classificar uma matriz de buffers.

42
Machine Translated by Google

10. Fluxos [Link]

O que são Streams?

Streams são objetos que permitem ler dados de uma origem ou gravar dados em um destino de maneira contínua. No
[Link], existem quatro tipos de streams:

• Legível - Fluxo que é usado para operação de leitura.

• Writable - Fluxo que é usado para operação de gravação.

• Duplex - Stream que pode ser usado para operação de leitura e gravação.

• Transform - Um tipo de fluxo duplex em que a saída é calculada com base em

entrada.

Cada tipo de Stream é uma instância EventEmitter e lança vários eventos em diferentes instâncias de tempos. Por exemplo,
alguns dos eventos comumente usados são:

• data - Este evento é acionado quando há dados disponíveis para leitura.

• end - Este evento é acionado quando não há mais dados para ler.

• error - Este evento é acionado quando ocorre algum erro ao receber ou gravar dados.

• Finish - Este evento é acionado quando todos os dados são liberados para o sistema subjacente.

Este tutorial fornece uma compreensão básica das operações comumente usadas no Streams.

Lendo de um stream
Crie um arquivo de texto chamado [Link] com o seguinte conteúdo:

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

var dados = '';

// Cria um fluxo legível

var readerStream = [Link]('[Link]');

// Defina a codificação como utf8.

43
Machine Translated by Google

[Link]

[Link]('UTF8');

// Manipula eventos de stream --> data, end e error

[Link]('data', function(chunk) {

dados += pedaço;

});

[Link]('end',function(){

[Link](dados);

});

[Link]('error', function(err){

[Link]([Link]);

});

[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Programa encerrado

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Gravando em um fluxo
Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

var data = 'Aprendizagem Simples Fácil';

// Cria um fluxo gravável

var writerStream = [Link]('[Link]');

// Grava os dados para stream com codificação para ser utf8

[Link](data,'UTF8');

44
Machine Translated by Google

[Link]

// Marca o final do arquivo

[Link]();

// Manipula eventos de stream --> finalização e erro

[Link]('finish', function() {

[Link]("Gravação concluída.");

});

[Link]('error', function(err){

[Link]([Link]);

});

[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Programa encerrado

Escrita concluída.

Agora abra [Link] criado em seu diretório atual; deve conter o seguinte:

Aprendizado Simplesmente Fácil

Canalizando os córregos

A tubulação é um mecanismo onde fornecemos a saída de um fluxo como entrada para outro fluxo. Normalmente é usado
para obter dados de um fluxo e passar a saída desse fluxo para outro fluxo. Não há limite nas operações de tubulação.
Agora vamos mostrar um exemplo de tubulação para ler de um arquivo e gravá-lo em outro arquivo.

Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

// Cria um fluxo legível

var readerStream = [Link]('[Link]');

// Cria um fluxo gravável

var writerStream = [Link]('[Link]');

45
Machine Translated by Google

[Link]

// Pipe as operações de leitura e escrita

// lê [Link] e grava dados em [Link]

[Link](writerStream);

[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Programa encerrado

Abra [Link] criado em seu diretório atual; deve conter o seguinte:

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Encadeando os fluxos
O encadeamento é um mecanismo para conectar a saída de um fluxo a outro fluxo e criar uma cadeia de várias
operações de fluxo. É normalmente usado com operações de tubulação. Agora usaremos tubulação e encadeamento
para primeiro compactar um arquivo e depois descompactá-lo.

Crie um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

var zlib = require('zlib');

// Compacta o arquivo [Link] para [Link]

[Link]('[Link]')

.pipe([Link]())

.pipe([Link]('[Link]'));

[Link]("Arquivo compactado.");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

46
Machine Translated by Google

[Link]

Arquivo compactado.

Você descobrirá que [Link] foi compactado e criou um arquivo [Link] no diretório atual. Agora vamos
tentar descompactar o mesmo arquivo usando o seguinte código:

var fs = require("fs");
var zlib = require('zlib');

// Descompacte o arquivo [Link] para [Link]

[Link]('[Link]')
.pipe([Link]())
.pipe([Link]('[Link]'));

[Link]("Arquivo descompactado.");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Arquivo descompactado.

47
Machine Translated by Google

[Link]
11. Sistema de arquivos

O Node implementa E/S de arquivo usando wrappers simples em torno de funções POSIX padrão. O módulo Node File
System (fs) pode ser importado usando a seguinte sintaxe:

ar fs = require("fs")

Síncrono vs Assíncrono
Cada método no módulo fs tem formulários síncronos e assíncronos.
Os métodos assíncronos usam o último parâmetro como o retorno de chamada da função de conclusão e o primeiro
parâmetro da função de retorno de chamada como erro. É melhor usar um método assíncrono em vez de um método
síncrono, pois o primeiro nunca bloqueia um programa durante sua execução, enquanto o segundo o faz.

Exemplo
Crie um arquivo de texto chamado [Link] com o seguinte conteúdo:

O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

// Leitura assíncrona

[Link]('[Link]', function (err, dados) {

se (erro) {

return [Link](err);

[Link]("Leitura assíncrona: " + [Link]());

});

// Leitura síncrona

var dados = [Link]('[Link]');

[Link]("Leitura síncrona: " + [Link]());

[Link]("Programa Finalizado");

48
Machine Translated by Google

[Link]

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Leitura síncrona: Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Programa encerrado

Leitura assíncrona: Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

As seções a seguir neste capítulo fornecem um conjunto de bons exemplos sobre os principais métodos de E/S
de arquivo.

Abra um arquivo

Sintaxe
A seguir está a sintaxe do método para abrir um arquivo no modo assíncrono:

[Link](path, flags[, mode], callback)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Esta é a string com o nome do arquivo incluindo o caminho.

• flags - Flags indicam o comportamento do arquivo a ser aberto. Todos os valores possíveis foram
mencionados abaixo.

• mode - Configura o modo do arquivo (permissão e bits fixos), mas somente se o arquivo foi criado. O
padrão é 0666, legível e gravável.

• callback - Esta é a função de callback que recebe dois argumentos (err, fd).

Bandeiras

Os sinalizadores para operações de leitura/gravação são:

Bandeira Descrição

r Abra o arquivo para leitura. Ocorre uma exceção se o arquivo não existir.

r+ Arquivo aberto para leitura e escrita. Ocorre uma exceção se o arquivo não existir.

49
Machine Translated by Google

[Link]

rs Arquivo aberto para leitura no modo síncrono.

Abra o arquivo para leitura e escrita, solicitando ao SO para abri-lo de forma síncrona. Veja as
rs+
notas para 'rs' sobre como usar isso com cuidado.

Abra o arquivo para escrita. O arquivo é criado (se não existir) ou truncado (se existir).
dentro

wx Como 'w', mas falha se o caminho existir.

Arquivo aberto para leitura e escrita. O arquivo é criado (se não existir) ou truncado (se existir).
em +

wx+ Como 'w+', mas falha se o caminho existir.

uma
Abra o arquivo para anexar. O arquivo é criado se não existir.

machado
Como 'a', mas falha se o caminho existir.

a+ Abra o arquivo para leitura e anexação. O arquivo é criado se não existir.

ax+ Como 'a+', mas falha se o caminho existir.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código para abrir um arquivo [Link] para
leitura e escrita.

var fs = require("fs");

// Assíncrono - Abrindo arquivo

[Link]("Indo para abrir o arquivo!");

[Link]('[Link]', 'r+', function(err, fd) {

se (erro) {
return [Link](err);
}

[Link]("Arquivo aberto com sucesso!");

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

50
Machine Translated by Google

[Link]

Verifique a saída.

Vai abrir o arquivo!

Arquivo aberto com sucesso!

Obter informações do arquivo

Sintaxe
A seguir está a sintaxe do método para obter as informações sobre um arquivo:

[Link](caminho, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Esta é a string com o nome do arquivo incluindo o caminho.

• callback - Esta é a função callback que recebe dois argumentos (err, stats) onde stats é um objeto
do tipo [Link] que é mostrado abaixo no exemplo.

Além dos atributos importantes que estão impressos abaixo no exemplo, existem vários métodos úteis
disponíveis na classe [Link] que podem ser usados para verificar o tipo de arquivo.
Esses métodos são fornecidos na tabela a seguir.

Método Descrição

[Link]() Retorna true se o tipo de arquivo for um arquivo simples.

[Link]() Retorna verdadeiro se o tipo de arquivo de um diretório.

[Link]() Retorna verdadeiro se o tipo de arquivo de um dispositivo de bloco.

[Link]() Retorna verdadeiro se o tipo de arquivo de um dispositivo de caractere.

[Link]() Retorna verdadeiro se o tipo de arquivo de um link simbólico.

[Link]() Retorna verdadeiro se o tipo de arquivo de um FIFO.

[Link]() Retorna verdadeiro se o tipo de arquivo de um soquete.

51
Machine Translated by Google

[Link]

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo para obter informações do arquivo!");

[Link]('[Link]', function (err, stats) {

se (erro) {

return [Link](err);

[Link](stats);

[Link]("Informações do arquivo obtidas com sucesso!");

//Verifica o tipo de arquivo

[Link]("isFile ?" + [Link]());

[Link]("isDirectory ? " + [Link]());

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para obter informações do arquivo!

{ desenvolvimento: 1792,

modo: 33188,

link: 1,

uid: 48,

gid: 48,
rdv: 0,

tamanho preto: 4096,

ino: 4318127,

tamanho: 97,

blocos: 8,

horário: Dom 22 de março de 2015 [Link] GMT-0500 (CDT),

mtime: Dom 22 de março de 2015 [Link] GMT-0500 (CDT),

ctime: Dom 22 de março de 2015 [Link] GMT-0500 (CDT) }

Informações do arquivo obtidas com sucesso!

52
Machine Translated by Google

[Link]

isFile ? verdadeiro

isDirectory ? falso

Escrevendo um arquivo

Sintaxe
A seguir está a sintaxe de um dos métodos para gravar em um arquivo:

[Link](nome do arquivo, dados[, opções], retorno de chamada)

Este método substituirá o arquivo se o arquivo já existir. Se você deseja gravar em um arquivo existente,
deve usar outro método disponível.

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Esta é a string com o nome do arquivo incluindo o caminho.

• data - Este é o String ou Buffer a ser escrito no arquivo. • opções - O

terceiro parâmetro é um objeto que conterá {encoding, mode, flag}.
Por padrão, a codificação é utf8, o modo é o valor octal 0666 e o sinalizador é 'w'

• retorno de chamada - Esta é a função de retorno de chamada que obtém um único parâmetro err que
retorna um erro em caso de qualquer erro de escrita.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo gravar em arquivo existente");

[Link]('[Link]', 'Aprendizagem simples!', function(err) {
se (erro) {
return [Link](err);
}
[Link]("Dados gravados com sucesso!");
[Link]("Vamos ler os dados recém-escritos");
[Link]('[Link]', function (err, dados) {
se (erro) {
return [Link](err);
}
[Link]("Leitura assíncrona: " + [Link]());
53
Machine Translated by Google

[Link]

});

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo gravar no arquivo existente

Dados gravados com sucesso!

Vamos ler dados recém-escritos

Leitura assíncrona: Aprendizado Simplesmente Fácil!

Lendo um arquivo

Sintaxe
A seguir está a sintaxe de um dos métodos para ler de um arquivo:

[Link](fd, buffer, offset, length, position, callback)

Este método usará o descritor de arquivo para ler o arquivo. Se você deseja ler o arquivo diretamente usando o nome do
arquivo, deve usar outro método disponível.

Parâmetros

Segue a descrição dos parâmetros utilizados:

• fd - Este é o descritor de arquivo retornado por [Link]().

• buffer - Este é o buffer no qual os dados serão gravados.

• offset - Este é o offset no buffer para começar a escrever.

• comprimento - Este é um número inteiro que especifica o número de bytes a serem lidos.

• position - Este é um número inteiro que especifica de onde começar a leitura no arquivo. Se a posição for nula, os
dados serão lidos da posição atual do arquivo.

• retorno de chamada - Esta é a função de retorno de chamada que obtém os três argumentos (err,
bytesRead, buffer).

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

54
Machine Translated by Google

[Link]

var fs = require("fs");
var buff = new Buffer (1024);

[Link]("Indo abrir um arquivo existente");

[Link]('[Link]', 'r+', function(err, fd) {
se (erro) {
return [Link](err);
}
[Link]("Arquivo aberto com sucesso!");
[Link]("Indo ler o arquivo");
[Link](fd, buf, 0, [Link], 0, function(err, bytes){
se (erro){
[Link](erro);
}
[Link](bytes + "bytes lidos");

// Imprime somente bytes lidos para evitar lixo.

if(bytes > 0){
[Link]([Link](0, bytes).toString());
}
});
});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para abrir um arquivo existente

Arquivo aberto com sucesso!
Indo ler o arquivo
97 bytes lidos
O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

55
Machine Translated by Google

[Link]

Arquivo de Fechamento

Sintaxe
A seguir está a sintaxe para fechar um arquivo aberto:

[Link](fd, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• fd - Este é o descritor de arquivo retornado por [Link]().

• retorno de chamada - Esta é a função de retorno de chamada. Nenhum argumento além de um possível
exceção são dadas ao retorno de chamada de conclusão.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");
var buff = new Buffer (1024);

[Link]("Indo abrir um arquivo existente");

[Link]('[Link]', 'r+', function(err, fd) {
se (erro) {
return [Link](err);
}
[Link]("Arquivo aberto com sucesso!");
[Link]("Indo ler o arquivo");
[Link](fd, buf, 0, [Link], 0, function(err, bytes){
se (erro){
[Link](erro);
}

// Imprime somente bytes lidos para evitar lixo.

if(bytes > 0){
[Link]([Link](0, bytes).toString());
}

// Fecha o arquivo aberto.

56
Machine Translated by Google

[Link]

[Link](fd, function(err){
se (erro){

[Link](erro);
}
[Link]("Arquivo fechado com sucesso.");
});
});
});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para abrir um arquivo existente

Arquivo aberto com sucesso!
Indo ler o arquivo
O Tutorials Point está fornecendo conteúdo de autoaprendizagem

para ensinar o mundo de forma simples e fácil!!!!!

Arquivo fechado com sucesso.

Truncar um arquivo

Sintaxe
A seguir está a sintaxe do método para truncar um arquivo aberto:

[Link](fd, len, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• fd - Este é o descritor de arquivo retornado por [Link]().

• len - Este é o comprimento do arquivo após o qual o arquivo será truncado.

• retorno de chamada - Esta é a função de retorno de chamada. Nenhum argumento além de um possível
exceção são dadas ao retorno de chamada de conclusão.

57
Machine Translated by Google

[Link]

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");
var buff = new Buffer (1024);

[Link]("Indo abrir um arquivo existente");

[Link]('[Link]', 'r+', function(err, fd) {
se (erro) {
return [Link](err);
}
[Link]("Arquivo aberto com sucesso!");
[Link]("Indo truncar o arquivo após 10 bytes");

//Trunca o arquivo aberto.

[Link](fd, 10, function(err){
se (erro){
[Link](erro);
}
[Link]("Arquivo truncado com sucesso.");
[Link]("Indo ler o mesmo arquivo");
[Link](fd, buf, 0, [Link], 0, function(err, bytes){
se (erro){
[Link](erro);
}

// Imprime somente bytes lidos para evitar lixo.

if(bytes > 0){
[Link]([Link](0, bytes).toString());
}

// Fecha o arquivo aberto.

[Link](fd, function(err){
se (erro){
[Link](erro);
}
[Link]("Arquivo fechado com sucesso.");

58
Machine Translated by Google

[Link]

});
});
});
});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para abrir um arquivo existente

Arquivo aberto com sucesso!
Indo truncar o arquivo após 10 bytes
Arquivo truncado com sucesso.
Indo ler o mesmo arquivo
Tutoriais

Arquivo fechado com sucesso.

Excluir um arquivo

Sintaxe
A seguir está a sintaxe do método para excluir um arquivo:

[Link](caminho, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Este é o nome do arquivo incluindo o caminho.

• retorno de chamada - Esta é a função de retorno de chamada. Nenhum argumento além de um possível
exceção são dadas ao retorno de chamada de conclusão.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo excluir um arquivo existente");

[Link]('[Link]', function(err) {
se (erro) {
59
Machine Translated by Google

[Link]

return [Link](err);
}
[Link]("Arquivo deletado com sucesso!");
});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para excluir um arquivo existente

Arquivo excluído com sucesso!

Criar um diretório

Sintaxe
A seguir está a sintaxe do método para criar um diretório:

[Link](caminho[, modo], retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Este é o nome do diretório incluindo o caminho.

• mode - Esta é a permissão de diretório a ser definida. O padrão é 0777.

• retorno de chamada - Esta é a função de retorno de chamada. Nenhum argumento além de um possível
exceção são dadas ao retorno de chamada de conclusão.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo para criar o diretório /tmp/test");

[Link]('/tmp/test',function(err){
se (erro) {
return [Link](err);
}
[Link]("Diretório criado com sucesso!");

60
Machine Translated by Google

[Link]

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo para criar o diretório /tmp/test

Diretório criado com sucesso!

Ler um diretório

Sintaxe
A seguir está a sintaxe do método para ler um diretório:

[Link](caminho, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Este é o nome do diretório incluindo o caminho.

• callback - Esta é a função callback que obtém dois argumentos (err, files) onde files é um array dos
nomes dos arquivos no diretório excluindo '.' e '..'.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo ler o diretório /tmp");

[Link]("/tmp/",function(err, arquivos){
se (erro) {
return [Link](err);
}
[Link]( função (arquivo){
[Link]( arquivo );
});
});

Agora execute o [Link] para ver o resultado:

61
Machine Translated by Google

[Link]

$ nó [Link]

Verifique a saída.

Indo ler o diretório /tmp

[Link]

[Link]

funcioná[Link]

hsperfdata_apache
teste

[Link]

Remover um diretório

Sintaxe
A seguir está a sintaxe do método para remover um diretório:

[Link](caminho, retorno de chamada)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• caminho - Este é o nome do diretório incluindo o caminho.

• retorno de chamada - Esta é a função de retorno de chamada. Nenhum argumento além de um possível
exceção são dadas ao retorno de chamada de conclusão.

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

var fs = require("fs");

[Link]("Indo para excluir o diretório /tmp/test");

[Link]("/tmp/teste",function(err){

se (erro) {

return [Link](err);

[Link]("Indo ler o diretório /tmp");

[Link]("/tmp/",function(err, arquivos){

se (erro) {

return [Link](err);
62
Machine Translated by Google

[Link]

[Link]( função (arquivo){

[Link]( arquivo );

});

});

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

Indo ler o diretório /tmp

[Link]

[Link]

funcioná[Link]

hsperfdata_apache
[Link]

Referência de métodos

A seguir está uma referência do módulo File System disponível em [Link]. Para mais detalhes, você pode
consultar a documentação oficial.

[Link]. Método e Descrição

[Link](oldPath, newPath, retorno de chamada)

1 Renomeação assíncrona(). Nenhum argumento além de uma possível exceção é fornecido ao
retorno de chamada de conclusão.

[Link](fd, len, retorno de chamada)

2 ftruncate() assíncrono. Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

3 [Link](fd, len)
Fruncate síncrono().

[Link](caminho, len, retorno de chamada)

4 Truncar assíncrono(). Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

5 [Link](caminho, len)
Truncamento síncrono().

[Link](caminho, uid, gid, retorno de chamada)

6 chown assíncrono(). Nenhum argumento além de uma possível exceção é fornecido ao
retorno de chamada de conclusão.

63
Machine Translated by Google

[Link]

7 [Link](caminho, uid, gid)

chown síncrono().

[Link](fd, uid, gid, callback)

8 fchown() assíncrono. Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

9 [Link](fd, uid, gid)

Fchown() síncrono.

[Link](caminho, uid, gid, retorno de chamada)

10 Assíncrono lchown(). Nenhum argumento além de uma possível exceção é fornecido ao
retorno de chamada de conclusão.

11 [Link](caminho, uid, gid)

lchown() síncrono.

[Link](caminho, modo, retorno de chamada)

12 chmod assíncrono(). Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

13 [Link](caminho, modo)
chmod síncrono().

[Link](fd, modo, retorno de chamada)

14 fchmod() assíncrono. Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

15 [Link](fd, modo)
fchmod() síncrono.

[Link](caminho, modo, retorno de chamada)

16 lchmod() assíncrono. Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão. Disponível apenas no Mac OS X.

17 [Link](caminho, modo)
lchmod() síncrono.

[Link](caminho, retorno de chamada)

18 estatística assíncrona(). O retorno de chamada recebe dois argumentos (err, stats) onde stats é um
objeto [Link].

[Link](caminho, retorno de chamada)

19 Assíncrono lstat(). O retorno de chamada recebe dois argumentos (err, stats) onde stats é
um objeto [Link]. lstat() é idêntico a stat(), exceto que se path for um link simbólico, então o link
em si é stat-ed, não o arquivo ao qual ele se refere.

[Link](fd, retorno de chamada)

20 fstat assíncrono(). O retorno de chamada recebe dois argumentos (err, stats) onde stats é
um objeto [Link]. fstat() é idêntico a stat(), exceto que o arquivo a ser stat-ed é especificado
pelo descritor de arquivo fd.

21 [Link](caminho)
Estatística síncrona(). Retorna uma instância de [Link].

64
Machine Translated by Google

[Link]

22 [Link](caminho)
lstat síncrono(). Retorna uma instância de [Link].

23 [Link](fd)
fstat síncrono(). Retorna uma instância de [Link].

[Link](srcpath, dstpath, callback)

24 Link assíncrono(). Nenhum argumento além de uma possível exceção é fornecido ao retorno de
chamada de conclusão.

25 [Link](srcpath, dstpath)
Link síncrono().

[Link](srcpath, dstpath[, tipo], retorno de chamada)

Link simbólico assíncrono(). Nenhum argumento além de uma possível exceção é fornecido ao
retorno de chamada de conclusão. O argumento de tipo pode ser definido como 'dir', 'arquivo' ou
26 'junção' (o padrão é 'arquivo') e está disponível apenas no Windows (ignorado em outras
plataformas). Observe que os pontos de junção do Windows exigem que o caminho de destino seja
absoluto. Ao usar 'junção', o argumento de destino será automaticamente normalizado para o
caminho absoluto.

27 [Link](srcpath, dstpath[, tipo])

Link simbólico síncrono().

[Link](caminho, retorno de chamada)

28
Readlink assíncrono(). O retorno de chamada obtém dois argumentos (err, linkString).

[Link](path[, cache], callback)

caminho real assíncrono(). O retorno de chamada obtém dois argumentos (err,
29 resolvidoPath). Pode usar [Link] para resolver caminhos relativos. cache é um objeto
literal de caminhos mapeados que pode ser usado para forçar uma resolução de caminho
específico ou evitar chamadas adicionais de [Link] para caminhos reais conhecidos.

30 [Link](caminho[, cache])
caminho real síncrono(). Retorna o caminho resolvido.

[Link](caminho, retorno de chamada)

31 Desvinculação assíncrona(). Nenhum argumento além de uma possível exceção é fornecido ao
retorno de chamada de conclusão.

32 [Link](caminho)
Desvinculação síncrona().

[Link](caminho, retorno de chamada)

33 Assíncrono rmdir(). Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão.

34 [Link](caminho)
rmdir síncrono().

[Link](caminho[, modo], retorno de chamada)

35 mkdir assíncrono(2). Nenhum argumento além de uma possível exceção é fornecido ao retorno
de chamada de conclusão. o modo padrão é 0777.

65
Machine Translated by Google

[Link]

36 [Link](caminho[, modo])
mkdir síncrono().

[Link](caminho, retorno de chamada)

37 readdir assíncrono(3). Lê o conteúdo de um diretório. O retorno de chamada obtém dois

argumentos (err, files) onde files é uma matriz dos nomes dos arquivos no diretório excluindo '.' e
'..'.

38 [Link](caminho)
readdir síncrono(). Retorna uma matriz de nomes de arquivos excluindo '.' e '..'.

[Link](fd, retorno de chamada)

39 Fechamento assíncrono(). Nenhum argumento além de uma possível exceção é fornecido
ao retorno de chamada de conclusão.

40 [Link](fd)
Fechamento síncrono().

41 [Link](path, flags[, mode], callback)

Arquivo assíncrono aberto.

42 [Link](caminho, sinalizadores[, modo])

Versão síncrona de [Link]().

43 [Link](caminho, atime, mtime, callback)

44 [Link](caminho, atime, mtime)

Altere os carimbos de data/hora do arquivo referenciado pelo caminho fornecido.

45 [Link](fd, atime, mtime, callback)

46 [Link](fd, atime, mtime)

Altere os registros de data e hora de um arquivo referenciado pelo descritor de arquivo fornecido.

[Link](fd, retorno de chamada)

47 Fsync assíncrono. Nenhum argumento além de uma possível exceção é fornecido ao retorno de
chamada de conclusão.

48 [Link](fd)
Fsync síncrono.

49 [Link](fd, buffer, offset, length[, position], callback)

Buffer de gravação para o arquivo especificado por fd.

[Link](fd, data[, position[, encoding]], callback)

50 Grava dados no arquivo especificado por fd. Se data não for uma instância de Buffer, o valor
será forçado a uma string.

51 [Link](fd, buffer, offset, length[, position])

Versões síncronas de [Link](). Retorna o número de bytes gravados.

52 [Link](fd, data[, position[, encoding]])

Versões síncronas de [Link](). Retorna o número de bytes gravados.

66
Machine Translated by Google

[Link]

53 [Link](fd, buffer, offset, length, position, callback)

Ler dados do arquivo especificado por fd.

54 [Link](fd, buffer, deslocamento, comprimento, posição)

Versão síncrona do [Link]. Retorna o número de bytesRead.

55 [Link](filename[, options], callback)

Lê de forma assíncrona todo o conteúdo de um arquivo.

56 [Link](nome do arquivo[, opções])

Versão síncrona de [Link]. Retorna o conteúdo do nome do arquivo.

[Link](nome do arquivo, dados[, opções], retorno de chamada)

57 Grava dados de forma assíncrona em um arquivo, substituindo o arquivo se ele já existir. os dados
podem ser uma string ou um buffer.

58 [Link](nome do arquivo, dados[, opções])

A versão síncrona de [Link].

[Link](filename, data[, options], callback)

59 Anexe dados de forma assíncrona a um arquivo, criando o arquivo se ele não existir. os dados podem
ser uma string ou um buffer.

60 [Link](nome do arquivo, dados[, opções])

A versão síncrona de [Link].

[Link](filename[, options], listener)

61 Observe as alterações no nome do arquivo. O ouvinte de retorno de chamada será chamado toda vez
que o arquivo for acessado.

[Link](nome do arquivo[, ouvinte])

62 Pare de observar as alterações no nome do arquivo. Se o listener for especificado, somente
esse listener específico será removido. Caso contrário, todos os ouvintes serão removidos e você
efetivamente parou de assistir ao nome do arquivo.

[Link](filename[, options][, listener])

63 Observe as alterações no nome do arquivo, onde o nome do arquivo é um arquivo ou um diretório.
O objeto retornado é um [Link].

[Link](caminho, retorno de chamada)

64 Teste se o caminho fornecido existe ou não verificando com o sistema de arquivos.
Em seguida, chame o argumento de retorno de chamada com true ou false.

65 [Link](caminho)
Versão síncrona de [Link].

[Link](path[, mode], callback)

66 Testa as permissões de um usuário para o arquivo especificado por caminho. mode é um inteiro
opcional que especifica as verificações de acessibilidade a serem executadas.

[Link](caminho[, modo])
67 Versão síncrona do [Link]. Ele é acionado se alguma verificação de acessibilidade falhar e não
faz nada de outra forma.

67
Machine Translated by Google

[Link]

68 [Link](caminho[, opções])
Retorna um novo objeto ReadStream.

69 [Link](caminho[, opções])
Retorna um novo objeto WriteStream.

[Link](srcpath, dstpath[, tipo], retorno de chamada)

Link simbólico assíncrono(). Nenhum argumento além de uma possível exceção é
fornecido ao retorno de chamada de conclusão. O argumento de tipo pode ser definido
70 como 'dir', 'arquivo' ou 'junção' (o padrão é 'arquivo') e está disponível apenas no Windows
(ignorado em outras plataformas). Observe que os pontos de junção do Windows exigem
que o caminho de destino seja absoluto. Ao usar 'junção', o argumento de destino será
automaticamente normalizado para o caminho absoluto.

68
Machine Translated by Google

12. Objetos Globais [Link]

Os objetos globais do [Link] são globais por natureza e estão disponíveis em todos os módulos. Não
precisamos incluir esses objetos em nosso aplicativo, mas podemos usá-los diretamente. Esses objetos
são módulos, funções, strings e o próprio objeto conforme explicado abaixo.

__nome do arquivo

O __filename representa o nome do arquivo do código que está sendo executado. Este é o caminho
absoluto resolvido deste arquivo de código. Para um programa principal, não é necessariamente o mesmo
nome de arquivo usado na linha de comando. O valor dentro de um módulo é o caminho para esse arquivo
de módulo.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

// Vamos tentar imprimir o valor de __filename

[Link]( __filename );

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Com base na localização do seu programa, ele imprimirá o nome do arquivo principal da seguinte forma:

/web/com/1427091028_21099/[Link]

__dirname
O __dirname representa o nome do diretório no qual o script atualmente em execução reside.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

// Vamos tentar imprimir o valor de __dirname

[Link]( __dirname );

Agora execute o [Link] para ver o resultado:

$ nó [Link]

69
Machine Translated by Google

[Link]

Com base na localização do seu programa, ele imprimirá o nome do diretório atual da seguinte maneira:

/web/com/1427091028_21099

setTimeout(cb, ms)
A função global setTimeout(cb, ms) é usada para executar o retorno de chamada cb após pelo menos ms
milissegundos. O atraso real depende de fatores externos, como granularidade do temporizador do sistema
operacional e carga do sistema. Um temporizador não pode abranger mais de 24,8 dias.

Esta função retorna um valor opaco que representa o timer que pode ser usado para limpar o timer.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

função imprimirOlá(){

[Link]("Olá, Mundo!");

// Agora chama a função acima após 2 segundos

setTimeout(printHello, 2000);

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique se a saída é impressa após um pequeno atraso.

Olá Mundo!

clearTimeout(t)
A função global clearTimeout(t) é usada para parar um cronômetro que foi criado anteriormente com setTimeout(). Aqui t
é o temporizador retornado pela função setTimeout().

Exemplo

Crie um arquivo js chamado [Link] com o seguinte código:

função imprimirOlá(){

[Link]("Olá, Mundo!");

// Agora chama a função acima após 2 segundos

var t = setTimeout(printHello, 2000);

70
Machine Translated by Google

[Link]

// Agora limpa o timer

clearTimeout(t);

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída onde você não encontrará nada impresso.

setInterval(cb, ms)
A função global setInterval(cb, ms) é usada para executar o callback cb repetidamente após pelo menos
ms milissegundos. O atraso real depende de fatores externos, como granularidade do temporizador do
sistema operacional e carga do sistema. Um temporizador não pode abranger mais de 24,8 dias.

Esta função retorna um valor opaco que representa o timer que pode ser usado para limpar o timer usando a função
clearInterval(t).

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

função imprimirOlá(){

[Link]("Olá, Mundo!");

// Agora chama a função acima após 2 segundos

setInterval(printHello, 2000);

Agora execute o [Link] para ver o resultado:

$ nó [Link]

O programa acima executará printHello() a cada 2 segundos. Devido à limitação do sistema, este programa não pode ser
executado com a opção Experimente para que você possa verificá-lo em sua máquina localmente.

Objetos Globais
A tabela a seguir fornece uma lista de outros objetos que usamos com frequência em nossos aplicativos. Para mais
detalhes, você pode consultar a documentação oficial.

[Link]. Nome e descrição do módulo

Console
1
Usado para imprimir informações sobre stdout e stderr.

71
Machine Translated by Google

[Link]

Processo
2 Usado para obter informações sobre o processo atual. Fornece vários eventos relacionados às
atividades do processo.

Objeto de console
O console [Link] é um objeto global e é usado para imprimir diferentes níveis de mensagens para stdout e stderr.
Existem métodos integrados a serem usados para imprimir mensagens informativas, de aviso e de erro.

É utilizado de forma síncrona quando o destino é um arquivo ou terminal e de forma assíncrona quando o destino é um
pipe.

Métodos de console

A seguir está uma lista de métodos disponíveis com o objeto global do console.

S. Não. Método e Descrição

[Link]([dados][, ...])
1 Imprime para stdout com nova linha. Esta função pode receber vários argumentos de maneira
semelhante a printf().

[Link]([dados][, ...])
2 Imprime para stdout com nova linha. Esta função pode receber vários argumentos de maneira
semelhante a printf().

[Link]([dados][, ...])
3 Imprime em stderr com nova linha. Esta função pode receber vários argumentos de maneira
semelhante a printf().

[Link]([dados][, ...])
4 Imprime em stderr com nova linha. Esta função pode receber vários argumentos de maneira
semelhante a printf()

[Link](obj[, opções])
5
Usa [Link] em obj e imprime a string resultante em stdout.

[Link](rótulo)
6
Marque um horário.

[Link](rótulo)
7
Termine o cronômetro, grave a saída.

72
Machine Translated by Google

[Link]

[Link](message[, ...])
8 Imprima para stderr 'Trace :', seguido pela mensagem formatada e rastreamento de pilha para a
posição atual.

[Link](valor[, mensagem][, ...])

9 Semelhante a [Link](), mas a mensagem de erro é formatada como
[Link](message...).

Exemplo
Vamos criar um arquivo js chamado [Link] com o seguinte código:

[Link]("Programa Iniciado");

var contador = 10;

[Link]("Contador: %d", contador);

[Link]("Obtendo dados");

//

// Faça algum processamento aqui...

//

[Link]('Obtendo dados');

[Link]("Programa Finalizado")

Agora execute o [Link] para ver o resultado:

nó [Link]

Verifique a saída.

Programa iniciado
Contador: 10

Obtendo dados: 0ms

Programa encerrado

73
Machine Translated by Google

[Link]

Objeto de processo

O objeto de processo é um objeto global e pode ser acessado de qualquer lugar. Existem vários métodos
disponíveis em um objeto de processo.

Eventos de Processo

O objeto de processo é uma instância de EventEmitter e emite os seguintes eventos:

S. Não. Descrição do Evento

saída

1 Emitido quando o processo está prestes a sair. Não há como impedir a saída do loop de
eventos neste ponto e, assim que todos os ouvintes de saída terminarem de ser executados,
o processo será encerrado.

antes de sair
Este evento é emitido quando o nó esvazia seu loop de eventos e não tem mais nada para
2 agendar. Normalmente, o nó sai quando não há trabalho agendado, mas um ouvinte para
'beforeExit' pode fazer chamadas assíncronas e fazer com que o nó continue.

Exceção não capturada

3 Emitido quando uma exceção borbulha de volta ao loop de eventos. Se um ouvinte for
adicionado para essa exceção, a ação padrão (que é imprimir um rastreamento de pilha e
sair) não ocorrerá.

4 Eventos de sinal
Emitido quando o processo recebe um sinal como SIGINT, SIGHUP, etc.

Exemplo

Crie um arquivo js chamado [Link] com o código a seguir para escutar o evento de saída :

[Link]('saída', function(código) {

// O código a seguir nunca será executado.

setTimeout(function(){
[Link]("Isto não será executado");
}, 0);

[Link]('Para sair com código:', código);

});
[Link]("Programa Finalizado");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

74
Machine Translated by Google

[Link]

Verifique a saída.

Programa encerrado

Prestes a sair com o código: 0

Códigos de saída

O nó normalmente sai com um código de status 0 quando não há mais operações assíncronas pendentes.
Existem outros códigos de saída descritos abaixo:

Código Nome e Descrição

Exceção Fatal Não Capturada

1 Houve uma exceção não capturada e não foi tratada por um domínio ou um manipulador de eventos
uncaughtException.

Não usado
2
reservado pelo Bash para uso indevido embutido.

Erro interno de análise de JavaScript

O código-fonte JavaScript interno no processo de inicialização do Node causou um erro de análise. Isso é
3
extremamente raro e geralmente só pode acontecer durante o desenvolvimento do próprio Node.

Falha na avaliação interna do JavaScript

4 O código-fonte JavaScript interno no processo de inicialização do Node falhou ao retornar um valor de

função quando avaliado. Isso é extremamente raro e geralmente só pode acontecer durante o
desenvolvimento do próprio Node.

Erro fatal
5 Houve um erro fatal irrecuperável no V8. Normalmente, uma mensagem será impressa em stderr com
o prefixo FATAL ERROR.

Manipulador de exceção interna sem função

6 Houve uma exceção não capturada, mas a função interna do manipulador de exceção fatal foi definida
como uma não função e não pôde ser chamada.

Falha em tempo de execução do manipulador de exceção interna

7 Houve uma exceção não capturada e a própria função interna do manipulador de exceção fatal gerou
um erro ao tentar tratá-la.

8 Não usado

Argumento inválido
9 Uma opção desconhecida foi especificada ou uma opção que requer um valor foi fornecida sem um valor.

Falha interna em tempo de execução do JavaScript

O código-fonte JavaScript interno no processo de inicialização do Node gerou um erro quando a função
10
de inicialização foi chamada. Isso é extremamente raro e geralmente só pode acontecer durante o
desenvolvimento do próprio Node.

75
Machine Translated by Google

[Link]

Argumento de depuração inválido

12 As opções --debug e/ou --debug-brk foram definidas, mas um número de porta inválido foi
escolhido.

Saídas de sinal
Se o Node receber um sinal fatal como SIGKILL ou SIGHUP, seu código de saída será 128 mais o valor do
>128 código do sinal. Esta é uma prática padrão do Unix, uma vez que os códigos de saída são definidos como
inteiros de 7 bits e as saídas de sinal definem o bit de ordem superior e, em seguida, contêm o valor do
código de sinal.

Propriedades do processo

O processo fornece muitas propriedades úteis para obter melhor controle sobre as interações do sistema.

S. Não. Descrição da Propriedade

padrão
1
Um fluxo gravável para stdout.

stderr
2
Um fluxo gravável para stderr.

padrão
3
Um fluxo gravável para stdin.

argv
Uma matriz contendo os argumentos da linha de comando. O primeiro elemento será 'node', o segundo
4
elemento será o nome do arquivo JavaScript. Os próximos elementos serão quaisquer argumentos de linha
de comando adicionais.

execPath
5
Este é o caminho absoluto do executável que iniciou o processo.

execArgv
6 Este é o conjunto de opções de linha de comando específicas do nó do executável que iniciou o processo.

env
7
Um objeto que contém o ambiente do usuário.

código de saída
8 Um número que será o código de saída do processo, quando o processo sair normalmente ou sair via
[Link]() sem especificar um código.

versão
9
Uma propriedade compilada que expõe NODE_VERSION.

versões
10
Uma propriedade que expõe as strings de versão do nó e suas dependências.

configuração

Um objeto contendo a representação JavaScript das opções de configuração que foram usadas para
11
compilar o executável do nó atual. Este é o mesmo que o arquivo "[Link]" que foi produzido ao executar
o script ./configure.

76
Machine Translated by Google

[Link]

pid
12
O PID do processo.

título
13
Getter/setter para definir o que é exibido em 'ps'.

arco
14
Qual arquitetura de processador você está executando: 'arm', 'ia32' ou 'x64'.

plataforma
15
Qual plataforma você está executando: 'darwin', 'freebsd', 'linux', 'sunos' ou 'win32'

módulo principal
Maneira alternativa de recuperar [Link]. A diferença é que, se o módulo principal for alterado em
16 tempo de execução, [Link] ainda poderá se referir ao módulo principal original em módulos que
foram necessários antes da ocorrência da alteração. Geralmente é seguro assumir que os dois se referem
ao mesmo módulo.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

// Imprimindo no console

[Link]("Olá Mundo!" + "\n");

// Lendo o parâmetro passado

[Link](function(val, index, array) {

[Link](index + ': ' + val);

});

// Obtendo o caminho executável

[Link]([Link]);

// Informações da plataforma

[Link]([Link]);

Agora execute o [Link] para ver o resultado:

$ nó [Link]

77
Machine Translated by Google

[Link]

Verifique a saída ao executar seu programa na máquina Linux:

Olá Mundo!

0: nó

1: /web/com/1427106219_25089/[Link]
/usr/bin/node
linux

Referência de Métodos

O processo fornece muitos métodos úteis para obter melhor controle sobre as interações do sistema.

[Link]. Método e Descrição

abortar()
1 Isso faz com que o nó emita um aborto. Isso faz com que o nó saia e gere um arquivo principal.

chdir (diretório)
2 Altera o diretório de trabalho atual do processo ou lança uma exceção se isso falhar.

3 cwd()
Retorna o diretório de trabalho atual do processo.

exit([código])
4 Finaliza o processo com o código especificado. Se omitido, exit usa o código de 'sucesso' 0.

getgid()
5 Obtém a identidade do grupo do processo. Este é o ID numérico do grupo, não o nome do grupo.
Esta função está disponível apenas em plataformas POSIX (ou seja, não Windows, Android).

setgid(id)
Define a identidade do grupo do processo (Veja setgid(2)). Ele aceita um ID numérico ou uma
6 string de nome de grupo. Se um nome de grupo for especificado, esse método será bloqueado
enquanto o resolve para um ID numérico. Esta função está disponível apenas em plataformas
POSIX (ou seja, não Windows, Android).

testemunha ()
7 Obtém a identidade do usuário do processo. Este é o id numérico, não o nome de usuário.
Esta função só está disponível em plataformas POSIX (ou seja, não Windows, Android).

setuid(id)
Define a identidade do usuário do processo (Veja setgid(2)). Ele aceita um ID numérico ou uma
8 string de nome de usuário. Se um nome de usuário for especificado, esse método será bloqueado
enquanto o resolve para um ID numérico. Esta função está disponível apenas em plataformas
POSIX (ou seja, não Windows, Android).

9 getgrupos()
Retorna uma matriz com os IDs de grupo suplementares. POSIX deixa não especificado

78
Machine Translated by Google

[Link]

se o ID do grupo efetivo for incluído, mas o [Link] garantirá que sempre seja. Esta função está disponível
apenas em plataformas POSIX (ou seja, não Windows, Android).

setgroups(grupos)
Define os IDs de grupo suplementares. Esta é uma operação privilegiada, o que implica que você precisa
10
estar na raiz ou ter o recurso CAP_SETGID. Esta função está disponível apenas em plataformas POSIX
(ou seja, não Windows, Android).

initgroups(usuário, extra_group)
Lê /etc/group e inicializa a lista de acesso do grupo, usando todos os grupos dos quais o usuário é
11 membro. Esta é uma operação privilegiada, o que implica que você precisa estar na raiz ou ter o recurso
CAP_SETGID. Esta função está disponível apenas em plataformas POSIX (ou seja, não Windows,
Android).

kill(pid[, sinal])
12 Envie um sinal para um processo. pid é o id do processo e signal é a string que descreve o sinal
a ser enviado. Os nomes dos sinais são strings como 'SIGINT' ou 'SIGHUP'. Se omitido, o sinal
será 'SIGTERM'.

uso de memória()
13 Retorna um objeto que descreve o uso de memória do processo Node medido em bytes.

nextTick(retorno de chamada)
14
Assim que o ciclo de eventos atual for concluído, chame a função de retorno de chamada.

umask([máscara])
Define ou lê a máscara de criação do modo de arquivo do processo. Os processos filho herdam a máscara
15
do processo pai. Retorna a máscara antiga se o argumento de máscara for fornecido, caso contrário,
retorna a máscara atual.

tempo de atividade()
16
Número de segundos que o Node está em execução.

hora ()
Retorna o tempo real atual de alta resolução em uma matriz de tuplas de [segundos, nanossegundos]. É
17 relativo a um tempo arbitrário no passado. Não está relacionado à hora do dia e, portanto, não está sujeito
ao desvio do relógio. O uso principal é para medir o desempenho entre intervalos.

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

// Imprime o diretório atual

[Link]('Diretório atual: ' + [Link]());

// Imprime a versão do processo

[Link]('Versão atual: ' + [Link]ão);

// Imprime o uso de memória

79
Machine Translated by Google

[Link]

[Link]([Link]());

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída ao executar seu programa na máquina Linux.

Diretório atual: /web/com/1427106219_25089

Versão atual: v0.10.33

{ rss: 11505664, heapTotal: 4083456, heapUsado: 2157704 }

80
Machine Translated by Google

[Link]
13. Módulos Utilitários

Existem vários módulos utilitários disponíveis na biblioteca de módulos [Link]. Esses módulos são muito comuns e são
frequentemente usados durante o desenvolvimento de qualquer aplicativo baseado em Node.

S. Não. Nome e descrição do módulo

1 OS Module

Fornece funções utilitárias básicas relacionadas ao sistema operacional.

2 Módulo de caminho

Fornece utilitários para manipular e transformar caminhos de arquivo.

3 Módulo de rede

Fornece servidores e clientes como fluxos. Atua como um wrapper de rede.

4 Módulo DNS

Fornece funções para fazer pesquisa de DNS real, bem como para usar as funcionalidades de

resolução de nomes do sistema operacional subjacente.

5 Módulo de domínio

Fornece maneiras de lidar com várias operações de E/S diferentes como um único grupo.

OS Module
O módulo [Link] os fornece algumas funções utilitárias básicas relacionadas ao sistema operacional. Este módulo pode
ser importado usando a seguinte sintaxe.

var os = require("os")

Métodos

S. Não. Método e Descrição

1 [Link]()
Retorna o diretório padrão do sistema operacional para arquivos temporários.

2 [Link]()
Retorna a endianidade da CPU. Os valores possíveis são "BE" ou "LE".

3 [Link]()
Retorna o nome do host do sistema operacional.

81
Machine Translated by Google

[Link]

4 [Link]()
Retorna o nome do sistema operacional.

5 [Link]()
Retorna a plataforma do sistema operacional.

6 [Link]()
Retorna a arquitetura de CPU do sistema operacional. Os valores possíveis são "x64", "arm" e
"ia32".

7 [Link]()
Retorna a versão do sistema operacional.

8 [Link]()
Retorna o tempo de atividade do sistema em segundos.

9 [Link]()
Retorna uma matriz contendo as médias de carga de 1, 5 e 15 minutos.

10 [Link]()
Retorna a quantidade total de memória do sistema em bytes.

11 [Link]()
Retorna a quantidade de memória livre do sistema em bytes.

12 [Link]()
Retorna uma matriz de objetos contendo informações sobre cada CPU/núcleo instalado: modelo,
velocidade (em MHz) e tempos (um objeto contendo o número de milissegundos que a CPU/
núcleo gastou em: user, nice, sys, idle e irq) .

13 [Link]()
Obtenha uma lista de interfaces de rede.

Propriedades

S. Não. Descrição da Propriedade

1 [Link]
Uma constante que define o marcador de fim de linha apropriado para o sistema operacional.

Exemplo

O exemplo a seguir demonstra alguns métodos de SO. Crie um arquivo js chamado [Link]
com o seguinte código.

var os = require("os");

// Endianidade
'
[Link]('endianness: + [Link]());

82
Machine Translated by Google

[Link]

// Tipo de SO

'
[Link]('type: + [Link]());

// plataforma do SO
'
[Link]('plataforma: + [Link]());

// Memória total do sistema

'
[Link]('memória total: + [Link]() + " bytes.");

// Memória livre total

'
[Link]('memória livre: + [Link]() + "bytes.");

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

endianness: LE

tipo: Linux

plataforma: linux

memória total: 25103400960 bytes.

memória livre: 20676710400 bytes.

Módulo de caminho

O módulo de caminho [Link] é usado para manipular e transformar caminhos de arquivo. Este módulo
pode ser importado usando a seguinte sintaxe.

var caminho = require("caminho")

Métodos

[Link]. Método e Descrição

1 [Link](p)
Normalize um caminho de string, cuidando de '..' e '.' partes.

2 [Link]([path1][, path2][, ...])

Junte todos os argumentos e normalize o caminho resultante.

83
Machine Translated by Google

[Link]

3 [Link]([de ...], para)

Resolve para um caminho absoluto.

[Link](caminho)
4 Determina se o caminho é um caminho absoluto. Um caminho absoluto sempre será resolvido
para o mesmo local, independentemente do diretório de trabalho.

5 [Link](de, para)
Resolva o caminho relativo de para até.

6 [Link](p)
Retorna o nome do diretório de um caminho. Semelhante ao comando Unix dirname .

7 [Link](p[, ext])
Retorna a última parte de um caminho. Semelhante ao comando Unix basename .

[Link](p)
8 Retorna a extensão do caminho, desde o último '.' para o final da string na última parte do caminho.
Se não há '.' na última parte do caminho ou o primeiro caractere dele é '.', então ele retorna uma
string vazia.

9 [Link](pathString)
Retorna um objeto de uma string de caminho.

10 [Link](pathObject)
Retorna uma string de caminho de um objeto, o oposto de [Link] acima.

Propriedades

S. Não. Descrição da Propriedade

1 [Link]
O separador de arquivos específico da plataforma. '\\' ou '/'.

2 [Link]
O delimitador de caminho específico da plataforma, ; ou ':'.

3 [Link]
Forneça acesso aos métodos de caminho mencionados, mas sempre interaja de maneira compatível
com posix.

4 caminho.win32
Forneça acesso aos métodos de caminho mencionados, mas sempre interaja de maneira compatível
com win32.

84
Machine Translated by Google

[Link]

Exemplo
Crie um arquivo js chamado [Link] com o seguinte código:

var caminho = require("caminho");

// Normalização
'
[Link]('normalization : [Link]('/ +
test/test1//2slashes/1slash/tab/..'));

// Junte-se
'
[Link]('caminho da junção: + [Link]('/teste', 'teste1', '2 barras/1 barra',
'tab', '..'));

// Resolve
'
[Link]('resolver: + [Link]('[Link]'));

// extName
'
[Link]('ext name: + [Link]('[Link]'));

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

normalização: /test/test1/2slashes/1slash

caminho de junção: /test/test1/2slashes/1slash

resolver: /web/com/1427176256_27423/[Link]

nome ext: .js

Módulo de rede

O módulo [Link] net é usado para criar servidores e clientes. Este módulo fornece um wrapper de rede assíncrono e
pode ser importado usando a seguinte sintaxe.

var net = exigir ("net")

Métodos

S. Não. Método e Descrição

85
Machine Translated by Google

[Link]

[Link]([opções][, connectionListener])
1 Cria um novo servidor TCP. O argumento connectionListener é definido automaticamente
como um ouvinte para o evento 'connection'.

[Link](opções[, connectionListener])
2 Um método de fábrica, que retorna um novo '[Link]' e se conecta ao endereço e porta
fornecidos.

[Link](options[, connectionListener])
3 Um método de fábrica, que retorna um novo '[Link]' e se conecta ao endereço e porta
fornecidos.

[Link](port[, host][, connectListener])

Cria uma conexão TCP para a porta no host. Se o host for omitido, 'localhost' será assumido. O
4
parâmetro connectListener será adicionado como listener para o evento 'connect'. É um método de
fábrica que retorna um novo '[Link]'.

[Link](port[, host][, connectListener])

Cria uma conexão TCP para a porta no host. Se o host for omitido, 'localhost' será assumido. O
5
parâmetro connectListener será adicionado como listener para o evento 'connect'. É um método de
fábrica que retorna um novo '[Link]'.

[Link](caminho[, connectListener])
Cria uma conexão de soquete Unix para o caminho. O parâmetro connectListener será adicionado como
6
listener para o evento 'connect'. É um método de fábrica que retorna um novo '[Link]'.

[Link](path[, connectListener])
Cria uma conexão de soquete Unix para o caminho. O parâmetro connectListener será adicionado como
7
listener para o evento 'connect'. É um método de fábrica que retorna um novo '[Link]'.

[Link] (entrada)
8 Testa se a entrada é um endereço IP. Retorna 0 para strings inválidas, 4 para endereços IP versão
4 e 6 para endereços IP versão 6.

net.isIPv4(entrada)
9
Retorna verdadeiro se a entrada for um endereço IP da versão 4, caso contrário, retorna falso.

net.isIPv6(entrada)
10
Retorna true se a entrada for um endereço IP da versão 6, caso contrário, retorna false.

Classe –[Link]
Esta classe é usada para criar um servidor TCP ou local.

Métodos

[Link]. Método e Descrição

1 [Link](port[, host][, backlog][, callback])

Comece a aceitar conexões na porta e no host especificados. Se o hospedeiro for

86
Machine Translated by Google

[Link]

omitido, o servidor aceitará conexões direcionadas a qualquer endereço IPv4

(INADDR_ANY). Um valor de porta zero atribuirá uma porta aleatória.

2 [Link](path[, callback])
Inicie um servidor de soquete local escutando conexões no caminho fornecido.

[Link](handle[, callback])
O objeto handle pode ser definido como um servidor ou soquete (qualquer coisa com um
3 membro _handle subjacente) ou um objeto {fd: <n>}. Isso fará com que o servidor aceite
conexões no identificador especificado, mas presume-se que o descritor ou identificador de
arquivo já foi vinculado a uma porta ou soquete de domínio.
A escuta em um descritor de arquivo não é compatível com o Windows.

[Link](options[, callback])
As propriedades port, host e backlog das opções, bem como a função de retorno de
4 chamada opcional, se comportam como em uma chamada para [Link](port, [host],
[backlog], [callback]) . Alternativamente, a opção de caminho pode ser usada para especificar
um soquete UNIX.

[Link]([retorno de chamada])
5 Finalmente fechado quando todas as conexões são encerradas e o servidor emite um evento
'close'.

endereço do servidor()
6 Retorna o endereço vinculado, o nome da família de endereços e a porta do servidor
conforme relatado pelo sistema operacional.

[Link]()
7 Chamar unref em um servidor permitirá que o programa saia se este for o único servidor
ativo no sistema de eventos. Se o servidor já não for refd, então
chamar unref novamente não terá efeito.

[Link]()
8 Ao contrário de unref, chamar ref em um servidor não refd anteriormente não permitirá que
o programa saia se for o único servidor restante (o comportamento padrão). Se o servidor for
refd, chamar o ref novamente não terá efeito.

[Link](retorno de chamada)
9 Obtenha de forma assíncrona o número de conexões simultâneas no servidor.
Funciona quando os soquetes foram enviados para garfos. O retorno de chamada deve receber dois
argumentos err e count.

Eventos

S. Não. Eventos e Descrição

1 ouvindo
Emitido quando o servidor foi vinculado após chamar [Link].

conexão
2 Emitido quando uma nova conexão é feita. Objeto de soquete, o objeto de conexão está
disponível para o manipulador de eventos. Socket é uma instância de [Link].

87
Machine Translated by Google

[Link]

perto
3 Emitido quando o servidor fecha. Observe que, se houver conexões, esse evento não será emitido
até que todas as conexões sejam encerradas.

erro
4 Emitido quando ocorre um erro. O evento 'close' será chamado diretamente após este evento.

Classe –[Link]

Este objeto é uma abstração de um soquete TCP ou local. As instâncias [Link] implementam uma interface
Stream duplex. Eles podem ser criados pelo usuário e usados como cliente (com connect()) ou podem ser criados
pelo Node e passados ao usuário através do evento 'connection' de um servidor.

Eventos

[Link] é um eventEmitter e emite os seguintes eventos.

S. Não. Eventos e Descrição

olho para cima

1 Emitido após resolver o nome do host, mas antes de conectar. Não aplicável a soquetes UNIX.

conectar
2
Emitido quando uma conexão de soquete é estabelecida com sucesso.

dados
3 Emitido quando os dados são recebidos. Os dados do argumento serão um Buffer ou String.
A codificação de dados é definida por [Link]().

fim
4
Emitido quando a outra extremidade do soquete envia um pacote FIN.

tempo esgotado
5 Emitido se o soquete atingir o tempo limite de inatividade. Isso é apenas para notificar que o soquete
está ocioso. O usuário deve fechar manualmente a conexão.

ralo
6
Emitido quando o buffer de gravação fica vazio. Pode ser usado para acelerar uploads.

erro
7 Emitido quando ocorre um erro. O evento 'close' será chamado diretamente após este evento.

perto
8 Emitido quando o soquete está totalmente fechado. O argumento had_error é um booleano que
indica se o socket foi fechado devido a um erro de transmissão.

Propriedades

[Link] fornece muitas propriedades úteis para obter melhor controle sobre as interações de soquete.

88
Machine Translated by Google

[Link]

S. Não. Descrição da Propriedade

1 [Link]
Esta propriedade mostra o número de caracteres atualmente armazenados em buffer para serem gravados.

2 [Link]
A representação de string do endereço IP remoto. Por exemplo, '[Link]' ou
'[Link]'.

3 [Link]
A representação de string da família de IP remoto. 'IPv4' ou 'IPv6'.

4 [Link]
A representação numérica da porta remota. Por exemplo, 80 ou 21.

5 [Link]
A representação de string do endereço IP local ao qual o cliente remoto está se conectando.
Por exemplo, se você estiver ouvindo em '[Link]' e o cliente se conectar em '[Link]', o
valor será '[Link]'.

6 [Link]
A representação numérica da porta local. Por exemplo, 80 ou 21.

7 [Link]
A quantidade de bytes recebidos.

8 [Link]
A quantidade de bytes enviados.

Métodos
S. Não. Método e Descrição

1 new [Link]([opções])
Construa um novo objeto de soquete.

[Link](port[, host][, connectListener])

Abre a conexão para um determinado soquete. Se a porta e o host forem fornecidos, o
2 soquete será aberto como um soquete TCP, se o host for omitido, o localhost será assumido.
Se um caminho for fornecido, o soquete será aberto como um soquete Unix para esse caminho.

[Link](path[, connectListener])
Abre a conexão para um determinado soquete. Se a porta e o host forem fornecidos, o
3 soquete será aberto como um soquete TCP, se o host for omitido, o localhost será assumido.
Se um caminho for fornecido, o soquete será aberto como um soquete Unix para esse caminho.

4 [Link]([codificação])
Defina a codificação para o soquete como um fluxo legível.

[Link](data[, encoding][, callback])

5 Envia dados no soquete. O segundo parâmetro especifica a codificação no caso de uma
string -- o padrão é a codificação UTF8.

89
Machine Translated by Google

[Link]

[Link]([dados][, codificação])
6 Fecha o socket pela metade, ou seja, envia um pacote FIN. É possível que o servidor ainda envie
alguns dados.

[Link]()
7 Garante que nenhuma atividade de E/S ocorra neste soquete. Necessário apenas em caso de erros
(erro de análise ou algo assim).

[Link]()
8 Pausa a leitura dos dados. Ou seja, eventos de 'dados' não serão emitidos. Útil para atrasar um upload.

[Link]()
9
Retoma a leitura após uma chamada para pause().

[Link](timeout[, callback])
10 Define o soquete para o tempo limite após o tempo limite de milissegundos de inatividade no
soquete. Por padrão, o [Link] não tem tempo limite.

[Link] ([noDelay])
Desativa o algoritmo Nagle. Por padrão, as conexões TCP usam o algoritmo Nagle, armazenam
11 os dados em buffer antes de enviá-los. Definir true para noDelay disparará imediatamente os dados
cada vez que [Link]() for chamado. O padrão noDelay é true.

[Link]([enable][, initialDelay])
12 Ative/desative a funcionalidade keep-alive e, opcionalmente, defina o atraso inicial antes que o
primeiro probe keepalive seja enviado em um soquete ocioso. habilitar os padrões para false.

[Link]ço()
Retorna o endereço associado, o nome da família de endereços e a porta do soquete conforme
13
relatado pelo sistema operacional. Retorna um objeto com três propriedades, por exemplo { port:
12346, family: 'IPv4', address: '[Link]' }.

[Link]()
14 Chamar unref em um soquete permitirá que o programa saia se este for o único soquete ativo no
sistema de eventos. Se o soquete já não for refd, então
chamar unref novamente não terá efeito.

[Link]()
15 Ao contrário de unref, chamar ref em um soquete não refd anteriormente não permitirá que o
programa saia se for o único soquete restante (o comportamento padrão). Se o soquete for refd, chamar
ref novamente não terá efeito.

Exemplo

Crie um arquivo js chamado [Link] com o seguinte código:

Arquivo: [Link]
90
Machine Translated by Google

[Link]

var net = exigir('net');

var server = [Link](function(connection) {
[Link]('cliente conectado');
[Link]('fim', function() {
[Link]('cliente desconectado');
});
[Link]('Olá Mundo!\r\n');
conexã[Link](conexão);
});
[Link](8080, function() {
[Link]('servidor está escutando');
});

Agora execute o [Link] para ver o resultado:

$ node [Link]

Verifique a saída.

servidor está ouvindo

Crie um arquivo js chamado [Link] com o seguinte código:

Arquivo: [Link]

var net = exigir('net');

var cliente = [Link]({porta: 8080}, function() {
[Link]('conectado ao servidor!');
});
[Link]('dados', function(dados) {
[Link]([Link]());
[Link]();
});
[Link]('fim', function() {
[Link]('desconectado do servidor');
});

Agora execute o [Link] de outro terminal para ver o resultado:

$ node [Link]

Verifique a saída.

91
Machine Translated by Google

[Link]

conectado ao servidor!

Olá Mundo!

Desconectado do servidor

Verifique a saída no terminal em que o [Link] está sendo executado.

servidor está ouvindo

cliente conectado

cliente desconectado

Módulo DNS
O módulo dns do [Link] é usado para fazer a pesquisa de DNS real, bem como para usar as funcionalidades de
resolução de nomes do sistema operacional subjacente. Este módulo fornece um wrapper de rede assíncrono e pode
ser importado usando a seguinte sintaxe.

var dns = require("dns")

Métodos

S. Não. Método e Descrição

[Link](hostname[, options], callback)

Resolve um nome de host (por exemplo, '[Link]') no primeiro registro A (IPv4) ou AAAA (IPv6)
1 encontrado. as opções podem ser um objeto ou um inteiro. Se as opções não forem fornecidas, os
endereços IP v4 e v6 serão válidos. Se options for um número inteiro, então deve ser 4 ou 6.

[Link](endereço, porta, retorno de chamada)

2 Resolve o endereço e a porta fornecidos em um nome de host e serviço usando getnameinfo.

[Link](hostname[, rrtype], callback)

3 Resolve um nome de host (por exemplo, '[Link]') em uma matriz dos tipos de registro
especificados por rrtype.

dns.resolve4(nome do host, retorno de chamada)

4 O mesmo que [Link](), mas apenas para consultas IPv4 (registros A). endereços
é uma matriz de endereços IPv4 (por exemplo, ['[Link]', '[Link]',
'[Link]']).

5 dns.resolve6(nome do host, retorno de chamada)

O mesmo que dns.resolve4(), exceto para consultas IPv6 (uma consulta AAAA).

6 [Link](nome do host, retorno de chamada)

O mesmo que [Link](), mas apenas para consultas de troca de correio (registros MX).

7 [Link](nome do host, retorno de chamada)

O mesmo que [Link](), mas apenas para consultas de texto (registros TXT).
92
Machine Translated by Google

[Link]

address é uma matriz 2-d dos registros de texto disponíveis para o nome do host (por exemplo, [ ['v=spf1
ip4:[Link] ', '~all' ] ]). Cada sub-matriz contém pedaços TXT de um registro. Dependendo do caso de uso,
eles podem ser unidos ou tratados separadamente.

[Link](nome do host, retorno de chamada)

O mesmo que [Link](), mas apenas para registros de serviço (registros SRV). endereços é
8 uma matriz dos registros SRV disponíveis para o nome do host. As propriedades dos registros SRV são
prioridade, peso, porta e nome (por exemplo, [{'priority': 10, 'weight': 5, 'port': 21223, 'name':
'[Link]'}, . ..]).

[Link](hostname, callback)
9 O mesmo que [Link](), mas apenas para consultas de registro de início de autoridade (registro SOA).

[Link](nome do host, retorno de chamada)

O mesmo que [Link](), mas apenas para registros de servidor de nomes (registros NS). address é
10
uma matriz dos registros do servidor de nomes disponíveis para o nome do host (por exemplo,
['[Link]', '[Link]']).

[Link](nome do host, retorno de chamada)

11 O mesmo que [Link](), mas apenas para registros de nomes canônicos (registros CNAME).
endereços é uma matriz dos registros de nomes canônicos disponíveis para o nome do host (por
exemplo, ['[Link]']).

12 [Link](ip, retorno de chamada)

Reverse resolve um endereço IP para uma matriz de nomes de host.

[Link]()
13 Retorna uma matriz de endereços IP como strings que estão sendo usadas atualmente para resolução.

[Link](servidores)
14 Dada uma matriz de endereços IP como strings, defina-os como os servidores a serem usados para resolver.

rrtypes
A seguir está a lista de rrtypes válidos usados pelo método [Link]():

• A - endereços IPV4, padrão

• Endereços AAAA - IPV6

• MX - registros de troca de correio

• TXT - registros de texto

• SRV - registros SRV

• PTR - usado para pesquisas reversas de IP

• NS - registros do servidor de nomes

• CNAME - registros de nomes canônicos

• SOA - início do registro de autoridade

93
Machine Translated by Google

[Link]

Códigos de erro

Cada consulta DNS pode retornar um dos seguintes códigos de erro:

• [Link] - O servidor DNS retornou a resposta sem dados.

• [Link] - A consulta de declarações do servidor DNS foi formatada

incorretamente. • [Link] - O servidor DNS retornou uma falha geral.

• [Link] - Nome de domínio não encontrado.

• [Link] - O servidor DNS não implementa a operação solicitada.

• [Link] - consulta recusada pelo servidor DNS.

• [Link] - Consulta DNS mal formatada.

• [Link] - Nome de host mal formatado.

• [Link] - Família de endereços não suportada.

• [Link] - Resposta DNS mal formatada.

• [Link] - Não foi possível contatar os servidores DNS.

• [Link] - Tempo limite ao contatar servidores DNS.

• [Link] - Fim do arquivo.

• [Link] - Erro ao ler o arquivo.

• [Link] - Memória insuficiente.

• [Link] - O canal está sendo destruído. • [Link] -

Cadeia de caracteres mal formatada.

• [Link] - Sinalizadores ilegais especificados.

• [Link] - O nome do host fornecido não é numérico.

• [Link] - Sinalizadores de dicas ilegais especificados.

• [Link] - inicialização da biblioteca c-ares ainda não realizada. • [Link]

- Erro ao carregar [Link].

• [Link] - Não foi possível localizar a função GetNetworkParams.

• [Link] - consulta DNS cancelada.

Exemplo

Crie um arquivo js chamado [Link] com o seguinte código:

var dns = require('dns');

[Link]('[Link]', function onLookup(err, address, family) {

94
Machine Translated by Google

[Link]

[Link]('endereço:', endereço);

[Link](endereço, função (erro, nomes de host) {

se (erro) {

[Link]([Link]);

[Link]('reverse para ' + endereço + ': ' + [Link](hostnames));

});

});

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

endereço: [Link]

inverter para [Link]: ["[Link]"]

Módulo de domínio
O módulo de domínio [Link] é usado para interceptar erros não tratados. Esses erros não tratados podem ser
interceptados usando ligação interna ou ligação externa. Se os erros não forem tratados,
então eles simplesmente travarão o aplicativo Node.

• Internal Binding - O emissor de erro está executando seu código dentro do método run de um
domínio.

• Ligação Externa - O emissor de erro é adicionado explicitamente a um domínio usando seu add
método.

Este módulo pode ser importado usando a seguinte sintaxe.

var domínio = require("domínio")

A classe de domínio do módulo de domínio é usada para fornecer a funcionalidade de erros de roteamento e exceções
não capturadas para o objeto Domínio ativo. É uma classe filha de EventEmitter. Para lidar com os erros que ele detecta,
ouça seu evento de erro. Ele é criado usando a seguinte sintaxe:

var domínio = require("domínio");

var filho = domí[Link]();

Métodos

S. Não. Método e Descrição

95
Machine Translated by Google

[Link]

domí[Link](função)
1 Execute a função fornecida no contexto do domínio, vinculando implicitamente todos os emissores
de eventos, temporizadores e solicitações de baixo nível criados nesse contexto.
Essa é a maneira mais básica de usar um domínio.

domí[Link](emissor)
2 Adiciona explicitamente um emissor ao domínio. Se algum manipulador de eventos chamado pelo
emissor lançar um erro, ou se o emissor emitir um evento de erro, ele será roteado para o evento
de erro do domínio, assim como na ligação implícita.

domí[Link](emissor)
3 O oposto de [Link](emissor). Remove a manipulação de domínio do emissor especificado.

domí[Link](retorno de chamada)
4 A função retornada será um wrapper em torno da função de retorno de chamada fornecida.
Quando a função retornada é chamada, qualquer erro gerado será roteado para o evento de erro
do domínio.

[Link](retorno de chamada)
5 Este método é quase idêntico ao [Link](callback). No entanto, além de capturar erros
lançados, ele também interceptará objetos Error enviados como o primeiro argumento para a
função.

domí[Link]()
O método enter é o encanamento usado pelos métodos run, bind e intercept para definir o domínio
ativo. Ele define [Link] e [Link] para o domínio e, implicitamente, envia o
6 domínio para a pilha de domínio gerenciada pelo módulo de domínio (consulte [Link]() para
obter detalhes sobre a pilha de domínio). A chamada para enter delimita o início de uma cadeia
de chamadas assíncronas e operações de E/S vinculadas a um domínio.

domí[Link]ída()
O método exit sai do domínio atual, retirando-o da pilha de domínios.
Sempre que a execução alterna para o contexto de uma cadeia diferente de chamadas
7
assíncronas, é importante garantir que o domínio atual seja encerrado.
A chamada para sair delimita o fim ou uma interrupção na cadeia de chamadas assíncronas e
operações de E/S vinculadas a um domínio.

domí[Link]()
8 Depois que o descarte for chamado, o domínio não será mais usado por retornos de chamada
vinculados ao domínio por meio de execução, ligação ou interceptação, e um evento de descarte será emitido

Propriedades

S. Não. Propriedade < & Descrição

[Link]
1 Uma matriz de temporizadores e emissores de eventos que foram explicitamente adicionados ao
domínio.

Exemplo

Crie um arquivo js chamado [Link] com o seguinte código:

96
Machine Translated by Google

[Link]

var EventEmitter = require("eventos").EventEmitter;

var domínio = require("domínio");

var emissor1 = new EventEmitter();

//Cria um domínio

var domínio1 = domí[Link]();

[Link]('erro', function(err){
[Link]("domain1 lidou com este erro ("+[Link]+")");
});

// Ligação explícita
domí[Link](emissor1);

[Link]('erro',function(err){
[Link]("ouvinte lidou com este erro ("+[Link]+")");
});

[Link]('error',new Error('A ser tratado pelo ouvinte'));

[Link]('error');

[Link]('error',new Error('A ser tratado pelo domínio1'));

var domínio2 = domí[Link]();

[Link]('erro', function(err){

[Link]("domain2 lidou com este erro ("+[Link]+")");

});

// Ligação implícita

[Link](function(){
var emissor2 = new EventEmitter();
[Link]('error',new Error('A ser tratado pelo domínio2'));

});

97
Machine Translated by Google

[Link]

domí[Link](emissor1);

[Link]('error', new Error('Convertido em exceção. O sistema irá travar!'));

Agora execute o [Link] para ver o resultado:

$ nó [Link]

Verifique a saída.

listener lidou com este erro (A ser tratado pelo listener)

domain1 lidou com este erro (a ser tratado por domain1)

domain2 lidou com este erro (a ser tratado por domain2)

[Link]

jogue er; // Evento 'erro' não tratado

^

Erro: convertido em exceção. O sistema irá travar!

em Object.<anonymous> (C:\Nodejs_WorkSpace\[Link]:23)

em Module._compile ([Link]:26)

em [Link]._extensions..js ([Link]:10)

em [Link] ([Link]:32)

em [Link]._load ([Link]:12)

em [Link] ([Link]:10)

na inicialização ([Link]:16)

em [Link]:3

98
Machine Translated by Google

14. Módulo Web [Link]

O que é um servidor web?

Um servidor Web é um aplicativo de software que lida com solicitações HTTP enviadas pelo cliente HTTP, como
navegadores da Web, e retorna páginas da Web em resposta aos clientes. Os servidores da Web geralmente entregam
documentos html junto com imagens, folhas de estilo e scripts.

A maioria dos servidores da web suporta scripts do lado do servidor, usando linguagens de script ou redirecionando a
tarefa para um servidor de aplicativos que recupera dados de um banco de dados e
executa lógica complexa e, em seguida, envia um resultado para o cliente HTTP por meio do servidor Web.

O servidor web Apache é um dos servidores web mais usados. É um projeto de código aberto.

Arquitetura de aplicativos da Web

Um aplicativo da Web geralmente é dividido em quatro camadas:

• Cliente - Esta camada consiste em navegadores da web, navegadores móveis ou aplicativos que
pode fazer solicitações HTTP para o servidor web.

• Servidor - Esta camada possui o servidor Web que pode interceptar as solicitações feitas pelos clientes e passar
a resposta.

• Negócios - Esta camada contém o servidor de aplicativos que é utilizado pelo servidor web para fazer o
processamento necessário. Essa camada interage com a camada de dados por meio do banco de dados ou de
alguns programas externos.

• Dados - Esta camada contém os bancos de dados ou qualquer outra fonte de dados.

99
Machine Translated by Google

[Link]

Criando um servidor Web usando o Node

[Link] fornece um módulo http que pode ser usado para criar um cliente HTTP de um servidor.
A seguir está a estrutura mínima do servidor HTTP que escuta na porta 8081.

Crie um arquivo js chamado [Link]:

Arquivo: [Link]

var http = require('http');

var fs = require('fs');

var url = require('url');

//Cria um servidor

[Link]( function (solicitação, resposta) {

// Analisa a requisição contendo o nome do arquivo

var pathname = [Link]([Link]).pathname;

// Imprime o nome do arquivo para o qual a solicitação é feita.

[Link]("Pedido para " + nome do caminho + " recebido.");

// Lê o conteúdo do arquivo solicitado do sistema de arquivos

[Link]([Link](1), function (err, data) {

se (erro) {

[Link](erro);
// Status HTTP: 404 : NÃO ENCONTRADO

// Tipo de conteúdo: text/plain

[Link](404, {'Content-Type': 'text/html'});

}senão{

//Página encontrada

// Status HTTP: 200 : OK

// Tipo de conteúdo: text/plain

[Link](200, {'Content-Type': 'text/html'});

// Grava o conteúdo do arquivo no corpo da resposta

[Link]([Link]());
}

//Envia o corpo da resposta

[Link]();
100
Machine Translated by Google

[Link]

});

}).listen(8081);

// O console imprimirá a mensagem

[Link]('Servidor rodando em [Link]

Em seguida, vamos criar o seguinte arquivo html chamado [Link] no mesmo diretório em que você criou
o [Link]

Arquivo: [Link]

<html>

<cabeça>

<title>Página de amostra</title>
</head>

<corpo>
Olá Mundo!

</body>
</html>

Agora vamos executar o [Link] para ver o resultado:

$ node [Link]

Verifique a saída.

Servidor rodando em [Link]

101
Machine Translated by Google

[Link]

Faça uma solicitação ao servidor [Link]

Abra [Link] em qualquer navegador para ver o seguinte resultado.

Verifique a saída na extremidade do servidor.

Servidor rodando em [Link]

Pedido para /[Link] recebido.

Criando um cliente Web usando o Node

Um cliente web pode ser criado usando o módulo http . Vamos verificar o seguinte exemplo.

Crie um arquivo js chamado [Link]:

Arquivo: [Link]

var http = require('http');

// Opções a serem usadas por solicitação

var opções = {
host: 'localhost',

porta: '8081',
caminho: '/[Link]'
};

// A função de retorno de chamada é usada para lidar com a resposta

var callback = function(resposta){

// Atualiza continuamente o fluxo com dados

var corpo = '';

102
Machine Translated by Google

[Link]

[Link]('dados', function(dados) {

corpo += dados;

});

[Link]('fim', function() {

// Dados recebidos completamente.

[Link](corpo);

});

// Faz uma requisição ao servidor

var req = [Link](opções, retorno de chamada);

[Link]();

Agora execute o [Link] a partir de um terminal de comando diferente do [Link] para ver o resultado:

$ node [Link]

Verifique a saída.

<html>

<cabeça>

<title>Página de amostra</title>
</head>

<corpo>
Olá Mundo!

</body>
</html>

Verifique a saída na extremidade do servidor.

Servidor rodando em [Link]

Pedido para /[Link] recebido.

103
Machine Translated by Google

15. Estrutura Expressa [Link]

Visão geral expressa

O Express é uma estrutura de aplicativo da Web [Link] mínima e flexível que fornece um conjunto robusto de
recursos para desenvolver aplicativos da Web e móveis. Ele facilita o desenvolvimento rápido de aplicativos da
Web baseados em Node. A seguir estão alguns dos principais recursos do framework Express:

• Permite configurar middlewares para responder a solicitações HTTP.

• Define uma tabela de roteamento que é usada para executar diferentes ações baseadas em HTTP
Método e URL.

• Permite renderizar dinamicamente páginas HTML com base na passagem de argumentos para
modelos.

Instalando o Expresso
Em primeiro lugar, instale o framework Express globalmente usando o NPM para que ele possa ser usado para
criar um aplicativo da Web usando o terminal do nó.

$ npm install express --save

O comando acima salva a instalação localmente no diretório node_modules e cria um diretório expresso dentro
de node_modules. Você deve instalar os seguintes módulos importantes junto com o express:

• body-parser - Este é um middleware [Link] para lidar com JSON, Raw, Text e URL
dados de formulário codificados.

• cookie-parser - Analisa o cabeçalho Cookie e preenche [Link] com um objeto

codificados pelos nomes dos cookies.

• multer - Este é um middleware [Link] para manipulação de dados multipart/form-data.

$ npm install body-parser --save

$ npm instala o analisador de cookies --save

$ npm install multer --save

Olá mundo Exemplo

A seguir está um aplicativo Express muito básico que inicia um servidor e escuta na porta 3000 para conexão.
Este aplicativo responde com Hello World! para solicitações à página inicial. Para todos os outros caminhos, ele
responderá com um 404 Not Found.

104
Machine Translated by Google

[Link]

var expresso = require('expresso');

var app = expresso();

[Link]('/', function (req, res) {

[Link]('Olá Mundo');
})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Salve o código acima em um arquivo chamado [Link] e execute-o com o comando a seguir.

$ node [Link]

Você verá a seguinte saída:

Aplicativo de exemplo ouvindo em [Link]

Abra [Link] em qualquer navegador para ver o seguinte resultado.

105
Machine Translated by Google

[Link]

Solicitação e resposta

O aplicativo expresso usa objetos de função de retorno de chamada cujos parâmetros são
solicitação e resposta .

[Link]('/', function (req, res) {

// --

})

• Objeto de solicitação - O objeto de solicitação representa a solicitação HTTP e possui propriedades para a string
de consulta da solicitação, parâmetros, corpo, cabeçalhos HTTP etc.
em.

• Objeto de Resposta - O objeto de resposta representa a resposta HTTP que um

O aplicativo expresso envia quando recebe uma solicitação HTTP.

Você pode imprimir objetos req e res que fornecem muitas informações relacionadas à solicitação e resposta HTTP,
incluindo cookies, sessões, URL, etc.

Objeto de solicitação

O objeto req representa a solicitação HTTP e possui propriedades para a string de consulta da solicitação, parâmetros,
corpo, cabeçalhos HTTP e assim por diante.

Solicitar propriedades do objeto

A seguir está a lista de algumas propriedades associadas ao objeto de solicitação.

S. Não. Propriedades e Descrição

[Link]
1 Essa propriedade contém uma referência à instância do aplicativo expresso que está usando o middleware.

2 [Link]
O caminho de URL no qual uma instância de roteador foi montada.

[Link]
Contém pares de valores-chave de dados enviados no corpo da solicitação. Por padrão, é indefinido e é
3
preenchido quando você usa middleware de análise de corpo, como body-parser

[Link]
4 Ao usar o middleware do analisador de cookies, essa propriedade é um objeto que contém os cookies
enviados pela solicitação.

[Link]
5
Indica se a solicitação é "fresca". É o oposto de [Link].

6 [Link] do host
Contém o nome do host do cabeçalho HTTP "Host".

106
Machine Translated by Google

[Link]

[Link]
7
O endereço IP remoto da solicitação.

[Link]
8 Quando a configuração do proxy de confiança for verdadeira, essa propriedade conterá uma matriz
de endereços IP especificados no cabeçalho da solicitação “X-Forwarded-For”.

[Link]
9 Esta propriedade é muito parecida com [Link]; no entanto, ele retém o URL de solicitação original,
permitindo que você reescreva [Link] livremente para fins de roteamento interno.

[Link]
Um objeto contendo propriedades mapeadas para os “parâmetros” da rota nomeada. Por exemplo, se
10
você tiver a rota /user/:name, a propriedade "name" estará disponível como [Link]. Esse objeto
é padronizado para {}.

11
caminho req
Contém a parte do caminho da URL de solicitação.

[Link]
12
A string do protocolo de solicitação, "http" ou "https" quando solicitado com TLS.

[Link]
13
Um objeto que contém uma propriedade para cada parâmetro de string de consulta na rota.

[Link]
14
A rota atualmente correspondente, uma string.

[Link]
15
Um booleano que é verdadeiro se uma conexão TLS for estabelecida.

[Link]
16 Ao usar o middleware do analisador de cookies, esta propriedade contém cookies assinados enviados
pela solicitação, não assinados e prontos para uso.

17 [Link]
Indica se a solicitação está "obsoleta" e é o oposto de [Link].

[Link]ínios
18
Uma matriz de subdomínios no nome de domínio da solicitação.

[Link]
Um valor booleano que é verdadeiro se o campo de cabeçalho "X-Requested-With" da solicitação for
19
"XMLHttpRequest", indicando que a solicitação foi emitida por uma biblioteca cliente, como jQuery

Métodos de objeto de solicitação

[Link](tipos)
[Link](tipos)

Esse método verifica se os tipos de conteúdo especificados são aceitáveis, com base no campo de cabeçalho Aceitar HTTP
da solicitação. Seguem alguns exemplos:
107
Machine Translated by Google

[Link]

// Aceita: texto/html
[Link]('html');
// => "html"

// Aceita: text/*, application/json

[Link]('html');
// => "html"

[Link]('texto/html');
// => "texto/html"

[Link](campo)

[Link](campo)

Este método retorna o campo de cabeçalho de solicitação HTTP especificado. Seguem alguns exemplos:

[Link]('Tipo de conteúdo');
// => "texto/simples"

[Link]('tipo de conteúdo');
// => "texto/simples"

[Link]('Algo');
// => indefinido

[Link](tipo)

[Link](tipo)

Esse método retornará true se o campo de cabeçalho HTTP "Content-Type" da solicitação recebida
corresponder ao tipo MIME especificado pelo parâmetro type. Seguem alguns exemplos:

// Com tipo de conteúdo: text/html; charset=utf-8

[Link]('html');
[Link]('texto/html');
[Link]('texto/*');
// => verdadeiro

108
Machine Translated by Google

[Link]

[Link](nome [, defaultValue])

[Link](nome [, defaultValue])

Este método retorna o valor do nome do parâmetro quando presente. Seguem alguns exemplos:

// ?name=tobi

[Link]('nome')

// => "grande"

// POST nome=tobi

[Link]('nome')

// => "grande"

// /usuário/tobi para /usuário/:nome

[Link]('nome')

// => "grande"

Objeto de resposta
O objeto res representa a resposta HTTP que um aplicativo Express envia quando recebe uma solicitação HTTP.

Propriedades do objeto de resposta

A seguir está a lista de algumas propriedades associadas ao objeto de resposta.

S. Não. Propriedades e Descrição

[Link]
1 Essa propriedade contém uma referência à instância do aplicativo expresso que está usando o middleware.

[Link]
2
Propriedade booleana que indica se o aplicativo enviou cabeçalhos HTTP para a resposta.

[Link]
3
Um objeto que contém variáveis locais de resposta com escopo para a solicitação.

Métodos de objeto de resposta

[Link](campo [, valor])

[Link](campo [, valor])

Este método anexa o valor especificado ao campo de cabeçalho de resposta HTTP. Seguem alguns exemplos:

109
Machine Translated by Google

[Link]

[Link]('Link', ['<[Link] '<[Link]

[Link]('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
[Link]('Aviso', '199 Avisos diversos');

[Link]([nome do arquivo])

[Link]([nome do arquivo])

Este método é usado para enviar um arquivo como anexo na resposta HTTP. Seguem alguns exemplos:

[Link]('caminho/para/[Link]');

[Link](nome, valor [, opções])

[Link](nome, valor [, opções])

Este método é usado para definir o nome do cookie como valor. O parâmetro value pode ser uma string
ou objeto convertido em JSON. Seguem alguns exemplos:

[Link]('name', 'tobi', { domain: '.[Link]', caminho: '/admin', secure: true });

[Link]('cart', { itens: [1,2,3] });

[Link]('cart', { items: [1,2,3] }, { maxAge: 900000 });

[Link](nome [, opções])

[Link](nome [, opções])

Este método é usado para limpar o cookie especificado pelo nome. Seguem alguns exemplos:

[Link]('nome', 'tobi', { caminho: '/admin' });

[Link]('nome', { caminho: '/admin' });

[Link](caminho [, nome do arquivo] [, fn])

[Link](caminho [, nome do arquivo] [, fn])

Este método é usado para transferir o arquivo no caminho como um "anexo". Normalmente, os
navegadores solicitarão ao usuário o download. Seguem alguns exemplos:

[Link]('/relató[Link]');

[Link]('/relató[Link]', 'relató[Link]');

110
Machine Translated by Google

[Link]

[Link]('/relató[Link]', 'relató[Link]', function(err){

});

[Link]([dados] [, codificação])

[Link]([dados] [, codificação])

Este método é usado para finalizar o processo de resposta. Seguem alguns exemplos:

reenviar();

[Link](404).end();

[Link](objeto)

[Link](objeto)

Esse método é usado para realizar a negociação de conteúdo no cabeçalho Accept HTTP no objeto
de solicitação, quando presente. Seguem alguns exemplos:

[Link]({

'texto/simples': function(){
[Link]('hey');
},

'texto/html': function(){
[Link]('

Ei
');
},

'aplicativo/json': function(){
[Link]({ mensagem: 'hey' });
},

'padrão': function() {
// registra a requisição e responde com 406

[Link](406).send('Não Aceitável');
}
111
Machine Translated by Google

[Link]

});

[Link](campo)

[Link](campo)

Este método é usado para retornar o cabeçalho de resposta HTTP especificado pelo campo. Aqui está
um exemplo:

[Link]('Tipo de conteúdo');

[Link]([corpo])

[Link]([corpo])

Este método é usado para enviar uma resposta JSON. Seguem alguns exemplos:

[Link](null)
[Link]({ usuário: 'tobi' })
[Link](500).json({ error: 'message' })

[Link]([corpo])

[Link]([corpo])

Este método é usado para enviar uma resposta JSON com suporte a JSONP. Seguem alguns exemplos:

[Link](null)
[Link]({ usuário: 'tobi' })
[Link](500).jsonp({ error: 'message' })

[Link](links)

[Link](links)

Este método é usado para unir os links fornecidos como propriedades do parâmetro para preencher o campo
de cabeçalho Link HTTP da resposta. Seguem alguns exemplos:

[Link]({
próximo: '[Link]
último: '[Link]
});

[Link](caminho)
112
Machine Translated by Google

[Link]

[Link](caminho)

Este método é usado para definir o campo de cabeçalho HTTP de localização de resposta com base no
parâmetro de caminho especificado. Seguem alguns exemplos:

[Link]('/foo/bar');

[Link]('foo/bar');

[Link]('[Link]

[Link]([status,] caminho)

[Link]([status,] caminho)

Este método é usado para redirecionar para a URL derivada do caminho especificado, com o status do
código de status HTTP especificado. Seguem alguns exemplos:

[Link]('/foo/bar');

[Link]('[Link]

[Link](301, '[Link]

[Link](view [, locals] [, callback])

[Link](view [, locals] [, callback])

Este método é usado para renderizar uma visualização e envia a string HTML renderizada para o cliente.
Seguem alguns exemplos:

// envia a visão renderizada para o cliente

[Link]('index');

// passa uma variável local para a view

[Link]('user', { name: 'Tobi' }, function(err, html) {

// ...

});

[Link]([corpo])

[Link]([corpo])

Este método é usado para enviar a resposta HTTP. Seguem alguns exemplos:

[Link](new Buffer('whoop'));

[Link]({ some: 'json' });

[Link]('

113
Machine Translated by Google

[Link]

alguns html

');

[Link](caminho [, opções] [, fn])

[Link](caminho [, opções] [, fn])

Este método é usado para transferir o arquivo no caminho fornecido. Define o campo de cabeçalho HTTP de
resposta Content-Type com base na extensão do nome do arquivo. Aqui está um exemplo:

[Link](fileName, options, function (err) {

// ...

});

[Link] (statusCode)

[Link] (statusCode)

Esse método é usado para definir o código de status HTTP de resposta para statusCode e enviar sua
representação de string como o corpo da resposta. Seguem alguns exemplos:

[Link](200); // equivalente a [Link](200).send('OK')

[Link](403); // equivalente a [Link](403).send('Forbidden')
[Link](404); // equivalente a [Link](404).send('Not Found')
[Link](500); // equivalente a [Link](500).send('Internal Server Error')

[Link](campo [, valor])

[Link](campo [, valor])

Esse método é usado para definir o valor do campo de cabeçalho HTTP da resposta. Seguem alguns
exemplos:

[Link]('Content-Type', 'text/plain');
[Link]({
'Tipo de conteúdo': 'texto/simples',
'Comprimento do conteúdo': '123',

'ETag': '12345'
})

[Link](código)

114
Machine Translated by Google

[Link]

[Link](código)

Este método é usado para definir o status HTTP para a resposta. Seguem alguns exemplos:

[Link](403).end();
[Link](400).send('Pedido incorreto');
[Link](404).sendFile('/absolute/path/to/[Link]');

[Link](type)

[Link](type)

Esse método é usado para definir o cabeçalho HTTP Content-Type para o tipo MIME. Seguem alguns
exemplos:

[Link]('.html'); // => 'texto/html'

[Link]('html'); // => 'texto/html'

[Link]('json'); // => 'aplicativo/json'

[Link]('aplicativo/json'); // => 'aplicativo/json'

[Link]('png'); // => imagem/png:

Roteamento Básico

Vimos um aplicativo básico que atende a solicitação HTTP para a página inicial. Roteamento refere-se a
determinar como um aplicativo responde a uma solicitação de cliente para um determinado endpoint, que é
um URI (ou caminho) e um método de solicitação HTTP específico (GET, POST e assim por diante).

Vamos estender nosso programa Hello World para lidar com mais tipos de solicitações HTTP.

var expresso = require('expresso');

var app = expresso();

// Isso responde com "Hello World" na página inicial

[Link]('/', function (req, res) {

[Link]("Recebi uma solicitação GET para a página inicial");
[Link]('Olá GET');
})

// Isso responde uma solicitação POST para a página inicial

[Link]('/', function (req, res) {

[Link]("Recebi uma solicitação POST para a página inicial");
115
Machine Translated by Google

[Link]

[Link]('Olá POST');
})

// Isso responde a uma solicitação DELETE para a página /del_user.

[Link]('/del_user', function (req, res) {

[Link]("Recebi uma solicitação DELETE para /del_user");

[Link]('Olá DELETE');
})

// Isso responde a uma solicitação GET para a página /list_user.

[Link]('/list_user', function (req, res) {
[Link]("Recebi um pedido GET para /list_user");

[Link]('Listagem de página');
})

// Isso responde a uma solicitação GET para abcd, abxcd, ab123cd e assim por diante

[Link]('/ab*cd', function(req, res) {

[Link]("Recebi uma solicitação GET para /ab*cd");

[Link]('Correspondência de padrões de página');

})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Salve o código acima em um arquivo chamado [Link] e execute-o com o comando a seguir.

$ node [Link]

Você verá a seguinte saída:

Aplicativo de exemplo ouvindo em [Link]

116
Machine Translated by Google

[Link]

Agora você pode tentar solicitações diferentes em [Link] para ver a saída gerada pelo
[Link]. A seguir estão algumas capturas de tela mostrando respostas diferentes para URLs
diferentes.

Tela mostrando novamente [Link]

Tela mostrando novamente [Link]

Tela mostrando novamente [Link]

117
Machine Translated by Google

[Link]

Servindo arquivos estáticos

O Express fornece um middleware integrado [Link] para servir arquivos estáticos, como imagens,
CSS, JavaScript, etc.

Você simplesmente precisa passar o nome do diretório onde você mantém seus ativos estáticos para o
middleware [Link] para começar a servir os arquivos diretamente. Por exemplo, se você mantiver
seus arquivos de imagens, CSS e JavaScript em um diretório chamado public, poderá fazer isso:

[Link]([Link]('public'));

Vamos manter algumas imagens no subdiretório public/images da seguinte forma:

node_modules

[Link]
público/
público/imagens
public/images/[Link]

Vamos modificar o aplicativo "Hello Word" para adicionar a funcionalidade de lidar com arquivos estáticos.

var expresso = require('expresso');

var app = expresso();

[Link]([Link]('public'));

[Link]('/', function (req, res) {

[Link]('Olá Mundo');
})
118
Machine Translated by Google

[Link]

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Salve o código acima em um arquivo chamado [Link] e execute-o com o comando a seguir.

$ node [Link]

Agora abra [Link] em qualquer navegador e observe o seguinte resultado.

Método GET
Aqui está um exemplo simples que passa dois valores usando o método HTML FORM GET. Vamos usar o
roteador process_get dentro do [Link] para lidar com essa entrada.

<html>

<corpo>

<form action="[Link] method="GET">

Nome: <input type="text" name="first_name"> <br>

Sobrenome: <input type="text" name="last_name">

<input type="submit" value="Submit">

119
Machine Translated by Google

[Link]

</form>

</body>
</html>

Vamos salvar o código acima em [Link] e modificar [Link] para lidar com solicitações de página inicial,
bem como a entrada enviada pelo formulário HTML.

var expresso = require('expresso');

var app = expresso();

[Link]([Link]('public'));

[Link]('/[Link]', function (req, res) {

[Link]( __dirname + "/" + "[Link]" );

})

[Link]('/process_get', function (req, res) {

// Prepara a saída no formato JSON

resposta = {

first_name:[Link].first_name,
last_name:[Link].last_name
};
[Link](resposta);

[Link]([Link](resposta));
})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Acessar o documento HTML usando http:// [Link]:8081/ [Link] gerará o seguinte formulário:

120
Machine Translated by Google

[Link]

Agora você pode inserir o nome e o sobrenome e clicar no botão enviar para ver o resultado e ele deve
retornar o seguinte resultado:

{"first_name":"João","last_name":"Paulo"}

Método POST
Aqui está um exemplo simples que passa dois valores usando o método HTML FORM POST. Vamos usar o
roteador process_get dentro do [Link] para lidar com essa entrada.

<html>

<corpo>

<form action="[Link] method="POST">

Nome: <input type="text" name="first_name"> <br>

Sobrenome: <input type="text" name="last_name">

<input type="submit" value="Submit">
</form>

</body>
</html>

Vamos salvar o código acima em [Link] e modificar [Link] para lidar com solicitações de página inicial,
bem como a entrada enviada pelo formulário HTML.

var expresso = require('expresso');

var app = expresso();

var bodyParser = require('body-parser');

// Cria o analisador application/x-www-form-urlencoded

var urlencodedParser = [Link]({ extended: false })

[Link]([Link]('public'));

[Link]('/[Link]', function (req, res) {

121
Machine Translated by Google

[Link]

[Link]( __dirname + "/" + "[Link]" );

})

[Link]('/process_post', urlencodedParser, function (req, res) {

// Prepara a saída no formato JSON

resposta = {
first_name:[Link].first_name,
last_name:[Link].last_name
};
[Link](resposta);
[Link]([Link](resposta));
})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Acessar o documento HTML usando http:// [Link]:8081/ [Link] gerará o seguinte formulário:

Agora você pode inserir o nome e o sobrenome e clicar no botão enviar para ver o seguinte resultado:

{"first_name":"João","last_name":"Paulo"}

122
Machine Translated by Google

[Link]

Upload de arquivo

O código HTML a seguir cria um formulário de upload de arquivo. Este formulário tem o atributo method
definido como POST e o atributo enctype está definido como multipart/form-data

<html>

<cabeça>

<title>Formulário de envio de arquivos</title>

</head>

<corpo>

<h3>Carregar arquivo:</h3>

Selecione um arquivo para upload: <br />

<form action="[Link] method="POST"

enctype="multipart/form-data">

<input type="file" name="file" size="50" />

<br />

<input type="submit" value="Enviar arquivo" />

</form>

</body>
</html>

Vamos salvar o código acima em [Link] e modificar [Link] para lidar com solicitações de página inicial, bem
como upload de arquivos.

var expresso = require('expresso');

var app = expresso();

var fs = require("fs");

var bodyParser = require('body-parser');

var multer = require('multer');

[Link]([Link]('public'));

[Link]([Link]({ extended: false }));

[Link](multer({ dest: '/tmp/'}));

[Link]('/[Link]', function (req, res) {

[Link]( __dirname + "/" + "[Link]" );

})

[Link]('/file_upload', function (req, res) {

123
Machine Translated by Google

[Link]

[Link]([Link]);
[Link]([Link]);
[Link]([Link]);

var arquivo = __dirname + "/" + [Link];

[Link]( [Link], function (err, data) {
[Link](arquivo, dados, função (err) {
if(erro){
[Link](err);
}senão{

resposta = {
mensagem:'Arquivo carregado com sucesso',
nome do arquivo:[Link]
};
}
[Link](resposta);
[Link]( [Link](resposta));
});
});
})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta

[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Acessar o documento HTML usando http:// [Link]:8081/ [Link] gerará o seguinte formulário:

124
Machine Translated by Google

[Link]

Gerenciamento de cookies
Você pode enviar cookies para um servidor [Link] que pode lidar com o mesmo usando a seguinte
opção de middleware. Segue um exemplo simples para imprimir todos os cookies enviados pelo cliente.

foi expresso = exigir('expresso')

var cookieParser = require('cookie-parser')

var app = express()

[Link](cookieParser())

[Link]('/', function(req, res) {

[Link]("Cookies: ", [Link])
})

[Link](8081)

125
Machine Translated by Google

16. API RESTful [Link]

O que é Arquitetura REST?

REST significa Transferência de Estado Representacional. REST é uma arquitetura baseada em padrão web que usa o
protocolo HTTP. Ele gira em torno de recursos em que cada componente é um recurso e um recurso é acessado por uma
interface comum usando métodos padrão HTTP. O REST foi introduzido pela primeira vez por Roy Fielding em 2000.

Um servidor REST simplesmente fornece acesso aos recursos e um cliente REST acessa e modifica os recursos usando o
protocolo HTTP. Aqui cada recurso é identificado por URIs/IDs globais. REST usa várias representações para representar um
recurso, por exemplo, texto, JSON, XML, mas JSON é o mais popular.

Métodos HTTP
Os quatro métodos HTTP a seguir são comumente usados na arquitetura baseada em REST.

• GET - Isso é usado para fornecer um acesso somente leitura a um recurso.

• PUT - Isto é usado para criar um novo recurso.

• DELETE - É usado para remover um recurso.

• POST - É usado para atualizar um recurso existente ou criar um novo recurso.

Serviços Web RESTful

Um serviço da Web é uma coleção de protocolos e padrões abertos usados para troca de dados entre aplicativos ou sistemas.
Aplicativos de software escritos em várias linguagens de programação e executados em várias plataformas podem usar
serviços da Web para trocar dados em redes de computadores, como a Internet, de maneira semelhante à comunicação entre
processos em um único computador. Essa interoperabilidade (por exemplo, comunicação entre Java e Python, ou aplicativos
Windows e Linux) se deve ao uso de padrões abertos.

Os serviços da Web baseados na Arquitetura REST são conhecidos como serviços da Web RESTful. Essas teias
serviços usam métodos HTTP para implementar o conceito de arquitetura REST. Um serviço web RESTful geralmente define
um URI, Uniform Resource Identifier, que fornece representação de recursos como JSON e um conjunto de métodos HTTP.

Criando RESTful para uma biblioteca

Considere que temos um banco de dados baseado em JSON de usuários com os seguintes usuários em um arquivo
[Link]:

"usuário1": {

"nome" : "mahesh",

126
Machine Translated by Google

[Link]

"senha": "senha1",

"profissão" : "professor",
"id": 1

},

"usuário2": {
"nome" : "certeza",

"senha": "senha2",

"profession" : "bibliotecário",
"id": 2

},

"usuário3": {
"nome" : "ramesh",

"senha": "senha3",

"profission" : "escriturário",
"id": 3

Com base nessas informações, forneceremos as seguintes APIs RESTful.

HTTP
S. Não. URI Método corpo do POST Resultado

1 listUsers OBTER vazio Mostrar lista de todos os usuários.

2 adicionar usuário PUBLICAR JSON String Adicione detalhes do novo usuário.

3 deletar usuário EXCLUIR String JSON Exclua um usuário existente.

4 :Eu iria OBTER vazio Mostrar detalhes de um usuário.

Estamos mantendo a maior parte de todos os exemplos na forma de hard-coding, supondo que você já saiba
como passar valores do front-end usando Ajax ou dados de formulário simples e como processá-los usando
o objeto Express Request .

127
Machine Translated by Google

[Link]

Listar usuários

Vamos implementar nossa primeira API RESTful listUsers usando o seguinte código em um arquivo
[Link] :

[Link]

var expresso = require('expresso');

var app = expresso();
var fs = require("fs");

[Link]('/listUsers', function (req, res) {

[Link]( __dirname + "/" + "[Link]", 'utf8', function (err, data) {
[Link](dados);
[Link](dados);
});
})

var server = [Link](8081, function() {

var host = [Link]().address
var porta = [Link]ço().porta
[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Agora tente acessar a API definida usando http:// [Link]:8081/ listUsers em sua máquina local. Deve
produzir o seguinte resultado:

Você pode alterar o endereço IP fornecido quando colocar a solução no ambiente de produção.

{
"usuário1": {
"nome" : "mahesh",

"senha": "senha1",
"profissão" : "professor",
"id": 1

},
"usuário2": {
"nome" : "certeza",
"senha": "senha2",
"profession" : "bibliotecário",
128
Machine Translated by Google

[Link]

"id": 2

},
"usuário3": {
"nome" : "ramesh",
"senha": "senha3",
"profission" : "escriturário",
"id": 3

}
}

Adicionar usuários

A API a seguir mostrará como adicionar um novo usuário na lista. Segue o detalhe do
novo usuário:

usuário = {

"usuário4": {
"name" : "mohit",
"senha": "senha4",
"profissão" : "professor",
"id": 4

}
}

Você pode aceitar a mesma entrada na forma de JSON usando a chamada Ajax, mas para fins de
demonstração, estamos codificando aqui. A seguir está a API addUser para um novo usuário no
banco de dados:

[Link]

var expresso = require('expresso');

var app = expresso();
var fs = require("fs");

var usuário = {
"usuário4": {
"name" : "mohit",
"senha": "senha4",
"profissão" : "professor",
"id": 4

129
Machine Translated by Google

[Link]

}
}

[Link]('/addUser', function (req, res) {

// Primeiro leia os usuários existentes.
[Link]( __dirname + "/" + "[Link]", 'utf8', function (err, data) {
dados = [Link](dados);
dados["usuário4"] = usuário["usuário4"];

[Link](dados);
[Link]([Link](dados));
});
})

var server = [Link](8081, function() {

var host = [Link]().address
var porta = [Link]ço().porta
[Link]("Exemplo de aplicativo escutando em [Link] host, port)
})

Agora tente acessar a API definida usando a URL: [Link] e o Método HTTP:
POST na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado:

{
"user1":{"name":"mahesh","password":"password1","profession":"professor","id":1},
"user2":{"name":"suresh","password":"password2","profession":"librarian","id":2},
"user3":{"name":"ramesh","password":"password3","profession":"clerk","id":3},
"user4":{"name":"mohit","password":"password4","profession":"professor","id":4}
}

Mostrar detalhes

Agora implementaremos uma API que será chamada usando o ID do usuário e exibirá os detalhes do
usuário correspondente.

[Link]
var expresso = require('expresso');
var app = expresso();
var fs = require("fs");

130
Machine Translated by Google

[Link]

[Link]('/:id', function (req, res) {

// Primeiro leia os usuários existentes.
[Link]( __dirname + "/" + "[Link]", 'utf8', function (err, data) {
usuários = [Link](dados);
var usuário = usuários["usuário" + [Link]]
[Link](usuário);
[Link]([Link](usuário));
});
})

var server = [Link](8081, function() {

var host = [Link]().address

var porta = [Link]ço().porta
[Link]("Exemplo de aplicativo escutando em [Link] host, port)

})

Agora tente acessar a API definida usando a URL: [Link] e o Método HTTP: GET na
máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado:

{"name":"suresh","password":"password2","profession":"bibliotecário","id":2}

Excluir um usuário

Essa API é muito parecida com a API addUser, onde recebemos dados de entrada por meio de [Link]
e, com base no ID do usuário, excluímos esse usuário do banco de dados. Para manter nosso programa
simples, assumimos que vamos excluir o usuário com ID 2.

[Link]
var expresso = require('expresso');
var app = expresso();
var fs = require("fs");

var id = 2;

[Link]('/deleteUser', function (req, res) {

131
Machine Translated by Google

[Link]

// Primeiro leia os usuários existentes.

[Link]( __dirname + "/" + "[Link]", 'utf8', function (err, data) {
dados = [Link](dados);
excluir dados["usuário" + 2];

[Link](dados);
[Link]([Link](dados));
});
})

var server = [Link](8081, function() {

var host = [Link]().address
var porta = [Link]ço().porta
[Link]("Exemplo de aplicativo escutando em [Link] host, port)
})

Agora tente acessar a API definida usando a URL: [Link] e o método HTTP:
DELETE na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado:

{"user1":{"name":"mahesh","password":"password1","profession":"professor","id":1},
"user3":{"name":"ramesh","password":"password3","profession":"clerk","id":3}}

132
Machine Translated by Google

[Link]
17. Dimensionamento de um aplicativo

O [Link] é executado em um modo de thread único, mas usa um paradigma orientado a eventos para lidar
com a simultaneidade. Também facilita a criação de processos filhos para alavancar o processamento paralelo
em sistemas baseados em CPU multi-core.

Os processos filho sempre têm três fluxos [Link], [Link] e

[Link] que pode ser compartilhado com os fluxos stdio do processo pai.

O Node fornece o módulo child_process que possui as três maneiras principais a seguir de criar um
processo filho.

• exec - o método child_process.exec executa um comando em um shell/console e armazena em buffer

a saída.

• spawn - child_process.spawn inicia um novo processo com um determinado comando.

• fork - O método child_process.fork é um caso especial do spawn() para criar

processos filhos.

O método exec()
O método child_process.exec executa um comando em um shell e armazena a saída em buffer. Possui
a seguinte assinatura:

child_process.exec(command[, options], callback)

Parâmetros
Segue a descrição dos parâmetros utilizados:

• command (String) O comando a ser executado, com argumentos separados por espaço

• opções (Objeto) pode compreender uma ou mais das seguintes opções:

o cwd (String) Diretório de trabalho atual do processo filho

o Pares de valores-chave do ambiente env (Objeto)

o codificação (String) Padrão: 'utf8'

o shell (String) Shell para executar o comando. Padrão: '/bin/sh' no UNIX,

'[Link]' no Windows. O shell deve entender a opção -c no UNIX ou /s /c no Windows.
No Windows, a análise de linha de comando deve ser compatível com [Link].

o tempo limite (Número) Padrão: 0

o maxBuffer (Número) Padrão: 200*1024

133
Machine Translated by Google

[Link]

o killSignal (String) Padrão: 'SIGTERM'

o uid (Número) Define a identidade do usuário do processo.

o gid (Número) Define a identidade do grupo do processo.

• retorno de chamada A função obtém três argumentos error, stdout e stderr que são chamados com a
saída quando o processo termina.

O método exec() retorna um buffer com tamanho máximo e aguarda o término do processo e tenta retornar
todos os dados armazenados em buffer de uma só vez.

Exemplo
Vamos criar dois arquivos js chamados [Link] e [Link]:

Arquivo: [Link]
"
[Link]("Processo filho + [Link][2] + "executado." );

Arquivo: [Link]

const fs = require('fs');

const processo_filho = require('processo_filho');

for (var i = 0; i <3; i ++) {

var workerProcess = child_process.exec('node [Link] '+i,

function (erro, stdout, stderr) {

se (erro) {

[Link]([Link]);

[Link]('Código de erro: '+[Link]);

[Link]('Sinal recebido: '+[Link]);

[Link]('stdout: ' + stdout);

[Link]('stderr: ' + stderr);

});

[Link]('exit', function (código) {

[Link]('Processo filho encerrado com código de saída '+código);

});

134
Machine Translated by Google

[Link]

Agora execute o [Link] para ver o resultado:

$ node [Link]

Verifique a saída. O servidor foi iniciado.

Processo filho encerrado com código de saída 0

stdout: Processo filho 1 executado.

stderr:

Processo filho encerrado com código de saída 0

stdout: Processo filho 0 executado.

stderr:

Processo filho encerrado com código de saída 0

stdout: Processo filho 2 executado.

O método spawn()
O método child_process.spawn inicia um novo processo com um determinado comando. Possui a seguinte
assinatura:

child_process.spawn(command[, args][, options])

Parâmetros
Segue a descrição dos parâmetros utilizados:

• command (String) O comando a ser executado.

• argumentos (Array) Lista de argumentos de string.

• opções (Objeto) Pode compreender uma ou mais das seguintes opções:

o cwd (String) Diretório de trabalho atual do processo filho.

o Pares chave-valor do ambiente env (Objeto).

o stdio (Array|String) Configuração stdio do filho.

o customFds (Array) Descritores de arquivo obsoletos para o filho usar para

estúdio.

o desanexado (Booleano) A criança será um líder de grupo de processo.

o uid (Número) Define a identidade do usuário do processo.

135
Machine Translated by Google

[Link]

o gid (Número) Define a identidade do grupo do processo.

O método spawn() retorna streams (stdout & stderr) e deve ser utilizado quando o processo retornar um grande
volume de dados. spawn() começa a receber a resposta assim que o processo começa a ser executado.

Exemplo
Crie dois arquivos js chamados [Link] e [Link]:

Arquivo: [Link]
"
[Link]("Processo filho + [Link][2] + "executado." );

Arquivo: [Link]

const fs = require('fs');

const processo_filho = require('processo_filho');

for (var i = 0; i <3; i ++) {

var workerProcess = child_process.spawn('node', ['[Link]', i]);

[Link]('data', function (dados) {

[Link]('stdout: ' + dados);

});

[Link]('data', function (dados) {

[Link]('stderr: ' + dados);

});

[Link]('fechar', function (código) {

[Link]('processo filho saiu com código ' + código);

});

Agora execute o [Link] para ver o resultado:

$ node [Link]

Verifique a saída. O servidor foi iniciado

stdout: Processo filho 0 executado.

processo filho saiu com código 0

136
Machine Translated by Google

[Link]

stdout: Processo filho 1 executado.

stdout: Processo filho 2 executado.

processo filho saiu com código 0

processo filho saiu com código 0

O método fork()
child_process.fork é um caso especial de spawn() para criar processos Node. Possui a seguinte assinatura:

child_process.fork(modulePath[, args][, options])

Parâmetros
Segue a descrição dos parâmetros utilizados:

• modulePath (String) O módulo a ser executado no filho.

• argumentos (Array) Lista de argumentos de string.

• opções (Objeto) Pode compreender uma ou mais das seguintes opções:

o cwd (String) Diretório de trabalho atual do processo filho.

o Pares chave-valor do ambiente env (Objeto).

o execPath (String) Executável usado para criar o processo filho.

o execArgv (Array) Lista de argumentos de string passados para o executável

(Padrão: [Link])

o silent (Boolean) Se true, stdin, stdout e stderr do filho serão canalizados para o pai, caso contrário serão
herdados do pai. Veja as opções "pipe" e "inherit" para o stdio de spawn() para mais detalhes sobre isso.

O padrão é falso.

o uid (Número) Define a identidade do usuário do processo.

o gid (Número) Define a identidade do grupo do processo.

O método fork retorna um objeto com um canal de comunicação embutido, além de ter todos os métodos em uma instância
ChildProcess normal.

Exemplo
Crie dois arquivos js chamados [Link] e [Link]:

137
Machine Translated by Google

[Link]

Arquivo: [Link]
"
[Link]("Processo filho + [Link][2] + "executado." );

Arquivo: [Link]

const fs = require('fs');

const processo_filho = require('processo_filho');

for (var i = 0; i <3; i ++) {

var worker_process = child_process.fork("[Link]", [i]);

worker_process.on('fechar', function (código) {

[Link]('processo filho saiu com código ' + código);

});

Agora execute o [Link] para ver o resultado:

$ node [Link]

Verifique a saída. O servidor foi iniciado.

Processo filho 0 executado.

Processo filho 1 executado.

Processo filho 2 executado.

processo filho saiu com código 0

processo filho saiu com código 0

processo filho saiu com código 0

138
Machine Translated by Google

18. Embalagem [Link]

JXcore, que é um projeto de código aberto, apresenta um recurso exclusivo para empacotamento e criptografia de
arquivos de origem e outros ativos em pacotes JX.

Considere que você tem um projeto grande que consiste em muitos arquivos. JXcore pode empacotar todos eles
em um único arquivo para simplificar a distribuição. Este capítulo fornece uma visão geral rápida de todo o processo
a partir da instalação do JXcore.

Instalação JXcore
A instalação do JXcore é bastante simples. Aqui nós fornecemos instruções passo a passo sobre como instalar o
JXcore em seu sistema. Siga os passos indicados abaixo:

Passo 1

Baixe o pacote JXcore em [Link] conforme seu sistema operacional e arquitetura de

máquina. Baixamos um pacote para Cenots rodando em 64-
máquina de bits.

$ wget [Link]

Passo 2
Descompacte o arquivo baixado jx_rh64.zip e copie o binário jx em /usr/bin ou pode estar em qualquer outro
diretório baseado na configuração do seu sistema.

$ descompacte jx_rh64.zip

$ cp jx_rh64/jx /usr/bin

etapa 3
Defina sua variável PATH adequadamente para executar o jx de qualquer lugar que desejar.

$ export PATH=$PATH:/usr/bin

Passo 4
Você pode verificar sua instalação emitindo um comando simples, conforme mostrado abaixo. Você deve
encontre-o funcionando e imprimindo seu número de versão da seguinte forma:

$ jx --versão
v0.10.32

139
Machine Translated by Google

[Link]

Empacotando o código
Considere que você tem um projeto com os seguintes diretórios onde você manteve todos os seus arquivos,
incluindo [Link], arquivo principal, [Link] e todos os módulos instalados localmente.

drwxr-xr-x 2 root root 4096 13 de novembro 12:42 imagens

-rwxr-xr-x 1 root root 30457 6 de março 12:19 [Link]

-rwxr-xr-x 1 root root 30452 1 de março 12:54 [Link]

drwxr-xr-x 23 root root 4096 Jan 15 03:48 node_modules
drwxr-xr-x 2 root root 4096 21 de março 06:10 scripts

drwxr-xr-x 2 root root 4096 15 de fevereiro 11:56 estilo

Para empacotar o projeto acima, basta entrar neste diretório e emitir o seguinte comando jx. Supondo que
[Link] seja o arquivo de entrada para seu projeto [Link]:

$ jx package [Link] index

Aqui você poderia ter usado qualquer outro nome de pacote em vez de index. Usamos o índice
porque queríamos manter nosso nome de arquivo principal como [Link]. No entanto, o comando acima
empacotará tudo e criará os dois arquivos a seguir:

• [Link] Este é um arquivo intermediário que contém os detalhes completos do projeto

necessários para compilar o projeto.

• [Link] Este é o arquivo binário com o pacote completo que está pronto para ser enviado ao seu
cliente ou ao seu ambiente de produção.

Iniciando o arquivo JX
Considere que seu projeto original do [Link] estava sendo executado da seguinte forma:

$ node [Link] command_line_arguments

Após compilar seu pacote usando o JXcore, ele pode ser iniciado da seguinte forma:

$ jx [Link] command_line_arguments

Para saber mais sobre o JXcore, você pode conferir seu site oficial.

140