Node.js - Guia rápido

O que é Node.js?

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

Node.js é uma plataforma construída no tempo de execução JavaScript do Chrome para construir facilmente aplicativos de rede rápidos e escaláveis. O Node.js usa um modelo de E / S não bloqueante e orientado por eventos que o torna leve e eficiente, perfeito para aplicativos em tempo real com muitos dados que são executados em dispositivos distribuídos.

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

Node.js também fornece uma rica biblioteca de vários módulos JavaScript que simplifica o desenvolvimento de aplicativos da web usando Node.js em grande medida.

Node.js = Runtime Environment + JavaScript Library

Recursos do Node.js

A seguir estão alguns dos recursos importantes que tornam o Node.js a primeira escolha dos arquitetos de software.

• Asynchronous and Event Driven- Todas as APIs da biblioteca Node.js são assíncronas, ou seja, sem bloqueio. Basicamente, isso significa que um servidor baseado em Node.js nunca espera que uma API retorne dados. O servidor passa para a próxima API após chamá-la e um mecanismo de notificação de Eventos de Node.js ajuda o servidor a obter uma resposta da chamada de API anterior.

• Very Fast - Sendo construída no motor V8 JavaScript do Google Chrome, a biblioteca Node.js é muito rápida na execução do código.

• Single Threaded but Highly Scalable- Node.js usa um único modelo de thread com loop de eventos. O mecanismo de eventos ajuda o servidor a responder de forma não bloqueadora e torna o servidor altamente escalonável, ao contrário dos servidores tradicionais que criam threads limitados para lidar com as solicitações. O Node.js usa um único programa encadeado e o mesmo programa pode fornecer serviço a um número muito maior de solicitações do que servidores tradicionais como o Apache HTTP Server.

• No Buffering- Os aplicativos Node.js nunca armazenam nenhum dado em buffer. Esses aplicativos simplesmente geram os dados em blocos.

• License- O Node.js é lançado sob a licença do MIT .

Quem usa Node.js?

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

• Projetos, aplicativos e empresas que usam o nó

Conceitos

O diagrama a seguir descreve algumas partes importantes do Node.js que discutiremos em detalhes nos capítulos subsequentes.

Onde usar o Node.js?

A seguir estão as áreas em que o Node.js está provando ser um parceiro de tecnologia perfeito.

• Aplicativos ligados a I / O
• Aplicativos de streaming de dados
• Aplicativos em tempo real com uso intensivo de dados (DIRT)
• Aplicativos baseados em APIs JSON
• Aplicativos de página única

Onde não usar o Node.js?

Não é aconselhável usar Node.js para aplicativos com uso intensivo de CPU.

Experimente a opção online

Você realmente não precisa configurar seu próprio ambiente para começar a aprender Node.js. O Reason é muito simples, já configuramos o ambiente Node.js 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 seguinte exemplo usando o Live Demo opção disponível no canto superior direito da caixa de código de amostra abaixo (em nosso site) -

/* Hello World! program in Node.js */
console.log("Hello World!");

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

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para Node.js, você precisa dos dois softwares a seguir disponíveis em seu computador, (a) Editor de Texto e (b) Instaláveis ​​binários do Node.js.

Editor de texto

Isso será usado para digitar seu programa. Exemplos de poucos editores incluem o bloco de notas do Windows, o comando Editar do sistema operacional, Brief, Epsilon, EMACS e vim ou vi.

O nome e a versão do editor de texto podem variar em diferentes sistemas operacionais. Por exemplo, o Bloco de notas será usado no Windows e o vim ou vi pode ser usado no Windows, bem 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 Node.js são normalmente nomeados com a extensão ".js"

Antes de iniciar sua programação, certifique-se de ter um editor de texto instalado e de ter experiência suficiente para escrever um programa de computador, salvá-lo em um arquivo e finalmente executá-lo.

O ambiente de execução do Node.js

O código-fonte escrito no arquivo-fonte é simplesmente javascript. O interpretador Node.js será usado para interpretar e executar seu código javascript.

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

A seção a seguir o orienta sobre como instalar a distribuição de binários Node.js em vários sistemas operacionais.

Baixe o arquivo Node.js

Baixar versão mais recente do arquivo instalável Node.js de Node.js downloads . No momento em que este tutorial foi escrito, a seguir estão as versões disponíveis em diferentes sistemas operacionais.

SO	Nome do arquivo
janelas	node-v6.3.1-x64.msi
Linux	node-v6.3.1-linux-x86.tar.gz
Mac	node-v6.3.1-darwin-x86.tar.gz
SunOS	node-v6.3.1-sunos-x86.tar.gz

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

Com base na arquitetura do seu sistema operacional, baixe e extraia o arquivo node-v6.3.1-osname.tar.gz para / tmp e, finalmente, mova os arquivos extraídos para o diretório / usr / local / nodejs. Por exemplo:

$ cd /tmp $ wget http://nodejs.org/dist/v6.3.1/node-v6.3.1-linux-x64.tar.gz
$ tar xvfz node-v6.3.1-linux-x64.tar.gz $ 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.

SO	Resultado
Linux	exportar PATH = $ PATH: / usr / local / nodejs / bin
Mac	exportar PATH = $ PATH: / usr / local / nodejs / bin
FreeBSD	exportar PATH = $ PATH: / usr / local / nodejs / bin

Instalação em Windows

Use o arquivo MSI e siga as instruções para instalar o Node.js. Por padrão, o instalador usa a distribuição Node.js em C: \ Arquivos de programas \ nodejs. O instalador deve definir o diretório C: \ Arquivos de programas \ nodejs \ bin na variável de ambiente PATH da janela. Reinicie todos os prompts de comando abertos para que a alteração tenha efeito.

Verifique a instalação: Executando um Arquivo

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

/* Hello, World! program in node.js */
console.log("Hello, World!")

Agora execute o arquivo main.js usando o interpretador Node.js para ver o resultado -

$ node main.js

Se tudo estiver bem com a sua instalação, isso deve produzir o seguinte resultado -

Hello, World!

Antes de criar um "Hello, World!" aplicativo usando Node.js, vamos ver os componentes de um aplicativo Node.js. Um aplicativo Node.js consiste nos três componentes importantes a seguir -

• Import required modules - Usamos o require diretiva para carregar módulos Node.js.

• Create server - Um servidor que ouvirá as solicitações do cliente semelhante ao Servidor HTTP Apache.

• Read request and return response - 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.

Criação de aplicativo Node.js

Etapa 1 - Importar Módulo Requerido

Nós usamos o require diretiva 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 http.createServer() método para criar uma instância do servidor e, em seguida, ligamos na porta 8081 usando o listenmétodo associado à instância do servidor. Passe uma função com os parâmetros de solicitação e resposta. Escreva a implementação de amostra para sempre retornar "Hello World".

http.createServer(function (request, response) {
   // Send the HTTP header 
   // HTTP Status: 200 : OK
   // Content Type: text/plain
   response.writeHead(200, {'Content-Type': 'text/plain'});
   
   // Send the response body as "Hello World"
   response.end('Hello World\n');
}).listen(8081);

// Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

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

Etapa 3 - Solicitação e resposta de teste

Vamos colocar as etapas 1 e 2 juntas em um arquivo chamado main.js e inicie nosso servidor HTTP como mostrado abaixo -

var http = require("http");

http.createServer(function (request, response) {
   // Send the HTTP header 
   // HTTP Status: 200 : OK
   // Content Type: text/plain
   response.writeHead(200, {'Content-Type': 'text/plain'});
   
   // Send the response body as "Hello World"
   response.end('Hello World\n');
}).listen(8081);

// Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

Agora execute o main.js para iniciar o servidor da seguinte forma -

$ node main.js

Verifique a saída. O servidor foi iniciado.

Server running at http://127.0.0.1:8081/

Faça uma solicitação ao servidor Node.js

Abra http://127.0.0.1:8081/ em qualquer navegador e observe o seguinte resultado.

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

REPL significa Read Eval Print Loop e representa um ambiente de computador como um console do Windows ou shell Unix / Linux onde um comando é inserido e o sistema responde com uma saída em um modo interativo. Node.js ouNodevem 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.

• Print - Imprime o resultado.

• Loop - Repete o comando acima até que o usuário pressione ctrl-c duas vezes.

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

Terminal REPL online

Para simplificar seu aprendizado, configuramos um ambiente REPL Node.js online fácil de usar, onde você pode praticar a sintaxe Node.js - Inicie o Terminal REPL Node.js

Iniciando REPL

REPL pode ser iniciado simplesmente executando node no shell / console sem nenhum argumento, conforme a seguir.

$ node

Você verá o prompt de comando REPL> onde você pode digitar qualquer comando Node.js -

$ node
>

Expressão Simples

Vamos tentar uma matemática simples no prompt de comando REPL do Node.js -

$ node
> 1 + 3
4
> 1 + ( 2 * 3 ) - 4
3
>

Use Variáveis

Você pode usar variáveis ​​para armazenar valores e imprimir mais tarde como qualquer script convencional. E sevarpalavra-chave não é usada, então o valor é armazenado na variável e impresso. Considerando que sevara palavra-chave for usada, o valor será armazenado, mas não impresso. Você pode imprimir variáveis ​​usandoconsole.log().

$ node
> x = 10
10
> var y = 10
undefined
> x + y
20
> console.log("Hello World")
Hello World
undefined

Expressão Multilinha

O Node REPL oferece suporte a expressões multilinhas semelhantes ao JavaScript. Vamos verificar o seguinte loop do-while em ação -

$ node
> var x = 0
undefined
> do {
   ... x++;
   ... console.log("x: " + x);
   ... } 
while ( x < 5 );
x: 1
x: 2
x: 3
x: 4
x: 5
undefined
>

...vem automaticamente quando você pressiona Enter após o colchete de abertura. O Node verifica automaticamente a continuidade das expressões.

Variável de sublinhado

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

$ node
> var x = 10
undefined
> var y = 20
undefined
> x + y
30
> var sum = _
undefined
> console.log(sum)
30
undefined
>

Comandos REPL

• ctrl + c - termina o comando atual.

• ctrl + c twice - terminar o Node REPL.

• ctrl + d - terminar o Node REPL.

• Up/Down Keys - veja o histórico de comandos e modifique os comandos anteriores.

• tab Keys - lista de comandos atuais.

• .help - lista de todos os comandos.

• .break - sair da expressão multilinha.

• .clear - sair da expressão multilinha.

• .save filename - salvar a sessão REPL do Nó atual em um arquivo.

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

Parando REPL

Conforme mencionado acima, você precisará usar ctrl-c twice para sair do REPL do Node.js.

$ node
>
(^C again to quit)
>

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

• Repositórios online para pacotes / módulos node.js que podem ser pesquisados ​​em search.nodejs.org

• Utilitário de linha de comando para instalar pacotes Node.js, fazer gerenciamento de versões e gerenciamento de dependências de pacotes Node.js.

O NPM vem com instaláveis ​​Node.js 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 --version
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/npm-cli.js
[email protected] /usr/lib/node_modules/npm

Instalando Módulos usando NPM

Existe uma sintaxe simples para instalar qualquer módulo Node.js -

$ npm install <Module Name>

Por exemplo, a seguir está o comando para instalar um famoso módulo de estrutura da web Node.js chamado express -

$ npm install express

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

var express = require('express');

Instalação global x local

Por padrão, o NPM instala qualquer dependência no modo local. Aqui, o modo local se refere à 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 por meio 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.

$ ls -l
total 0
drwxr-xr-x 3 root root 20 Mar 17 02:23 node_modules

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

Os pacotes / dependências instalados globalmente são armazenados no diretório do sistema. Essas dependências podem ser usadas na função CLI (Command Line Interface) de qualquer node.js, mas não podem ser importadas usando require () no aplicativo Node diretamente. Agora vamos tentar instalar o módulo expresso usando a instalação global.

$ npm install express -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 ele está sendo instalado.

[email protected] /usr/lib/node_modules/express
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected]
├── [email protected] ([email protected])
├── [email protected] ([email protected])
├── [email protected] ([email protected])
├── [email protected] ([email protected], [email protected])
├── [email protected] ([email protected], [email protected], [email protected])
├── [email protected] ([email protected])
├── [email protected] ([email protected], [email protected])
└── [email protected] ([email protected], [email protected])

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

$ npm ls -g

Usando package.json

package.json está presente no diretório raiz de qualquer aplicativo / módulo do Node e é usado para definir as propriedades de um pacote. Vamos abrir o package.json do pacote expresso presente emnode_modules/express/

{
   "name": "express",
      "description": "Fast, unopinionated, minimalist web framework",
      "version": "4.11.2",
      "author": {
      
         "name": "TJ Holowaychuk",
         "email": "[email protected]"
      },
   
   "contributors": [{
      "name": "Aaron Heckmann",
      "email": "[email protected]"
   }, 
   
   {
      "name": "Ciaran Jessup",
      "email": "[email protected]"
   },
   
   {
      "name": "Douglas Christopher Wilson",
      "email": "[email protected]"
   },
   
   {
      "name": "Guillermo Rauch",
      "email": "[email protected]"
   },
   
   {
      "name": "Jonathan Ong",
      "email": "[email protected]"
   },
   
   {
      "name": "Roman Shtylman",
      "email": "[email protected]"
   },
   
   {
      "name": "Young Jae Sim",
      "email": "[email protected]"
   } ],
   
   "license": "MIT", "repository": {
      "type": "git",
      "url": "https://github.com/strongloop/express"
   },
   
   "homepage": "https://expressjs.com/", "keywords": [
      "express",
      "framework",
      "sinatra",
      "web",
      "rest",
      "restful",
      "router",
      "app",
      "api"
   ],
   
   "dependencies": {
      "accepts": "~1.2.3",
      "content-disposition": "0.5.0",
      "cookie-signature": "1.0.5",
      "debug": "~2.1.1",
      "depd": "~1.0.0",
      "escape-html": "1.0.1",
      "etag": "~1.5.1",
      "finalhandler": "0.3.3",
      "fresh": "0.2.4",
      "media-typer": "0.3.0",
      "methods": "~1.1.1",
      "on-finished": "~2.2.0",
      "parseurl": "~1.3.0",
      "path-to-regexp": "0.1.3",
      "proxy-addr": "~1.0.6",
      "qs": "2.3.3",
      "range-parser": "~1.0.2",
      "send": "0.11.1",
      "serve-static": "~1.8.1",
      "type-is": "~1.5.6",
      "vary": "~1.0.0",
      "cookie": "0.1.2",
      "merge-descriptors": "0.0.2",
      "utils-merge": "1.0.0"
   },
   
   "devDependencies": {
      "after": "0.8.1",
      "ejs": "2.1.4",
      "istanbul": "0.3.5",
      "marked": "0.3.3",
      "mocha": "~2.1.0",
      "should": "~4.6.2",
      "supertest": "~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",
      "multiparty": "~4.1.1",
      "vhost": "~3.0.0"
   },
   
   "engines": {
      "node": ">= 0.10.0"
   },
   
   "files": [
      "LICENSE",
      "History.md",
      "Readme.md",
      "index.js",
      "lib/"
   ],
   
   "scripts": {
      "test": "mocha --require test/support/env 
         --reporter spec --bail --check-leaks test/ test/acceptance/",
      "test-cov": "istanbul cover node_modules/mocha/bin/_mocha 
         -- --require test/support/env --reporter dot --check-leaks test/ test/acceptance/",
      "test-tap": "mocha --require test/support/env 
         --reporter tap --check-leaks test/ test/acceptance/",
      "test-travis": "istanbul cover node_modules/mocha/bin/_mocha 
         --report lcovonly -- --require test/support/env 
         --reporter spec --check-leaks test/ test/acceptance/"
   },
   
   "gitHead": "63ab25579bda70b4927a179b580a9c580b6c7ada",
   "bugs": {
      "url": "https://github.com/strongloop/express/issues"
   },
   
   "_id": "[email protected]",
   "_shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
   "_from": "express@*",
   "_npmVersion": "1.4.28",
   "_npmUser": {
      "name": "dougwilson",
      "email": "[email protected]"
   },
   
   "maintainers": [{
      "name": "tjholowaychuk",
      "email": "[email protected]"
   },
   
   {
      "name": "jongleberry",
      "email": "[email protected]"
   },
   
   {
      "name": "shtylman",
      "email": "[email protected]"
   },
   
   {
      "name": "dougwilson",
      "email": "[email protected]"
   },
   
   {
      "name": "aredridel",
      "email": "[email protected]"
   },
   
   {
      "name": "strongloop",
      "email": "[email protected]"
   },
   
   {
      "name": "rfeng",
      "email": "[email protected]"
   }],
   
   "dist": {
      "shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
      "tarball": "https://registry.npmjs.org/express/-/express-4.11.2.tgz"
   },
   
   "directories": {},
      "_resolved": "https://registry.npmjs.org/express/-/express-4.11.2.tgz",
      "readme": "ERROR: No README data found!"
}

Atributos de Package.json

• name - nome do pacote

• version - versão do pacote

• description - descrição do pacote

• homepage - página inicial do pacote

• author - autor do pacote

• contributors - nome dos contribuintes do pacote

• dependencies- lista de dependências. O NPM instala automaticamente todas as dependências mencionadas aqui na pasta node_module do pacote.

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

• main - ponto de entrada do pacote

• keywords - palavras-chave

Desinstalando um Módulo

Use o seguinte comando para desinstalar um módulo Node.js.

$ npm uninstall express

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

$ npm ls

Atualizando um Módulo

Atualize o package.json e altere a versão da dependência a ser atualizada e execute o seguinte comando.

$ npm update express

Pesquisar um Módulo

Pesquise um nome de pacote usando NPM.

$ npm search express

Crie um Módulo

A criação de um módulo requer que o package.json seja gerado. Vamos gerar o package.json usando NPM, que gerará o esqueleto básico do package.json.

$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sane defaults.

See 'npm help json' for definitive documentation on these fields
and exactly what they do.

Use 'npm install <pkg> --save' afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (webmaster)

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

$ npm adduser
Username: mcmohd
Password:
Email: (this IS public) [email protected]

É hora de publicar seu módulo -

$ npm publish

Se tudo estiver bem com o seu módulo, ele será publicado no repositório e estará acessível para instalação usando NPM como qualquer outro módulo Node.js.

O que é Callback?

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. O Node faz uso intenso de retornos de chamada. Todas as APIs do Node são escritas de forma que suportem callbacks.

Por exemplo, uma função para ler um arquivo pode iniciar a leitura do arquivo e retornar o controle para o ambiente de execução imediatamente para que a próxima instrução possa ser executada. Assim que 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 um parâmetro. Portanto, não há bloqueio ou espera pela E / S do arquivo. Isso torna o Node.js altamente escalonável, pois pode processar um grande número de solicitações sem esperar que nenhuma função retorne os resultados.

Exemplo de código de bloqueio

Crie um arquivo de texto chamado input.txt com o seguinte conteúdo -

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Crie um arquivo js chamado main.js com o seguinte código -

var fs = require("fs");
var data = fs.readFileSync('input.txt');

console.log(data.toString());
console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended

Exemplo de código sem bloqueio

Crie um arquivo de texto denominado input.txt com o seguinte conteúdo.

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Atualize main.js para ter o seguinte código -

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {
   if (err) return console.error(err);
   console.log(data.toString());
});

console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Esses dois exemplos explicam o conceito de chamadas bloqueadoras e não bloqueadoras.

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

• O segundo exemplo mostra que o programa não espera a leitura do arquivo e passa a imprimir "Programa finalizado" 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 sem bloqueio não são executados em sequência. Caso um programa necessite utilizar algum dado para ser processado, ele deve ser mantido dentro do mesmo bloco para sua execução sequencial.

Node.js é um aplicativo de thread único, mas pode suportar simultaneidade por meio do conceito de event e callbacks. Cada API do Node.js é assíncrona e de thread único, eles usamasync function callspara manter a simultaneidade. Node usa padrão de observador. A thread do nó mantém um loop de eventos e sempre que uma tarefa é concluída, ela dispara o evento correspondente que sinaliza a execução da função de ouvinte de eventos.

Programação Orientada a Eventos

Node.js usa eventos intensamente e também é uma das razões pelas quais o Node.js é muito 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 o evento ocorrer.

Em um aplicativo orientado a eventos, geralmente há um loop principal que escuta os eventos e 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 o tratamento de eventos funciona no padrão do observador. As funções que ouvem eventos agem comoObservers. Sempre que um evento é disparado, sua função de ouvinte começa a ser executada. O Node.js tem vários eventos embutidos 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 maneira -

// Import events module
var events = require('events');

// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

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

// Bind event and event  handler as follows
eventEmitter.on('eventName', eventHandler);

Podemos disparar um evento programaticamente da seguinte maneira -

// Fire an event 
eventEmitter.emit('eventName');

Exemplo

Crie um arquivo js chamado main.js com o seguinte código -

// Import events module
var events = require('events');

// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

// Create an event handler as follows
var connectHandler = function connected() {
   console.log('connection succesful.');
  
   // Fire the data_received event 
   eventEmitter.emit('data_received');
}

// Bind the connection event with the handler
eventEmitter.on('connection', connectHandler);
 
// Bind the data_received event with the anonymous function
eventEmitter.on('data_received', function() {
   console.log('data received succesfully.');
});

// Fire the connection event 
eventEmitter.emit('connection');

console.log("Program Ended.");

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

$ node main.js

A TI deve produzir o seguinte resultado -

connection successful.
data received successfully.
Program Ended.

Como funcionam os aplicativos do Node?

No aplicativo Node, 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 denominado input.txt com o seguinte conteúdo.

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Crie um arquivo js chamado main.js com o seguinte código -

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {
   if (err) {
      console.log(err.stack);
      return;
   }
   console.log(data.toString());
});
console.log("Program Ended");

Aqui fs.readFile () é uma função assíncrona cujo propósito é ler um arquivo. Se ocorrer um erro durante a operação de leitura, oerr object 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 operação de leitura ser concluída, que finalmente imprime o conteúdo.

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Muitos objetos em um Node emitem eventos, por exemplo, um net.Server emite um evento cada vez que um par se conecta a ele, um fs.readStream emite um evento quando o arquivo é aberto. Todos os objetos que emitem eventos são as instâncias de events.EventEmitter.

Classe EventEmitter

Como vimos na seção anterior, a classe EventEmitter está no módulo de eventos. Ele é acessível por meio do seguinte código -

// Import events module
var events = require('events');

// Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

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

EventEmitter fornece várias propriedades como on e emit. on propriedade é usada para ligar uma função com o evento e emit é usado para disparar um evento.

Métodos

Sr. Não.	Método e Descrição
1	addListener(event, listener) Adiciona um ouvinte no final da matriz de ouvintes para o evento especificado. Nenhuma verificação é feita para ver se o listener 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. Emissor de retorno, para que as chamadas possam ser encadeadas.
2	on(event, listener) Adiciona um ouvinte no final da matriz de ouvintes para o evento especificado. Nenhuma verificação é feita para ver se o listener 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. Emissor de retorno, para que as chamadas possam ser encadeadas.
3	once(event, listener) Adiciona um ouvinte único ao evento. Esse ouvinte é chamado apenas na próxima vez em que o evento é disparado, após o que é removido. Emissor de retorno, para que as chamadas possam ser encadeadas.
4	removeListener(event, listener) Remove um ouvinte da matriz do ouvinte para o evento especificado. Caution −Ele altera os índices da matriz na matriz do ouvinte atrás do ouvinte. removeListener removerá, no máximo, uma instância de um listener da matriz de listener. Se qualquer ouvinte único tiver sido adicionado várias vezes à matriz do ouvinte para o evento especificado, removeListener deve ser chamado várias vezes para remover cada instância. Emissor de retorno, para que as chamadas possam ser encadeadas.
5	removeAllListeners([event]) Remove todos os ouvintes ou aqueles do evento especificado. Não é uma boa ideia remover os ouvintes 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 arquivo). Emissor de retorno, para que as chamadas possam ser encadeadas.
6	setMaxListeners(n) Por padrão, EventEmitters imprimirá um aviso se mais de 10 ouvintes forem adicionados para 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.
7	listeners(event) Retorna uma matriz de ouvintes para o evento especificado.
8	emit(event, [arg1], [arg2], [...]) Execute cada um dos ouvintes em ordem com os argumentos fornecidos. Retorna verdadeiro se o evento tiver ouvintes e falso caso contrário.

Métodos de aula

Sr. Não.	Método e Descrição
1	listenerCount(emitter, event) Retorna o número de ouvintes de um determinado evento.

Eventos

Sr. Não.	Eventos e Descrição
1	newListener event - String: o nome do evento listener - Função: a função de manipulador de eventos Este evento é emitido sempre que um ouvinte é adicionado. Quando esse evento é disparado, o ouvinte pode ainda não ter sido adicionado à matriz de ouvintes do evento.
2	removeListener event - String O nome do evento listener - Função A função de manipulador de eventos Este evento é emitido sempre que alguém remove um ouvinte. Quando esse evento é disparado, o ouvinte pode ainda não ter sido removido da matriz de ouvintes do evento.

Exemplo

Crie um arquivo js chamado main.js com o seguinte código Node.js -

var events = require('events');
var eventEmitter = new events.EventEmitter();

// listener #1
var listner1 = function listner1() {
   console.log('listner1 executed.');
}

// listener #2
var listner2 = function listner2() {
   console.log('listner2 executed.');
}

// Bind the connection event with the listner1 function
eventEmitter.addListener('connection', listner1);

// Bind the connection event with the listner2 function
eventEmitter.on('connection', listner2);

var eventListeners = require('events').EventEmitter.listenerCount
   (eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");

// Fire the connection event 
eventEmitter.emit('connection');

// Remove the binding of listner1 function
eventEmitter.removeListener('connection', listner1);
console.log("Listner1 will not listen now.");

// Fire the connection event 
eventEmitter.emit('connection');

eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");

console.log("Program Ended.");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

2 Listner(s) listening to connection event
listner1 executed.
listner2 executed.
Listner1 will not listen now.
listner2 executed.
1 Listner(s) listening to connection event
Program Ended.

O JavaScript puro é compatível com Unicode, mas não para dados binários. Ao lidar com fluxos TCP ou sistema de arquivos, é necessário lidar com fluxos de octetos. Node fornece 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.

Criação de buffers

O 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 buf = new Buffer(10);

Método 2

A seguir está a sintaxe para criar um buffer a partir de uma determinada matriz -

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

Método 3

A seguir está a sintaxe para criar um Buffer a partir de uma determinada string e, opcionalmente, tipo de codificação -

var buf = new Buffer("Simply Easy Learning", "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 para Buffers

Sintaxe

A seguir está a sintaxe do método para escrever em um Node Buffer -

buf.write(string[, offset][, length][, encoding])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• offset- Este é o índice do buffer para começar a escrever. O valor padrão é 0.

• length- Este é o número de bytes a serem gravados. O padrão é buffer.length.

• encoding- Codificação para usar. '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 toda a string, ele escreverá uma parte da string.

Exemplo

buf = new Buffer(256);
len = buf.write("Simply Easy Learning");

console.log("Octets written : "+  len);

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

Octets written : 20

Lendo de Buffers

Sintaxe

A seguir está a sintaxe do método para ler dados de um Buffer do Nó -

buf.toString([encoding][, start][, end])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• encoding- Codificação para usar. 'utf8' é a codificação padrão.

• start - Índice inicial para iniciar a leitura, o padrão é 0.

• end - Índice final para leitura final, 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.

Exemplo

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

console.log( buf.toString('ascii'));       // outputs: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   // outputs: abcde
console.log( buf.toString('utf8',0,5));    // outputs: abcde
console.log( buf.toString(undefined,0,5)); // encoding defaults to 'utf8', outputs abcde

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

abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

Converter Buffer em JSON

Sintaxe

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

buf.toJSON()

Valor de retorno

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

Exemplo

var buf = new Buffer('Simply Easy Learning');
var json = buf.toJSON(buf);

console.log(json);

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

{ type: 'Buffer',
   data: 
   [ 
      83,
      105,
      109,
      112,
      108,
      121,
      32,
      69,
      97,
      115,
      121,
      32,
      76,
      101,
      97,
      114,
      110,
      105,
      110,
      103 
   ]
}

Buffers concatenados

Sintaxe

A seguir está a sintaxe do método para concatenar buffers de Nó em um único Buffer de Nó -

Buffer.concat(list[, totalLength])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• list - Array Lista 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 = Buffer.concat([buffer1,buffer2]);

console.log("buffer3 content: " + buffer3.toString());

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

buffer3 content: TutorialsPoint Simply Easy Learning

Compare Buffers

Sintaxe

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

buf.compare(otherBuffer);

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

Valor de retorno

Retorna um número que indica se ele vem antes ou depois ou é o mesmo que o otherBuffer na ordem de classificação.

Exemplo

var buffer1 = new Buffer('ABC');
var buffer2 = new Buffer('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 +" comes before " + buffer2);
} else if(result === 0) {
   console.log(buffer1 +" is same as " + buffer2);
} else {
   console.log(buffer1 +" comes after " + buffer2);
}

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

ABC comes before ABCD

Buffer de cópia

Sintaxe

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

buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• 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: buffer.length

Valor de retorno

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

Exemplo

var buffer1 = new Buffer('ABC');

//copy a buffer
var buffer2 = new Buffer(3);
buffer1.copy(buffer2);
console.log("buffer2 content: " + buffer2.toString());

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

buffer2 content: ABC

Slice Buffer

Sintaxe

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

buf.slice([start][, end])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• start - Número, opcional, padrão: 0

• end - Número, opcional, padrão: buffer.length

Valor de retorno

Retorna um novo buffer que faz referência à mesma memória do antigo, mas deslocado e recortado pelos índices de início (o padrão é 0) e final (o padrão é buffer.length). Índices negativos começam no final do buffer.

Exemplo

var buffer1 = new Buffer('TutorialsPoint');

//slicing a buffer
var buffer2 = buffer1.slice(0,9);
console.log("buffer2 content: " + buffer2.toString());

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

buffer2 content: Tutorials

Comprimento do Buffer

Sintaxe

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

buf.length;

Valor de retorno

Retorna o tamanho de um buffer em bytes.

Exemplo

var buffer = new Buffer('TutorialsPoint');

//length of the buffer
console.log("buffer length: " + buffer.length);

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

buffer length: 14

Referência de Métodos

A seguir está uma referência do módulo Buffers disponível em Node.js. Para obter mais detalhes, você pode consultar a documentação oficial.

Sr. Não.	Método e Descrição
1	new Buffer(size) 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	new Buffer(buffer) Copia os dados do buffer passados ​​em uma nova instância do Buffer.
3	new Buffer(str[, encoding]) Aloca um novo buffer contendo o str fornecido. o padrão de codificação é 'utf8'.
4	buf.length Retorna o tamanho do buffer em bytes. Observe que este não é necessariamente o tamanho do conteúdo. comprimento refere-se à quantidade de memória alocada para o objeto de buffer. Ele não muda quando o conteúdo do buffer é alterado.
5	buf.write(string[, offset][, length][, encoding]) Grava uma string no buffer no deslocamento usando a codificação fornecida. o deslocamento padrão é 0, o padrão de codificação é 'utf8'. comprimento é o número de bytes a serem gravados. Retorna o número de octetos gravados.
6	buf.writeUIntLE(value, offset, byteLength[, noAssert]) Grava um valor no buffer no deslocamento e comprimento de byte 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.
7	buf.writeUIntBE(value, offset, byteLength[, noAssert]) Grava um valor no buffer no deslocamento e comprimento de byte 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.
8	buf.writeIntLE(value, offset, byteLength[, noAssert]) Grava um valor no buffer no deslocamento e comprimento de byte 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.
9	buf.writeIntBE(value, offset, byteLength[, noAssert]) Grava um valor no buffer no deslocamento e comprimento de byte 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.
10	buf.readUIntLE(offset, byteLength[, noAssert]) Uma versão generalizada de todos os métodos de leitura numérica. Suporta até 48 bits de precisão. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
11	buf.readUIntBE(offset, byteLength[, noAssert]) Uma versão generalizada de todos os métodos de leitura numérica. Suporta até 48 bits de precisão. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
12	buf.readIntLE(offset, byteLength[, noAssert]) Uma versão generalizada de todos os métodos de leitura numérica. Suporta até 48 bits de precisão. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
13	buf.readIntBE(offset, byteLength[, noAssert]) Uma versão generalizada de todos os métodos de leitura numérica. Suporta até 48 bits de precisão. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
14	buf.toString([encoding][, start][, end]) Decodifica e retorna uma string de dados de buffer codificados usando a codificação do conjunto de caracteres especificado.
15	buf.toJSON() Retorna uma representação JSON da instância do Buffer. JSON.stringify chama implicitamente essa função ao sequenciar uma instância do Buffer.
16	buf[index] Obtenha e defina o octeto no índice. Os valores referem-se a bytes individuais, portanto, a faixa legal está entre 0x00 e 0xFF hex ou 0 e 255.
17	buf.equals(otherBuffer) Retorna um booleano se este buffer e outroBuffer tiverem os mesmos bytes.
18	buf.compare(otherBuffer) Retorna um número que indica se este buffer vem antes ou depois ou é o mesmo que o otherBuffer na ordem de classificação.
19	buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd]) Copia dados de uma região desse buffer para uma região no buffer de destino, mesmo se a região de memória de destino se sobrepõe à origem. Se indefinido, os parâmetros targetStart e sourceStart são padronizados como 0, enquanto sourceEnd é padronizado como buffer.length.
20	buf.slice([start][, end]) Retorna um novo buffer que faz referência à mesma memória do antigo, mas deslocado e recortado pelos índices inicial (o padrão é 0) e final (o padrão é buffer.length). Índices negativos começam no final do buffer.
21	buf.readUInt8(offset[, noAssert]) Lê um inteiro não assinado de 8 bits do buffer no deslocamento especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
22	buf.readUInt16LE(offset[, noAssert]) Lê um inteiro não assinado de 16 bits do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
23	buf.readUInt16BE(offset[, noAssert]) Lê um inteiro não assinado de 16 bits do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
24	buf.readUInt32LE(offset[, noAssert]) Lê um inteiro de 32 bits não assinado do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
25	buf.readUInt32BE(offset[, noAssert]) Lê um inteiro de 32 bits não assinado do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
26	buf.readInt8(offset[, noAssert]) Lê um inteiro assinado de 8 bits do buffer no deslocamento especificado. Defina noAssert como true para ignorar a validação de 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 formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
28	buf.readInt16BE(offset[, noAssert]) 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 de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
29	buf.readInt32LE(offset[, noAssert]) Lê um inteiro assinado de 32 bits do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
30	buf.readInt32BE(offset[, noAssert]) Lê um inteiro assinado de 32 bits do buffer no deslocamento especificado com o formato endian especificado. Defina noAssert como true para ignorar a validação de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
31	buf.readFloatLE(offset[, noAssert]) 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 de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
32	buf.readFloatBE(offset[, noAssert]) 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 de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
33	buf.readDoubleLE(offset[, noAssert]) 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 de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
34	buf.readDoubleBE(offset[, noAssert]) 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 de deslocamento. Isso significa que o deslocamento pode estar além do final do buffer. O padrão é falso.
35	buf.writeUInt8(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado. Observe que o valor deve ser um número inteiro de 8 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
36	buf.writeUInt16LE(value, offset[, 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 não assinado 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza da correção. O padrão é falso.
37	buf.writeUInt16BE(value, offset[, 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 não assinado 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
38	buf.writeUInt32LE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um inteiro não assinado de 32 bits 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
39	buf.writeUInt32BE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um inteiro não assinado de 32 bits 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
40	buf.writeInt8(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um inteiro válido de 8 bits com sinal. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
41	buf.writeInt16LE(value, offset[, 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 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
42	buf.writeInt16BE(value, offset[, 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 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
43	buf.writeInt32LE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um inteiro válido de 32 bits com sinal. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
44	buf.writeInt32BE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um inteiro válido de 32 bits com sinal. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza da correção. O padrão é falso.
45	buf.writeFloatLE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um float válido de 32 bits. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
46	buf.writeFloatBE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um float válido de 32 bits. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
47	buf.writeDoubleLE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um duplo válido de 64 bits. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
48	buf.writeDoubleBE(value, offset[, noAssert]) Grava um valor no buffer no deslocamento especificado com o formato endian especificado. Observe que o valor deve ser um duplo válido de 64 bits. 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, levando aos valores sendo descartados silenciosamente. Não deve ser usado a menos que você tenha certeza de sua correção. O padrão é falso.
49	buf.fill(value[, offset][, end]) Preenche o buffer com o valor especificado. Se o deslocamento (o padrão é 0) e o fim (o padrão é buffer.length) não forem fornecidos, ele preencherá o buffer inteiro.

Métodos de aula

Sr. Não.	Método e Descrição
1	Buffer.isEncoding(encoding) Retorna verdadeiro se a codificação for um argumento de codificação válido, caso contrário, retorna falso.
2	Buffer.isBuffer(obj) Testa se obj é um buffer.
3	Buffer.byteLength(string[, encoding]) Fornece o comprimento real do byte de uma string. o padrão de codificação é 'utf8'. Não é o mesmo que String.prototype.length, já que String.prototype.length retorna o número de caracteres em uma string.
4	Buffer.concat(list[, totalLength]) Retorna um buffer que é o resultado da concatenação de todos os buffers da lista.
5	Buffer.compare(buf1, buf2) O mesmo que buf1.compare (buf2). Útil para classificar uma série de buffers.

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 Node.js, existem quatro tipos de streams -

• Readable - Fluxo que é usado para operação de leitura.

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

• Duplex - Fluxo 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 na entrada.

Cada tipo de fluxo é um EventEmitterinstância e lança vários eventos em diferentes instâncias de tempos. Por exemplo, alguns dos eventos comumente usados ​​são -

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

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

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

• finish - Este evento é disparado 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 fluxo

Crie um arquivo de texto denominado input.txt com o seguinte conteúdo -

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Crie um arquivo js chamado main.js com o seguinte código -

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

// Create a readable stream
var readerStream = fs.createReadStream('input.txt');

// Set the encoding to be utf8. 
readerStream.setEncoding('UTF8');

// Handle stream events --> data, end, and error
readerStream.on('data', function(chunk) {
   data += chunk;
});

readerStream.on('end',function() {
   console.log(data);
});

readerStream.on('error', function(err) {
   console.log(err.stack);
});

console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Escrevendo em um fluxo

Crie um arquivo js chamado main.js com o seguinte código -

var fs = require("fs");
var data = 'Simply Easy Learning';

// Create a writable stream
var writerStream = fs.createWriteStream('output.txt');

// Write the data to stream with encoding to be utf8
writerStream.write(data,'UTF8');

// Mark the end of file
writerStream.end();

// Handle stream events --> finish, and error
writerStream.on('finish', function() {
   console.log("Write completed.");
});

writerStream.on('error', function(err) {
   console.log(err.stack);
});

console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Program Ended
Write completed.

Agora abra output.txt criado em seu diretório atual; deve conter o seguinte -

Simply Easy Learning

Canalizando os córregos

Piping é um mecanismo em que 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 para 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 main.js com o seguinte código -

var fs = require("fs");

// Create a readable stream
var readerStream = fs.createReadStream('input.txt');

// Create a writable stream
var writerStream = fs.createWriteStream('output.txt');

// Pipe the read and write operations
// read input.txt and write data to output.txt
readerStream.pipe(writerStream);

console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Program Ended

Abra output.txt criado em seu diretório atual; deve conter o seguinte -

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Encadeando os Streams

O encadeamento é um mecanismo para conectar a saída de um fluxo a outro fluxo e criar uma cadeia de múltiplas operações de fluxo. Normalmente é usado com operações de tubulação. Agora usaremos tubulação e encadeamento para compactar primeiro um arquivo e depois descompactar o mesmo.

Crie um arquivo js chamado main.js com o seguinte código -

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

// Compress the file input.txt to input.txt.gz
fs.createReadStream('input.txt')
   .pipe(zlib.createGzip())
   .pipe(fs.createWriteStream('input.txt.gz'));
  
console.log("File Compressed.");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

File Compressed.

Você descobrirá que input.txt foi compactado e criou um arquivo input.txt.gz no diretório atual. Agora vamos tentar descompactar o mesmo arquivo usando o seguinte código -

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

// Decompress the file input.txt.gz to input.txt
fs.createReadStream('input.txt.gz')
   .pipe(zlib.createGunzip())
   .pipe(fs.createWriteStream('input.txt'));
  
console.log("File Decompressed.");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

File Decompressed.

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 -

var 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 input.txt com o seguinte conteúdo -

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Vamos criar um arquivo js chamado main.js com o seguinte código -

var fs = require("fs");

// Asynchronous read
fs.readFile('input.txt', function (err, data) {
   if (err) {
      return console.error(err);
   }
   console.log("Asynchronous read: " + data.toString());
});

// Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());

console.log("Program Ended");

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Synchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Program Ended
Asynchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

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 -

fs.open(path, flags[, mode], callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

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

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

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

Bandeiras

Sinalizadores para operações de leitura / gravação são -

Sr. Não.	Sinalizador e descrição
1	r Abra o arquivo para leitura. Uma exceção ocorre se o arquivo não existir.
2	r+ Abra o arquivo para leitura e gravação. Uma exceção ocorre se o arquivo não existir.
3	rs Abra o arquivo para leitura no modo síncrono.
4	rs+ Abra o arquivo para leitura e gravação, pedindo ao SO para abri-lo de forma síncrona. Consulte as notas para 'rs' sobre como usar isso com cuidado.
5	w Abra o arquivo para gravação. O arquivo é criado (se não existir) ou truncado (se existir).
6	wx Como 'w', mas falha se o caminho existir.
7	w+ Abra o arquivo para leitura e gravação. O arquivo é criado (se não existir) ou truncado (se existir).
8	wx+ Como 'w +', mas falha se o caminho existir.
9	a Abra o arquivo para anexar. O arquivo é criado se não existir.
10	ax Como 'a', mas falha se o caminho existir.
11	a+ Abra o arquivo para ler e anexar. O arquivo é criado se não existir.
12	ax+ Como 'a +', mas falha se o caminho existir.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código para abrir um arquivo input.txt para leitura e gravação.

var fs = require("fs");

// Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");     
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to open file!
File opened successfully!

Obter informações do arquivo

Sintaxe

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

fs.stat(path, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• callback - Esta é a função de retorno de chamada que obtém dois argumentos (err, estatísticas) onde stats é um objeto do tipo fs.Stats que é impresso a seguir no exemplo.

Além dos atributos importantes que são impressos abaixo no exemplo, existem vários métodos úteis disponíveis em fs.Statsclasse que pode ser usada para verificar o tipo de arquivo. Esses métodos são fornecidos na tabela a seguir.

Sr. Não.	Método e Descrição
1	stats.isFile() Retorna verdadeiro se o tipo de arquivo de um arquivo simples.
2	stats.isDirectory() Retorna verdadeiro se o tipo de arquivo de um diretório.
3	stats.isBlockDevice() Retorna verdadeiro se o tipo de arquivo de um dispositivo de bloco.
4	stats.isCharacterDevice() Retorna verdadeiro se o tipo de arquivo de um dispositivo de caractere.
5	stats.isSymbolicLink() Retorna verdadeiro se o tipo de arquivo de um link simbólico.
6	stats.isFIFO() Retorna verdadeiro se o tipo de arquivo de um FIFO.
7	stats.isSocket() Retorna verdadeiro se o tipo de arquivo for asocket.

Exemplo

Vamos criar um arquivo js chamado main.js com o seguinte código -

var fs = require("fs");

console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
   if (err) {
      return console.error(err);
   }
   console.log(stats);
   console.log("Got file info successfully!");
   
   // Check file type
   console.log("isFile ? " + stats.isFile());
   console.log("isDirectory ? " + stats.isDirectory());    
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to get file info!
{ 
   dev: 1792,
   mode: 33188,
   nlink: 1,
   uid: 48,
   gid: 48,
   rdev: 0,
   blksize: 4096,
   ino: 4318127,
   size: 97,
   blocks: 8,
   atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
   mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
   ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT) 
}
Got file info successfully!
isFile ? true
isDirectory ? false

Gravando um Arquivo

Sintaxe

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

fs.writeFile(filename, data[, options], callback)

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

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• data - Esta é a String ou Buffer a ser gravada no arquivo.

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

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

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

var fs = require("fs");

console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {
   if (err) {
      return console.error(err);
   }
   
   console.log("Data written successfully!");
   console.log("Let's read newly written data");
   
   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("Asynchronous read: " + data.toString());
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to write into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!

Lendo um arquivo

Sintaxe

A seguir está a sintaxe de um dos métodos de leitura de um arquivo -

fs.read(fd, buffer, offset, length, position, callback)

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

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• fd - Este é o descritor de arquivo retornado por fs.open ().

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

• offset - Este é o deslocamento no buffer para iniciar a gravação.

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

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

• callback - 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 main.js com o seguinte código -

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

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to read the file");
   
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + " bytes read");
      
      // Print only read bytes to avoid junk.
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to open an existing file
File opened successfully!
Going to read the file
97 bytes read
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Fechando um Arquivo

Sintaxe

A seguir está a sintaxe para fechar um arquivo aberto -

fs.close(fd, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• fd - Este é o descritor de arquivo retornado pelo método file fs.open ().

• callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

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

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to read the file");
   
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
      if (err) {
         console.log(err);
      }

      // Print only read bytes to avoid junk.
      if(bytes > 0) {
         console.log(buf.slice(0, bytes).toString());
      }

      // Close the opened file.
      fs.close(fd, function(err) {
         if (err) {
            console.log(err);
         } 
         console.log("File closed successfully.");
      });
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to open an existing file
File opened successfully!
Going to read the file
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

File closed successfully.

Truncar um arquivo

Sintaxe

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

fs.ftruncate(fd, len, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• fd - Este é o descritor de arquivo retornado por fs.open ().

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

• callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

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

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to truncate the file after 10 bytes");
   
   // Truncate the opened file.
   fs.ftruncate(fd, 10, function(err) {
      if (err) {
         console.log(err);
      } 
      console.log("File truncated successfully.");
      console.log("Going to read the same file"); 
      
      fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err) {
            console.log(err);
         }

         // Print only read bytes to avoid junk.
         if(bytes > 0) {
            console.log(buf.slice(0, bytes).toString());
         }

         // Close the opened file.
         fs.close(fd, function(err) {
            if (err) {
               console.log(err);
            } 
            console.log("File closed successfully.");
         });
      });
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to open an existing file
File opened successfully!
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Tutorials 
File closed successfully.

Excluir um arquivo

Sintaxe

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

fs.unlink(path, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

var fs = require("fs");

console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("File deleted successfully!");
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to delete an existing file
File deleted successfully!

Crie um diretório

Sintaxe

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

fs.mkdir(path[, mode], callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

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

• callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

var fs = require("fs");

console.log("Going to create directory /tmp/test");
fs.mkdir('/tmp/test',function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("Directory created successfully!");
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to create directory /tmp/test
Directory created successfully!

Leia um diretório

Sintaxe

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

fs.readdir(path, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• callback- Esta é a função de retorno de chamada que obtém dois argumentos (errar, arquivos) onde arquivos é uma matriz dos nomes dos arquivos no diretório, excluindo '.' e '..'.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

var fs = require("fs");

console.log("Going to read directory /tmp");
fs.readdir("/tmp/",function(err, files) {
   if (err) {
      return console.error(err);
   }
   files.forEach( function (file) {
      console.log( file );
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test
test.txt

Remover um diretório

Sintaxe

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

fs.rmdir(path, callback)

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

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

• callback - Esta é a função de retorno de chamada. Nenhum argumento além de uma possível exceção é fornecido para o retorno de chamada de conclusão.

Exemplo

Vamos criar um arquivo js chamado main.js tendo o seguinte código -

var fs = require("fs");

console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("Going to read directory /tmp");
   
   fs.readdir("/tmp/",function(err, files) {
      if (err) {
         return console.error(err);
      }
      files.forEach( function (file) {
         console.log( file );
      });
   });
});

Agora execute o main.js para ver o resultado -

$ node main.js

Verifique a saída.

Going to read directory /tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test.txt

Referência de Métodos

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

Sr. Não	Método e Descrição
1	fs.rename(oldPath, newPath, callback) Renomear assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
2	fs.ftruncate(fd, len, callback) Ftruncate assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
3	fs.ftruncateSync(fd, len) Ftruncate síncrono ().
4	fs.truncate(path, len, callback) Truncate assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
5	fs.truncateSync(path, len) Truncamento síncrono ().
6	fs.chown(path, uid, gid, callback) Chown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
7	fs.chownSync(path, uid, gid) Chown síncrono ().
8	fs.fchown(fd, uid, gid, callback) Fchown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
9	fs.fchownSync(fd, uid, gid) Fchown síncrono ().
10	fs.lchown(path, uid, gid, callback) Lchown assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
11	fs.lchownSync(path, uid, gid) Lchown síncrono ().
12	fs.chmod(path, mode, callback) Chmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
13	fs.chmodSync(path, mode) Chmod síncrono ().
14	fs.fchmod(fd, mode, callback) Fchmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
15	fs.fchmodSync(fd, mode) Fchmod síncrono ().
16	fs.lchmod(path, mode, callback) Lchmod assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão. Disponível apenas no Mac OS X.
17	fs.lchmodSync(path, mode) Lchmod síncrono ().
18	fs.stat(path, callback) Stat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats.
19	fs.lstat(path, callback) Lstat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats. lstat () é idêntico a stat (), exceto que se o caminho for um link simbólico, então o link em si é stat-ed, não o arquivo ao qual se refere.
20	fs.fstat(fd, callback) Fstat assíncrono (). O retorno de chamada obtém dois argumentos (err, estatísticas) onde estatísticas é um objeto fs.Stats. fstat () é idêntico a stat (), exceto que o arquivo a ser stat-ed é especificado pelo descritor de arquivo fd.
21	fs.statSync(path) Stat síncrono (). Retorna uma instância de fs.Stats.
22	fs.lstatSync(path) Lstat síncrono (). Retorna uma instância de fs.Stats.
23	fs.fstatSync(fd) Fstat síncrono (). Retorna uma instância de fs.Stats.
24	fs.link(srcpath, dstpath, callback) Link assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
25	fs.linkSync(srcpath, dstpath) Link síncrono ().
26	fs.symlink(srcpath, dstpath[, type], callback) Link simbólico assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão. O argumento de tipo pode ser definido 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á normalizado automaticamente para o caminho absoluto.
27	fs.symlinkSync(srcpath, dstpath[, type]) Link simbólico síncrono ().
28	fs.readlink(path, callback) Readlink assíncrono (). O retorno de chamada obtém dois argumentos (err, linkString).
29	fs.realpath(path[, cache], callback) Realpath assíncrono (). O retorno de chamada obtém dois argumentos (err, resolvidoPath). Pode usar process.cwd para resolver caminhos relativos. cache é um objeto literal de caminhos mapeados que pode ser usado para forçar uma resolução de caminho específica ou evitar chamadas fs.stat adicionais para caminhos reais conhecidos.
30	fs.realpathSync(path[, cache]) Realpath síncrono (). Retorna o caminho resolvido.
31	fs.unlink(path, callback) Desvinculação assíncrona (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
32	fs.unlinkSync(path) Desvinculação síncrona ().
33	fs.rmdir(path, callback) Rmdir assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
34	fs.rmdirSync(path) Rmdir síncrono ().
35	fs.mkdir(path[, mode], callback) Mkdir assíncrono (2). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão. o modo padrão é 0777.
36	fs.mkdirSync(path[, mode]) Mkdir síncrono ().
37	fs.readdir(path, callback) Readdir assíncrono (3). Lê o conteúdo de um diretório. O retorno de chamada obtém dois argumentos (err, arquivos) onde arquivos é uma matriz dos nomes dos arquivos no diretório, excluindo '.' e '..'.
38	fs.readdirSync(path) Readdir síncrono (). Retorna uma matriz de nomes de arquivos, excluindo '.' e '..'.
39	fs.close(fd, callback) Close assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
40	fs.closeSync(fd) Fechamento síncrono ().
41	fs.open(path, flags[, mode], callback) Arquivo assíncrono aberto.
42	fs.openSync(path, flags[, mode]) Versão síncrona de fs.open ().
43	fs.utimes(path, atime, mtime, callback)
44	fs.utimesSync(path, atime, mtime) Altere os carimbos de data / hora do arquivo referenciado pelo caminho fornecido.
45	fs.futimes(fd, atime, mtime, callback)
46	fs.futimesSync(fd, atime, mtime) Altere os carimbos de data / hora de um arquivo referenciado pelo descritor de arquivo fornecido.
47	fs.fsync(fd, callback) Fsync assíncrono. Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão.
48	fs.fsyncSync(fd) Fsync síncrono.
49	fs.write(fd, buffer, offset, length[, position], callback) Buffer de gravação no arquivo especificado por fd.
50	fs.write(fd, data[, position[, encoding]], callback) Grava dados no arquivo especificado por fd. Se os dados não forem uma instância do Buffer, o valor será forçado para uma string.
51	fs.writeSync(fd, buffer, offset, length[, position]) Versões síncronas de fs.write (). Retorna o número de bytes gravados.
52	fs.writeSync(fd, data[, position[, encoding]]) Versões síncronas de fs.write (). Retorna o número de bytes gravados.
53	fs.read(fd, buffer, offset, length, position, callback) Leia os dados do arquivo especificado por fd.
54	fs.readSync(fd, buffer, offset, length, position) Versão síncrona de fs.read. Retorna o número de bytesRead.
55	fs.readFile(filename[, options], callback) Lê de forma assíncrona todo o conteúdo de um arquivo.
56	fs.readFileSync(filename[, options]) Versão síncrona de fs.readFile. Retorna o conteúdo do nome do arquivo.
57	fs.writeFile(filename, data[, options], callback) Grava dados de maneira assíncrona em um arquivo, substituindo o arquivo se ele já existir. os dados podem ser uma string ou um buffer.
58	fs.writeFileSync(filename, data[, options]) A versão síncrona de fs.writeFile.
59	fs.appendFile(filename, data[, options], callback) Anexar dados de maneira assíncrona a um arquivo, criando o arquivo se ele não existir. os dados podem ser uma string ou um buffer.
60	fs.appendFileSync(filename, data[, options]) A versão síncrona de fs.appendFile.
61	fs.watchFile(filename[, options], listener) Observe as mudanças no nome do arquivo. O ouvinte de retorno de chamada será chamado sempre que o arquivo for acessado.
62	fs.unwatchFile(filename[, listener]) Pare de observar as mudanças no nome do arquivo. Se listener for especificado, apenas esse listener específico será removido. Caso contrário, todos os ouvintes são removidos e você efetivamente parou de assistir a filename.
63	fs.watch(filename[, options][, listener]) Observe as mudanças no nome do arquivo, onde nome do arquivo é um arquivo ou um diretório. O objeto retornado é um fs.FSWatcher.
64	fs.exists(path, callback) 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 verdadeiro ou falso.
65	fs.existsSync(path) Versão síncrona de fs.exists.
66	fs.access(path[, mode], callback) Testa as permissões de um usuário para o arquivo especificado por caminho. mode é um número inteiro opcional que especifica as verificações de acessibilidade a serem realizadas.
67	fs.accessSync(path[, mode]) Versão síncrona de fs.access. Ele lança se alguma verificação de acessibilidade falhar e não faz nada de outra forma.
68	fs.createReadStream(path[, options]) Retorna um novo objeto ReadStream.
69	fs.createWriteStream(path[, options]) Retorna um novo objeto WriteStream.
70	fs.symlink(srcpath, dstpath[, type], callback) Link simbólico assíncrono (). Nenhum argumento diferente de uma possível exceção é fornecido para o retorno de chamada de conclusão. O argumento de tipo pode ser definido 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á normalizado automaticamente para o caminho absoluto.

Os objetos globais do Node.js 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 a seguir.

__nome do arquivo

o __filenamerepresenta 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 main.js com o seguinte código -

// Let's try to print the value of __filename

console.log( __filename );

Agora execute o main.js para ver o resultado -

$ node main.js

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

/web/com/1427091028_21099/main.js

__dirname

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

Exemplo

Crie um arquivo js chamado main.js com o seguinte código -

// Let's try to print the value of __dirname

console.log( __dirname );

Agora execute o main.js para ver o resultado -

$ node main.js

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

/web/com/1427091028_21099

setTimeout (cb, ms)

o setTimeout(cb, ms)a função global é usada para executar o callback 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 cronômetro não pode abranger mais de 24,8 dias.

Esta função retorna um valor opaco que representa o cronômetro que pode ser usado para zerar o cronômetro.

Exemplo

Crie um arquivo js chamado main.js com o seguinte código -

function printHello() {
   console.log( "Hello, World!");
}

// Now call above function after 2 seconds
setTimeout(printHello, 2000);

Agora execute o main.js para ver o resultado -

$ node main.js

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

Hello, World!

clearTimeout (t)

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

Exemplo

Crie um arquivo js chamado main.js com o seguinte código -

function printHello() {
   console.log( "Hello, World!");
}

// Now call above function after 2 seconds
var t = setTimeout(printHello, 2000);

// Now clear the timer
clearTimeout(t);

Agora execute o main.js para ver o resultado -

$ node main.js

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

setInterval (cb, ms)

o setInterval(cb, ms)a função global é 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 cronômetro não pode abranger mais de 24,8 dias.

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

Exemplo

Crie um arquivo js chamado main.js com o seguinte código -

function printHello() {
   console.log( "Hello, World!");
}

// Now call above function after 2 seconds
setInterval(printHello, 2000);

Agora execute o main.js para ver o resultado -

$ node main.js

O programa acima executará printHello () a cada 2 segundos. Devido à limitação do sistema.

Objetos Globais

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

Sr. Não.	Nome e descrição do módulo
1	Console Usado para imprimir informações sobre stdout e stderr.
2	Process Usado para obter informações sobre o processo atual. Fornece vários eventos relacionados às atividades do processo.

Existem vários módulos de utilitário disponíveis na biblioteca de módulos Node.js. Esses módulos são muito comuns e frequentemente usados ​​durante o desenvolvimento de qualquer aplicativo baseado em Node.

Sr. Não.	Nome e descrição do módulo
1	Módulo OS 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 pesquisas DNS reais, 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.

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 fornecem documentos html junto com imagens, folhas de estilo e scripts.

A maioria dos servidores da web oferece suporte a 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 ao cliente HTTP por meio do servidor da web.

O servidor da web Apache é um dos servidores da web mais comumente usados. É um projeto de código aberto.

Arquitetura de aplicativo da Web

Um aplicativo da Web geralmente é dividido em quatro camadas -

• Client - Esta camada consiste em navegadores da web, navegadores móveis ou aplicativos que podem fazer solicitações HTTP para o servidor da web.

• Server - Esta camada possui o servidor Web que pode interceptar as solicitações feitas pelos clientes e passar a resposta.

• Business- Essa camada contém o servidor de aplicativos que é utilizado pelo servidor da 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.

• Data - Esta camada contém os bancos de dados ou qualquer outra fonte de dados.

Criando um servidor web usando o Node

Node.js fornece um httpmódulo 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 server.js -

File: server.js

var http = require('http');
var fs = require('fs');
var url = require('url');

// Create a server
http.createServer( function (request, response) {  
   // Parse the request containing file name
   var pathname = url.parse(request.url).pathname;
   
   // Print the name of the file for which request is made.
   console.log("Request for " + pathname + " received.");
   
   // Read the requested file content from file system
   fs.readFile(pathname.substr(1), function (err, data) {
      if (err) {
         console.log(err);
         
         // HTTP Status: 404 : NOT FOUND
         // Content Type: text/plain
         response.writeHead(404, {'Content-Type': 'text/html'});
      } else {	
         //Page found	  
         // HTTP Status: 200 : OK
         // Content Type: text/plain
         response.writeHead(200, {'Content-Type': 'text/html'});	
         
         // Write the content of the file to response body
         response.write(data.toString());		
      }
      
      // Send the response body 
      response.end();
   });   
}).listen(8081);

// Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

A seguir, vamos criar o seguinte arquivo html denominado index.htm no mesmo diretório onde você criou server.js.

File: index.htm

<html>
   <head>
      <title>Sample Page</title>
   </head>
   
   <body>
      Hello World!
   </body>
</html>

Agora vamos executar o server.js para ver o resultado -

$ node server.js

Verifique a saída.

Server running at http://127.0.0.1:8081/

Faça uma solicitação ao servidor Node.js

Abra http://127.0.0.1:8081/index.htm em qualquer navegador para ver o seguinte resultado.

Verifique a saída no final do servidor.

Server running at http://127.0.0.1:8081/
Request for /index.htm received.

Criação de cliente Web usando Node

Um cliente da web pode ser criado usando httpmódulo. Vamos verificar o seguinte exemplo.

Crie um arquivo js chamado client.js -

File: client.js

var http = require('http');

// Options to be used by request 
var options = {
   host: 'localhost',
   port: '8081',
   path: '/index.htm'  
};

// Callback function is used to deal with response
var callback = function(response) {
   // Continuously update stream with data
   var body = '';
   response.on('data', function(data) {
      body += data;
   });
   
   response.on('end', function() {
      // Data received completely.
      console.log(body);
   });
}
// Make a request to the server
var req = http.request(options, callback);
req.end();

Agora execute o client.js a partir de um terminal de comando diferente do server.js para ver o resultado -

$ node client.js

Verifique a saída.

<html>
   <head>
      <title>Sample Page</title>
   </head>
   
   <body>
      Hello World!
   </body>
</html>

Verifique a saída no final do servidor.

Server running at http://127.0.0.1:8081/
Request for /index.htm received.

Visão geral expressa

Express é uma estrutura de aplicativo da web Node.js mínima e flexível que fornece um conjunto robusto de recursos para desenvolver aplicativos da web e móveis. Ele facilita o rápido desenvolvimento de aplicativos da Web baseados em Node. A seguir estão alguns dos principais recursos da estrutura Express -

• Permite configurar middlewares para responder a solicitações HTTP.

• Define uma tabela de roteamento que é usada para realizar diferentes ações com base no método HTTP e URL.

• Permite renderizar páginas HTML dinamicamente com base na passagem de argumentos para modelos.

Instalando o Express

Em primeiro lugar, instale a estrutura Express globalmente usando NPM para que possa ser usada para criar um aplicativo da web usando terminal de nó.

$ npm install express --save

O comando acima salva a instalação localmente no node_modulesdiretório e cria um diretório expresso dentro de node_modules. Você deve instalar os seguintes módulos importantes junto com express -

• body-parser - Este é um middleware node.js para lidar com dados de formulários codificados em JSON, Raw, Texto e URL.

• cookie-parser - Analisar o cabeçalho do cookie e preencher req.cookies com um objeto codificado pelos nomes dos cookies.

• multer - Este é um middleware node.js para lidar com multipart / form-data.

$ npm install body-parser --save
$ npm install cookie-parser --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 8081 para conexão. Este aplicativo responde comHello World!para pedidos à página inicial. Para cada outro caminho, ele responderá com um404 Not Found.

var express = require('express');
var app = express();

app.get('/', function (req, res) {
   res.send('Hello World');
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   
   console.log("Example app listening at http://%s:%s", host, port)
})

Salve o código acima em um arquivo chamado server.js e execute-o com o seguinte comando.

$ node server.js

Você verá a seguinte saída -

Example app listening at http://0.0.0.0:8081

Abra http://127.0.0.1:8081/ em qualquer navegador para ver o seguinte resultado.

Pedido e Resposta

O aplicativo expresso usa uma função de retorno de chamada cujos parâmetros são request e response objetos.

app.get('/', function (req, res) {
   // --
})

• Objeto de solicitação - o objeto de solicitação representa a solicitação HTTP e tem propriedades para a string de consulta da solicitação, parâmetros, corpo, cabeçalhos HTTP e assim por diante.

• Objeto de resposta - o objeto de resposta representa a resposta HTTP que um aplicativo Express envia ao obter uma solicitação HTTP.

Você pode imprimir req e res objetos que fornecem muitas informações relacionadas à solicitação e resposta HTTP, incluindo cookies, sessões, URL, etc.

Roteamento Básico

Vimos um aplicativo básico que atende a solicitações HTTP para a página inicial. O roteamento se refere à determinação de como um aplicativo responde a uma solicitação do cliente para um determinado ponto de extremidade, que é um URI (ou caminho) e um método de solicitação HTTP específico (GET, POST e assim por diante).

Estenderemos nosso programa Hello World para lidar com mais tipos de solicitações HTTP.

var express = require('express');
var app = express();

// This responds with "Hello World" on the homepage
app.get('/', function (req, res) {
   console.log("Got a GET request for the homepage");
   res.send('Hello GET');
})

// This responds a POST request for the homepage
app.post('/', function (req, res) {
   console.log("Got a POST request for the homepage");
   res.send('Hello POST');
})

// This responds a DELETE request for the /del_user page.
app.delete('/del_user', function (req, res) {
   console.log("Got a DELETE request for /del_user");
   res.send('Hello DELETE');
})

// This responds a GET request for the /list_user page.
app.get('/list_user', function (req, res) {
   console.log("Got a GET request for /list_user");
   res.send('Page Listing');
})

// This responds a GET request for abcd, abxcd, ab123cd, and so on
app.get('/ab*cd', function(req, res) {   
   console.log("Got a GET request for /ab*cd");
   res.send('Page Pattern Match');
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   
   console.log("Example app listening at http://%s:%s", host, port)
})

Salve o código acima em um arquivo chamado server.js e execute-o com o seguinte comando.

$ node server.js

Você verá a seguinte saída -

Example app listening at http://0.0.0.0:8081

Agora você pode tentar diferentes solicitações em http://127.0.0.1:8081 para ver a saída gerada por server.js. A seguir estão algumas capturas de tela mostrando diferentes respostas para diferentes URLs.

Tela mostrando novamente http://127.0.0.1:8081/list_user

Tela mostrando novamente http://127.0.0.1:8081/abcd

Tela mostrando novamente http://127.0.0.1:8081/abcdefg

Servindo arquivos estáticos

O Express fornece um middleware integrado express.static 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 express.staticmiddleware para começar a servir os arquivos diretamente. Por exemplo, se você mantiver suas imagens, arquivos CSS e JavaScript em um diretório denominado público, poderá fazer isso -

app.use(express.static('public'));

Vamos manter algumas imagens em public/images subdiretório da seguinte forma -

node_modules
server.js
public/
public/images
public/images/logo.png

Vamos modificar o aplicativo "Hello Word" para adicionar a funcionalidade de lidar com arquivos estáticos.

var express = require('express');
var app = express();

app.use(express.static('public'));

app.get('/', function (req, res) {
   res.send('Hello World');
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

Salve o código acima em um arquivo chamado server.js e execute-o com o seguinte comando.

$ node server.js

Agora abra http://127.0.0.1:8081/images/logo.png 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 usarprocess_get roteador dentro de server.js para lidar com essa entrada.

<html>
   <body>
      
      <form action = "http://127.0.0.1:8081/process_get" method = "GET">
         First Name: <input type = "text" name = "first_name">  <br>
         Last Name: <input type = "text" name = "last_name">
         <input type = "submit" value = "Submit">
      </form>
      
   </body>
</html>

Vamos salvar o código acima em index.htm e modificar server.js para lidar com as solicitações da página inicial, bem como a entrada enviada pelo formulário HTML.

var express = require('express');
var app = express();

app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
   res.sendFile( __dirname + "/" + "index.htm" );
})

app.get('/process_get', function (req, res) {
   // Prepare output in JSON format
   response = {
      first_name:req.query.first_name,
      last_name:req.query.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   
   console.log("Example app listening at http://%s:%s", host, port)
})

Acessar o documento HTML usando http://127.0.0.1:8081/index.htm irá gerar o seguinte formulário -

Agora você pode inserir o nome e o sobrenome e clicar no botão enviar para ver o resultado e deve retornar o seguinte resultado -

{"first_name":"John","last_name":"Paul"}

Método POST

Aqui está um exemplo simples que passa dois valores usando o método HTML FORM POST. Vamos usarprocess_get roteador dentro de server.js para lidar com essa entrada.

<html>
   <body>
      
      <form action = "http://127.0.0.1:8081/process_post" method = "POST">
         First Name: <input type = "text" name = "first_name"> <br>
         Last Name: <input type = "text" name = "last_name">
         <input type = "submit" value = "Submit">
      </form>
      
   </body>
</html>

Vamos salvar o código acima em index.htm e modificar server.js para lidar com as solicitações da página inicial, bem como a entrada enviada pelo formulário HTML.

var express = require('express');
var app = express();
var bodyParser = require('body-parser');

// Create application/x-www-form-urlencoded parser
var urlencodedParser = bodyParser.urlencoded({ extended: false })

app.use(express.static('public'));
app.get('/index.htm', function (req, res) {
   res.sendFile( __dirname + "/" + "index.htm" );
})

app.post('/process_post', urlencodedParser, function (req, res) {
   // Prepare output in JSON format
   response = {
      first_name:req.body.first_name,
      last_name:req.body.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   
   console.log("Example app listening at http://%s:%s", host, port)
})

Acessar o documento HTML usando http://127.0.0.1:8081/index.htm irá gerar o seguinte formulário -

Agora você pode inserir o nome e o sobrenome e, em seguida, clicar no botão enviar para ver o seguinte resultado -

{"first_name":"John","last_name":"Paul"}

Upload de arquivo

O código HTML a seguir cria um formulário de upload de arquivo. Este formulário possui atributo de método definido comoPOST e o atributo enctype é definido como multipart/form-data

<html>
   <head>
      <title>File Uploading Form</title>
   </head>

   <body>
      <h3>File Upload:</h3>
      Select a file to upload: <br />
      
      <form action = "http://127.0.0.1:8081/file_upload" method = "POST" 
         enctype = "multipart/form-data">
         <input type="file" name="file" size="50" />
         <br />
         <input type = "submit" value = "Upload File" />
      </form>
      
   </body>
</html>

Vamos salvar o código acima em index.htm e modificar o server.js para lidar com as solicitações da página inicial e também com o upload de arquivos.

var express = require('express');
var app = express();
var fs = require("fs");

var bodyParser = require('body-parser');
var multer  = require('multer');

app.use(express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}));

app.get('/index.htm', function (req, res) {
   res.sendFile( __dirname + "/" + "index.htm" );
})

app.post('/file_upload', function (req, res) {
   console.log(req.files.file.name);
   console.log(req.files.file.path);
   console.log(req.files.file.type);
   var file = __dirname + "/" + req.files.file.name;
   
   fs.readFile( req.files.file.path, function (err, data) {
      fs.writeFile(file, data, function (err) {
         if( err ) {
            console.log( err );
            } else {
               response = {
                  message:'File uploaded successfully',
                  filename:req.files.file.name
               };
            }
         
         console.log( response );
         res.end( JSON.stringify( response ) );
      });
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   
   console.log("Example app listening at http://%s:%s", host, port)
})

Acessar o documento HTML usando http://127.0.0.1:8081/index.htm irá gerar o seguinte formulário -

File Upload:
Select a file to upload: 





NOTE: This is just dummy form and would not work, but it must work at your server.

Gestão de Cookies

Você pode enviar cookies para um servidor Node.js que pode lidar com o mesmo usando a seguinte opção de middleware. A seguir está um exemplo simples para imprimir todos os cookies enviados pelo cliente.

var express      = require('express')
var cookieParser = require('cookie-parser')

var app = express()
app.use(cookieParser())

app.get('/', function(req, res) {
   console.log("Cookies: ", req.cookies)
})
app.listen(8081)

O que é arquitetura REST?

REST significa Transferência de Estado Representacional. REST é uma arquitetura baseada em padrões da web e usa 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 a recursos e o 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 como 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 acesso somente leitura a um recurso.

• PUT - Isso é usado para criar um novo recurso.

• DELETE - Isso é usado para remover um recurso.

• POST - Isso é usado para atualizar um recurso existente ou criar um novo recurso.

Serviços da Web RESTful

Um serviço da web é uma coleção de protocolos e padrões abertos usados ​​para trocar dados entre aplicativos ou sistemas. Os aplicativos de software escritos em várias linguagens de programação e em execução em várias plataformas podem usar serviços da web para trocar dados em redes de computadores como a Internet de uma 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. Esses serviços da web usam métodos HTTP para implementar o conceito de arquitetura REST. Um serviço da web RESTful geralmente define um URI, Uniform Resource Identifier um serviço, 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 users.json:

{
   "user1" : {
      "name" : "mahesh",
      "password" : "password1",
      "profession" : "teacher",
      "id": 1
   },
   
   "user2" : {
      "name" : "suresh",
      "password" : "password2",
      "profession" : "librarian",
      "id": 2
   },
   
   "user3" : {
      "name" : "ramesh",
      "password" : "password3",
      "profession" : "clerk",
      "id": 3
   }
}

Com base nessas informações, forneceremos as seguintes APIs RESTful.

Sr. Não.	URI	Método HTTP	POST body	Resultado
1	listUsers	PEGUE	vazio	Mostra a lista de todos os usuários.
2	adicionar usuário	POSTAR	String JSON	Adicione detalhes do novo usuário.
3	deletar usuário	EXCLUIR	String JSON	Exclua um usuário existente.
4	:Eu iria	PEGUE	vazio	Mostra os detalhes de um usuário.

Estou mantendo a maior parte de todos os exemplos na forma de codificação, presumindo que você já saiba como passar valores do front end usando Ajax ou dados de formulário simples e como processá-los usando express Request objeto.

Listar usuários

Vamos implementar nossa primeira API RESTful listUsers usando o seguinte código em um arquivo server.js -

server.js

var express = require('express');
var app = express();
var fs = require("fs");

app.get('/listUsers', function (req, res) {
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      console.log( data );
      res.end( data );
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

Agora tente acessar a API definida usando URL: http://127.0.0.1:8081/listUsers e Método HTTP: GET na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado -

Você pode alterar o endereço IP fornecido quando colocar a solução no ambiente de produção.

{
   "user1" : {
      "name" : "mahesh",
      "password" : "password1",
      "profession" : "teacher",
      "id": 1
   },
   
   "user2" : {
      "name" : "suresh",
      "password" : "password2",
      "profession" : "librarian",
      "id": 2
   },
   
   "user3" : {
      "name" : "ramesh",
      "password" : "password3",
      "profession" : "clerk",
      "id": 3
   }
}

Adicionar usuário

A API a seguir mostrará como adicionar um novo usuário à lista. A seguir estão os detalhes do novo usuário -

user = {
   "user4" : {
      "name" : "mohit",
      "password" : "password4",
      "profession" : "teacher",
      "id": 4
   }
}

Você pode aceitar a mesma entrada na forma de JSON usando a chamada Ajax, mas para o ponto de vista do ensino, estamos tornando-a codificada aqui. A seguir está oaddUser API para um novo usuário no banco de dados -

server.js

var express = require('express');
var app = express();
var fs = require("fs");

var user = {
   "user4" : {
      "name" : "mohit",
      "password" : "password4",
      "profession" : "teacher",
      "id": 4
   }
}

app.post('/addUser', function (req, res) {
   // First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      data = JSON.parse( data );
      data["user4"] = user["user4"];
      console.log( data );
      res.end( JSON.stringify(data));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

Agora tente acessar a API definida usando URL: http://127.0.0.1:8081/addUser e Método HTTP: POST na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado -

{
   "user1":{"name":"mahesh","password":"password1","profession":"teacher","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":"teacher","id":4}
}

Mostrar Detalhe

Agora vamos implementar uma API que será chamada usando o ID do usuário e exibirá o detalhe do usuário correspondente.

server.js

var express = require('express');
var app = express();
var fs = require("fs");

app.get('/:id', function (req, res) {
   // First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      var users = JSON.parse( data );
      var user = users["user" + req.params.id] 
      console.log( user );
      res.end( JSON.stringify(user));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

Agora tente acessar a API definida usando URL: http://127.0.0.1:8081/2 e Método HTTP: GET na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado -

{"name":"suresh","password":"password2","profession":"librarian","id":2}

Deletar usuário

Esta API é muito semelhante à API addUser, onde recebemos dados de entrada por meio de req.body e, com base no ID do usuário, excluímos esse usuário do banco de dados. Para manter nosso programa simples, presumimos que excluiremos o usuário com ID 2.

server.js

var express = require('express');
var app = express();
var fs = require("fs");

var id = 2;

app.delete('/deleteUser', function (req, res) {
   // First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      data = JSON.parse( data );
      delete data["user" + 2];
       
      console.log( data );
      res.end( JSON.stringify(data));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

Agora tente acessar a API definida usando URL: http://127.0.0.1:8081/deleteUser e Método HTTP: DELETE na máquina local usando qualquer cliente REST. Isso deve produzir o seguinte resultado -

{"user1":{"name":"mahesh","password":"password1","profession":"teacher","id":1},
"user3":{"name":"ramesh","password":"password3","profession":"clerk","id":3}}

O Node.js é executado em um modo de thread único, mas usa um paradigma orientado a eventos para lidar com a simultaneidade. Ele também facilita a criação de processos filhos para aproveitar o processamento paralelo em sistemas baseados em CPU de vários núcleos.

Os processos filho sempre têm três fluxos child.stdin, child.stdout, e child.stderr que pode ser compartilhado com os streams stdio do processo pai.

Node fornece child_process módulo que possui as seguintes três maneiras principais de criar um processo filho.

• exec - o método child_process.exec executa um comando em um shell / console e armazena a saída em buffer.

• spawn - child_process.spawn inicia um novo processo com um determinado comando.

• fork - O método child_process.fork é um caso especial de 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

Aqui está a descrição dos parâmetros usados ​​-

• command (String) O comando a ser executado, com argumentos separados por espaço

• options (Objeto) pode incluir uma ou mais das seguintes opções -

  • cwd (String) Diretório de trabalho atual do processo filho

  • env (Objeto) Pares de valores-chave do ambiente

  • encoding (String) (Padrão: 'utf8')

  • shell (String) Shell para executar o comando com (Padrão: '/ bin / sh' no UNIX, 'cmd.exe' no Windows, O shell deve compreender a opção -c no UNIX ou / s / c no Windows. No Windows, a análise da linha de comando deve ser compatível com cmd.exe.)

  • timeout (Número) (Padrão: 0)

  • maxBuffer (Número) (Padrão: 200 * 1024)

  • killSignal (String) (Padrão: 'SIGTERM')

  • uid (Número) Define a identidade do usuário do processo.

  • gid (Número) Define a identidade do grupo do processo.

• callback 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 um tamanho máximo e espera o processo terminar e tenta retornar todos os dados do buffer de uma vez.

Exemplo

Vamos criar dois arquivos js chamados support.js e master.js -

File: support.js

console.log("Child Process " + process.argv[2] + " executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var workerProcess = child_process.exec('node support.js '+i,function 
      (error, stdout, stderr) {
      
      if (error) {
         console.log(error.stack);
         console.log('Error code: '+error.code);
         console.log('Signal received: '+error.signal);
      }
      console.log('stdout: ' + stdout);
      console.log('stderr: ' + stderr);
   });

   workerProcess.on('exit', function (code) {
      console.log('Child process exited with exit code '+code);
   });
}

Agora execute o master.js para ver o resultado -

$ node master.js

Verifique a saída. O servidor foi iniciado.

Child process exited with exit code 0
stdout: Child Process 1 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 0 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 2 executed.

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

Aqui está a descrição dos parâmetros usados ​​-

• command (String) O comando a ser executado

• args (Array) Lista de argumentos de string

• options (Objeto) pode incluir uma ou mais das seguintes opções -

  • cwd (String) Diretório de trabalho atual do processo filho.

  • env (Objeto) Pares de valores-chave do ambiente.

  • stdio (Array) Configuração de stdio de String Child.

  • customFds (Matriz) Descritores de arquivo obsoletos para a criança usar para stdio.

  • detached (Booleano) A criança será um líder do grupo de processo.

  • uid (Número) Define a identidade do usuário do processo.

  • gid (Número) Define a identidade do grupo do processo.

O método spawn () retorna streams (stdout & stderr) e deve ser usado quando o processo retorna uma quantidade de 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 support.js e master.js -

File: support.js

console.log("Child Process " + process.argv[2] + " executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');
 
for(var i = 0; i<3; i++) {
   var workerProcess = child_process.spawn('node', ['support.js', i]);

   workerProcess.stdout.on('data', function (data) {
      console.log('stdout: ' + data);
   });

   workerProcess.stderr.on('data', function (data) {
      console.log('stderr: ' + data);
   });

   workerProcess.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

Agora execute o master.js para ver o resultado -

$ node master.js

Verifique a saída. O servidor começou

stdout: Child Process 0 executed.

child process exited with code 0
stdout: Child Process 1 executed.

stdout: Child Process 2 executed.

child process exited with code 0
child process exited with code 0

Método fork ()

O método child_process.fork é um caso especial de spawn () para criar processos Node. Possui a seguinte assinatura -

child_process.fork(modulePath[, args][, options])

Parâmetros

Aqui está a descrição dos parâmetros usados ​​-

• modulePath (String) O módulo a ser executado no filho.

• args (Array) Lista de argumentos de string

• options (Objeto) pode incluir uma ou mais das seguintes opções -

  • cwd (String) Diretório de trabalho atual do processo filho.

  • env (Objeto) Pares de valores-chave do ambiente.

  • execPath (String) Executável usado para criar o processo filho.

  • execArgv (Array) Lista de argumentos de string passados ​​para o executável (Padrão: process.execArgv).

  • silent (Booleano) Se verdadeiro, stdin, stdout e stderr do filho serão canalizados para o pai, caso contrário, serão herdados do pai, consulte as opções "canalizar" e "herdar" para stdio de spawn () para mais detalhes (o padrão é falso).

  • uid (Número) Define a identidade do usuário do processo.

  • gid (Número) Define a identidade do grupo do processo.

O método fork retorna um objeto com um canal de comunicação integrado, além de ter todos os métodos em uma instância normal de ChildProcess.

Exemplo

Crie dois arquivos js chamados support.js e master.js -

File: support.js

console.log("Child Process " + process.argv[2] + " executed." );

File: master.js

const fs = require('fs');
const child_process = require('child_process');
 
for(var i=0; i<3; i++) {
   var worker_process = child_process.fork("support.js", [i]);	

   worker_process.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

Agora execute o master.js para ver o resultado -

$ node master.js

Verifique a saída. O servidor foi iniciado.

Child Process 0 executed.
Child Process 1 executed.
Child Process 2 executed.
child process exited with code 0
child process exited with code 0
child process exited with code 0

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 grande projeto que consiste em muitos arquivos. JXcore pode empacotá-los todos em um único arquivo para simplificar a distribuição. Este capítulo fornece uma visão geral rápida de todo o processo, começando com a instalação do JXcore.

Instalação JXcore

Instalar o JXcore é bastante simples. Aqui fornecemos instruções passo a passo sobre como instalar o JXcore em seu sistema. Siga as etapas abaixo -

Passo 1

Baixe o pacote JXcore de https://github.com/jxcore/jxcore, de acordo com seu sistema operacional e arquitetura de máquina. Baixamos um pacote para Cenots rodando em uma máquina de 64 bits.

$ wget https://s3.amazonaws.com/nodejx/jx_rh64.zip

Passo 2

Descompacte o arquivo baixado jx_rh64.zipe copie o binário jx em / usr / bin ou pode estar em qualquer outro diretório com base na configuração do sistema.

$ unzip jx_rh64.zip
$ cp jx_rh64/jx /usr/bin

etapa 3

Defina sua variável PATH apropriadamente para executar jx de qualquer lugar que você quiser.

$ export PATH=$PATH:/usr/bin

Passo 4

Você pode verificar sua instalação emitindo um comando simples, conforme mostrado abaixo. Você deve encontrá-lo funcionando e imprimindo seu número de versão da seguinte maneira -

$ jx --version
v0.10.32

Empacotando o Código

Considere que você tem um projeto com os seguintes diretórios onde você manteve todos os seus arquivos, incluindo Node.js, arquivo principal, index.js e todos os módulos instalados localmente.

drwxr-xr-x  2 root root  4096 Nov 13 12:42 images
-rwxr-xr-x  1 root root 30457 Mar  6 12:19 index.htm
-rwxr-xr-x  1 root root 30452 Mar  1 12:54 index.js
drwxr-xr-x 23 root root  4096 Jan 15 03:48 node_modules
drwxr-xr-x  2 root root  4096 Mar 21 06:10 scripts
drwxr-xr-x  2 root root  4096 Feb 15 11:56 style

Para empacotar o projeto acima, você simplesmente precisa entrar neste diretório e emitir o seguinte comando jx. Supondo que index.js seja o arquivo de entrada para seu projeto Node.js -

$ jx package index.js index

Aqui você poderia ter usado qualquer outro nome de pacote em vez de index. Nós usamos indexporque queríamos manter nosso nome de arquivo principal como index.jx. No entanto, o comando acima empacotará tudo e criará os dois arquivos a seguir -

• index.jxp Este é um arquivo intermediário que contém os detalhes completos do projeto necessários para compilar o projeto.

• index.jx Este é o arquivo binário que contém o pacote completo que está pronto para ser enviado ao seu cliente ou ao seu ambiente de produção.

Iniciando arquivo JX

Considere que seu projeto Node.js original estava sendo executado da seguinte maneira -

$ node index.js command_line_arguments

Depois de compilar seu pacote usando JXcore, ele pode ser iniciado da seguinte maneira -

$ jx index.jx command_line_arguments

Para saber mais sobre o JXcore, você pode conferir seu site oficial.