1. Home
  2. NodeJs
  3. Referência rápida de Node.js

Referência rápida de Node.js

Índice

1- Sobre o Node.js

O Node.js foi criado por Ryan Dahl em 2009 ele é um runtime que roda código Javascript no servidor utilizando o V8, que é o runtime de Javascript do browser Google Chrome.

Para entender isso melhor, é importante falar um pouco sobre Javascript:

Javascript (também conhecido por JS) é uma linguagem de programação que roda nos browsers (por isso também é chamada de linguagem de script para páginas Web) e que adiciona dinamismo às páginas HTML, que são em sua essência páginas estáticas somente com textos, imagens e links.

Podemos utilizar como exemplo o Gmail, quando você arrasta um e-mail para uma pasta:

Para saber mais sobre Javascript consulte: Referência Javascript

O Javascript tradicionalmente roda no seu Browser. Você baixa a página do servidor e o engine de Javascript do seu browser executa o código.

Cada browser tem o seu motor de Javascript (engine), que executa o código Javascript:

A ideia por trás do Node.js é poder rodar Javascript no servidor, para isso o motor de Javascript do Chrome (chamado V8) foi modificado para se tornar o Node.js.

Quando o browser solicita uma página do servidor, se a aplicação utiliza Node.js o código Javascript escrito e que está armazenado no servidor é executado pelo Node.js e o HTML resultante é enviado para o usuário, que visualiza essa página no browser.

Referências (en-US):

Single Thread

Ao contrário de outras linguagens como C# ou Java o Node.js é “single thread”, ou seja, todo o código é executado em uma única thread, sem processamento concorrente. Para evitar que o sistema fique travado aguardando operações demoradas, como obter um dado do banco de dados, o Node.js e suas bibliotecas utilizam o modelo assíncrono, ou seja, a thread principal recebe a requisição e toda execução que for mais demorada, como consulta a um banco de dados, é executada de forma assíncrona. A thread principal solicita a execução (de forma assíncrona) e quando a resposta estiver pronta, o componente notifica a thread principal, que então continua com o processamento da requisição e ao final responde ao usuário. Utilizar uma única thread tem a vantagem de evitar a complexidade que o gerenciamento de threads trás para o código escrito.

EventLoop

O EventLoop é o que permite que o Node.js execute operações de I/O de forma “non-blocking” apesar do fato do Javascript ser single thread. Ou seja, é possível realizar uma operação de I/O (Input/Output) como ler um arquivo, que é uma tarefa demorada, sem travar a thread principal do Node.js.

Diferenças do Javascript rodando no servidor

Comparando código Javascript rodando no browser com código Javascript rodando no servidor (Node.js) temos as seguintes diferenças:

Recurso Browser Node.js Detalhes
DOM e Window Sim Não No Node.js não há acesso a API do browser, ex: document.querySelector(), fetch ou location
Tipo de aplicativos Interativos Rodando no Servidor No Node.js os aplicativos rodam no servidor e o resultado é enviado para o cliente junto com o HTML, não há parte gráfica como no Javascript rodando no browser em que o usuário clica em um botão e uma div pode ser exibida ou ocultada
Filesystem Não Sim No Node.js é possível acessar ou gravar arquivos no computador que está executando o código
Versões Fragmentação Versão rodando Javascript rodando no browser depende da versão do Browser que o usuário está utilizando e cada usuário pode estar utilizando um browser diferente, que pode ou não ter suporte a uma feature que estamos utilizando. Node.js depende apenas da versão do Node instalada no servidor

2- Referências de Node.js

Documentação da API (en-US): https://Node.js.org/api/

Guides (en-US): https://Node.js.org/en/docs/guides/

Node.js full course - freeCodeCamp.org (en-US): https://www.youtube.com/watch?v=Oe421EPjeBE

3- Instalação

Instalação no Windows

É possível instalar o Nodejs rodando diretamente o instalador disponível no site oficial: https://Node.js.org/en/

.

NO ENTANTO… é muito comum trabalhar com vários projetos ao mesmo tempo no mesmo computador e cada projeto depender de uma versão específica do Node. Por isso, ao invés de instalar uma única versão, é recomendado seguir o processo abaixo para instalar o NVM, que é um gerenciador de versões do Node que permite instalar diferentes versões ao mesmo tempo no mesmo computador.

.

Se já tiver o Node instalado diretamente no Windows, desinstale ele primeiro utilizando a função adicionar/remover programas do Painel de Controle do Windows.

Para instalar o Node utilizando o NVM são duas estapas:

1- Instalação do NVM

Onde você vai instalar?

Se você está rodando no Windows uma sugestão é instalar tanto no Windows (1.1) quanto no WSL (1.2), cada ambiente é separado.

1.1- Instalação do NVM no Windows

Faça o download do arquivo nvm-setup.zip no site do NVM e execute o instalador: https://github.com/coreybutler/nvm-windows/releases

Para testar a instalação, abra um prompt e execute:

nvm --version

Agora, siga os passos do tópico abaixo: Instale o Node usando o NVM

NOTA: Você pode ter o node instalado tanto no Windows, quanto no Linux rodando dentro do WSL, basta repetir o processo nos dois ambientes.

1-2- Instalação do NVM no WSL rodando no Windows

Veja aqui instruções de como instalar o WSL: Rodando o Linux junto com o Windows

Então, abra um prompt do WSL:

Para instalar o NVM, execute:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

Nota: Por favor pegue o link da versão mais recente no site: https://github.com/nvm-sh/nvm#installing-and-updating

Depois execute:

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

Para verificar a instalação execute:

nvm --version

Agora, siga os passos do tópico abaixo: Instale o Node usando o NVM

1.3- Instalação do NVM no Linux

Para instalar o NVM abra um prompt de comando e execute:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

Nota: Por favor pegue o link da versão mais recente no site: https://github.com/nvm-sh/nvm#installing-and-updating

Depois execute:

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

Para verificar a instalação execute:

nvm --version

Agora, siga os passos do tópico abaixo: Instale o Node usando o NVM

2- Instalação do Node utilizando o NVM

Agora, utilizando o NVM vamos instalar o Node:

Instale o Node no Windows utilizando o NVM

Acesse o site do Node: https://nodejs.org/en/ e verifique qual a última versão LTS disponível.

No meu caso a última versão LTS disponível é a 16.14.0, então vou instalar ela.

Abra um prompt de comando e digite:

nvm install 16.14.0

O NVM irá baixar a versão do Node e instalar. Depois da instalação execute:

nvm use 16.14.0

Verifique a versão do node rodando

Então, a versão estará pronta para uso, você pode testar:

node --version

Repetindo o mesmo processo:

nvm install [version]
nvm use [version]

você pode instalar outras versões.

Mais informações sobre a instalação do Node usando NVL no Windows, aqui: https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows

Mais informações sobre como usar o NVM, aqui: https://github.com/coreybutler/nvm-windows

4- IDEs

Agora, você pode instalar uma IDE para facilitar o desenvolvimento. Abaixo algumas opções:

VSCode (recomendo esse)

O VSCode é bastante funcional e rápido para desenvolver em diferentes plataformas, incluindo Node.js.

O VSCode é um editor FREE, rápido, leve e com uma infinidade de extensões para diferentes linguagens de programação, o que faz com que ele seja uma ótima opção para diferentes usos, vale destacar também que ele ganhou com folga a primeira posição da pesquisa anual do Stack Overflow de 2021 (link) como a IDE mais utilizada por programadores.

5- Hello World

Imprimindo Hello World no console

Crie uma pasta “hello” e abra ela no VSCode (botão direito na pasta / Open with code)

No VSCode crie um arquivo “app.js” e insira o conteúdo abaixo:

console.log('Hello World!')

Então, abra o terminal no VsCode (menu: Terminal / New Terminal) e digite:

node app.js

Será impresso no console a mensagem: Hello World!

API Hello World

Agora, vamos modificar o código para ser uma aplicação web, ao acessar pelo browser uma Url será retornada a mensagem Hello World.

Altere o conteúdo do arquivo “app.js” para:

const http = require("http");

const hostname = "127.0.0.1";
const port = 3000;

const server = http.createServer(function(req, res) {
   res.writeHead(200, {'Content-Type': 'text/plain'});
   res.end('Hello World\n');
});

server.listen(port, hostname, function() {
   console.log(`Server running at http://${hostname}:${port}/`);
})

E execute novamente:

node app.js

Então utilizando o browser, acesse:

http://127.0.0.1:3000/

Será exibida a mensagem: “Hello World”

6- Básico

Lembrando que o Node é um runtime que roda Javascript, então o código que você irá escrever é Javascript.

Para referência da linguagem Javascript consulte:

Referência Javascript

Aqui serão descritos somente itens referentes a utilização de Node.

Globals

Itens com escopo Global podem ser acessados em qualquer arquivo. São eles:

Por exemplo, se criar o arquivo app.js na pasta c:\temp com o conteúdo abaixo:

console.log(__dirname)
console.log(__filename)

Ao executar:

node app.js

Será exibido:

c:\temp
c:\temp\app.js

Módulos

Abaixo um exemplo de como itens são exportados e importados. No exemplo são utilizados 3 arquivos diferentes:

names-list.js

//local
const secret = 'SUPER SECRET'
// share
const john = 'john'
const peter = 'peter'

module.exports = { john, peter }

utils.js

const sayHi = (name) => {
    console.log(`Hello there ${name}`)
}

module.exports = sayHi

app.js

const names = require('./names-list')
const sayHi = require('./utils')

sayHi('susan')
sayHi(names.john)
sayHi(names.peter)

Ao executar:

node app.js

Será exibido:

Hello there susan
Hello there john
Hello there peter

Acima vimos duas formas de exportar:

1- Exportar um valor

//exporta um valor
const sayHi = (name) => {
    console.log(`Hello there ${name}`)
}
module.exports = sayHi

//que é utilizado assim:
const sayHi = require('./utils')
sayHi('susan')

2- Exportar vários valores

//exportar vários valores
const john = 'john'
const peter = 'peter'
module.exports = { john, peter }

//que são utilizados assim:
const names = require('./names-list')
sayHi(names.john)
sayHi(names.peter)

e também é possível fazer assim:

3- Outra forma de exportar vários valores:

//exportar vários valores
module.exports.items = ['item1', 'item2']
const person = {
	name: 'bob'
}
module.exports.singlePerson = person

//uso
const data = require('./6-other')
console.log(data.items);
console.log(data.singlePerson);

Utilizando Built-in modules

O Node tem alguns módulos internos, para utiliza-los, basta importar o pacote e realizar a chamada. Por exemplo:

const os = require('os')

console.log(os.platform()) //retorna informações do sistema operacional, no Windows por exemplo retorna 'win32'

Abaixo tem a lista de alguns Built-in modules: 7-Builtin Modules

Utilizando pacotes

Para utilizar um pacote externo é necessário adicionar a dependência no projeto. O repositório oficial de pacotes do Node é o NPM, disponível em: https://www.npmjs.com/, ele possui milhares de pacotes.

Abaixo tem as instruções de como trabalhar com pacotes e mais para frente uma lista com pacotes bastante utilizados: 8-Packages/Libs

Criando o arquivo de dependências

Os pacotes instalados no projeto ficam no arquivo package.json, para criar esse arquivo de forma fácil, execute:

npm init -y

Adicionar dependência

Para instalar um pacote, utilize:

npm i <package-name>

por exemplo, para instalar o pacote lodash, execute:

npm i lodash

Nota: i=install

Serão realizadas as seguintes alterações:

1- A dependência será adicionada no arquivo “package.json” no bloco “dependencies” 2- O pacote será baixado na pasta node_modules 3- O número da versão baixada para cada um dos pacotes que esse pacote depende será adicionada no arquivo .package-lock.json

Veja abaixo como utilizar uma dependência baixada

Para mais informações sobre os arquivos package.json acesse: https://nodesource.com/blog/the-basics-of-package-json-in-node-js-and-npm/

Adicionar dependência dev

Para adicionar uma dependência que será utilizada somente no ambiente de desenvolvimento (por exemplo pacotes para build, deploy, debug, lint, etc), utilize:

npm install <package-name> --save-dev

Por exemplo, para instalar a dependência do nodemon, execute:

npm install nodemon --save-dev

As dependências de dev são adicionadas no arquivo “package.json” no bloco “devDependencies”

Adicionar dependência global

É possível adicionar uma dependência globalmente no seu computador, assim todos os projetos node que você baixar vão poder utilizar essa dependência. Para fazer isso, execute:

npm install <package-name> -g

Por exemplo, para instalar o nodemon, execute:

npm install nodemon -g

Assim, você poderá executar:

nodemon app.js

Mesmo sem adicionar esse pacote como dependência de dev do seu projeto.

Remover dependência

Para remover uma dependência, execute:

npm uninstall <package-name>

por exemplo, para remover o pacote loadsh, execute:

	npm uninstall loadsh

Restaurar todas as dependências

Quando você abre um projeto criado por outra pessoa, precisa baixar as dependências na pasta node_modules, normalmente não enviamos essa pasta junto com os projetos por que ela contém muitos arquivos, mas que podem ser facilmente restaurados. Para instalar as dependências de um projeto, execute:

npm i

Irá restaurar todas as dependências listadados no arquivo package.json. Se quiser testar como isso funciona no seu projeto, basta apagar a pasta node_modules e reodar o comando, a pasta será recriada com os pacotes.

Para subir um projeto Node no Git (ex: Github) inclua um arquivo .gitignore removendo a pasta node_modules:

node_modules/

Você pode incluir um arquivo .gitignore completo em: https://github.com/github/gitignore/blob/main/Node.gitignore

Utilizar o pacote

Depois de adicionar a dependência, basta utilizar require() assim como na utilização de BuiltIn modules, por exemplo:

const _ = require('lodash')

const items = [1, [2, [3, [4]]]]
const newItems = _.flattenDeep(items)
console.log(newItems) //[ 1, 2, 3, 4 ]

Scripts

No arquivo package.json é possível definir no bloco “scripts” comandos para executar. Por exemplo ao incluir:

"scripts": {
	"dev": "nodemon app.js"
},

Ao executar:

npm run dev

Serão executados os comandos especificados, nesse caso: “nodemon app.js”

Utilizando o nodemon dessa forma, a cada vez que você salvar o código a aplicação será reiniciada, isso facilita bastante o desenvolvimento porque você pode visualizar imediatamente o que está fazendo. Para finalizar o nodemon no console, digite: CTRL+C

Acessando um arquivo de forma síncrona

const { writeFile, readFile } = require('fs')

//Escrever um arquivo de forma sincrona
const contentWrite = `Arquivo atualizado em: ${Date()}`
writeFileSync('./test.txt', contentWrite)

//Ler um arquivo de forma sincrona
const contentRead = readFileSync('./test.txt', 'utf8')
console.log(contentRead)

NOTA: Deve-se evitar utilizar métodos síncronos porque eles travam o event loop, então vão fazer sua aplicação ficar lenta quando tiver muitos usuários, por isso prefira utilizar métodos assíncronos, como no próximo exemplo.

Acessando um arquivo de forma assíncrona

const { writeFile, readFile } = require('fs')

//Escrever um arquivo de forma assíncrona
const contentWrite = `Arquivo atualizado em: ${Date()}`
writeFile('./test.txt', contentWrite, (err, result) => {
	if (err) {
		console.log(err)
		return
	}

	//Ler um arquivo de forma assíncrona
	readFile('./test.txt', 'utf8', (err, result) => {
		if (err) {
			console.log(err)
			return
		}
		console.log(result)
	})
})

NOTA: Utilizando esse modelo de vários callbacks, o código costuma ficar confuso e de difícil manutenção, por isso prefira utilizar Promises como no próximo exemplo.

Acessando um arquivo utilizando Promises

const { writeFile, readFile } = require('fs')

const writeFile2 = (path, data) => {
    return new Promise((resolve, reject) => {
        writeFile(path, data, (err, data) => {
            if (err)
                reject(err)
            else
                resolve(data)
        })
    })
}

const readFile2 = (path) => {
    return new Promise((resolve, reject) => {
        readFile(path, 'utf-8', (err, data) => {
            if (err)
                reject(err)
            else
                resolve(data)
        })
    })
}

Depois de criar essas funções retornando Promisses, é possível:

Escrever no arquivo:

writeFile2(path, `Arquivo atualizado em: ${Date()}`)
	.then((result) => console.log('ok'))
	.catch((err) => console.error(err))

Ler o arquivo:

readFile2(path)
    .then((result) => console.log(result))
    .catch((err) => console.error(err))

E escrever e ler na sequência:

writeFile2(path, `Arquivo atualizado em: ${Date()}`)
    .then((result) => readFile2(path))
    .then((result) => console.log(result))
    .catch((err) => console.error(err))

NOTA: A maioria dos métodos de packages já retornam promises, então não será necessário criar um método para encapsular o método original como nesse caso.

Acessando um arquivo utilizando async/await

Temos uma forma ainda mais simples de escrever isso, utilizando o padrão async/await, assim:

const { writeFile, readFile } = require('fs')

const writeFile2 = (path, data) => {
    return new Promise((resolve, reject) => {
        writeFile(path, data, (err, data) => {
            if (err)
                reject(err)
            else
                resolve(data)
        })
    })
}

const readFile2 = (path) => {
    return new Promise((resolve, reject) => {
        readFile(path, 'utf-8', (err, data) => {
            if (err)
                reject(err)
            else
                resolve(data)
        })
    })
}

const start = async () => {
    const path = './test.txt';

    try {
        await writeFile2(path, `Arquivo atualizado em: ${Date()}`)
        const content = await readFile2(path)
        console.log(content);
    }
    catch (err) {
        console.error(err);
    }
}

start();

Transformando um método em Promise

Também é possível converter um método para Promise de uma forma mais simples, utilizando o módulo util:

const { readFile, writeFile } = require('fs')
const util = require('util')

const readFile2 = util.promisify(fs.readFile);
const writeFile2 = util.promisify(fs.writeFile);

const start = async () => {
    const path = './test.txt';

    try {
        await writeFile2(path, `Arquivo atualizado em: ${Date()}`)
        const content = await readFile2(path, 'utf-8')
        console.log(content);
    }
    catch (err) {
        console.error(err);
    }
}

start();

ou, a forma mais simples, basta adicionar “.promises” no require:

const { writeFile, readFile } = require('fs').promises

const start = async () => {
    const path = './test.txt';

    try {
        await writeFile(path, `Arquivo atualizado em: ${Date()}`)
        const content = await readFile(path, 'utf-8')
        console.log(content);
    }
    catch (err) {
        console.error(err);
    }
}

start();

Eventos

Para enviar ou receber eventos, utilizamos o builtin module “events” e os métodos:

A sintaxe básica é a seguinte:

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

customEmitter.on('event1', () => {
    console.log(`event1 received`)
})

customEmitter.emit('event1')

Também é possível enviar parâmetros junto com o evento:

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

customEmitter.on('event2', (id, name) => {
    console.log(`event1 received -- ${id}, ${name}`)
})

customEmitter.emit('event2', 'Coutinho', 123)

Considerações:

Eventos são muito utilizados no nodejs e estão disponíveis em muitos componentes, por exemplo no server http, ao invés de utilizar o handler do callback:

const http = require('http');
const server = http.createServer(function(req, res) {
   res.end('Hello World');
});
server.listen(3000)
console.log(`Server running at http://localhost:3000/`);

É possível escutar o evento request, assim:

const http = require('http')
const server = http.createServer()
server.on('request', (req, res) => {
	res.end('Hello World')
})
server.listen(3000)
console.log(`Server running at http://localhost:3000/`);

Para a lista de eventos emitidos por http, consulte: https://nodejs.org/docs/latest-v15.x/api/http.html

Streams

Streams permitem realizar operações de leitura ou escrita em arquivos, comunicação em rede, ou troca de informações em blocos. Por exemplo, ao ler um arquivo, ao invés de carregar o arquivo inteiro na memória, o que irá consumir muita memória, utilizando Streams o processo de leitura será realizado bloco por bloco.

Vantagens de utilizar Streams:

Mais informações sobre Streams (en-US): https://nodejs.dev/learn/nodejs-streams

Abaixo um exemplo de leitura de um arquivo utilizando Streams:

var { createReadStream, createWriteStream } = require('fs')
const path = './temp.txt'

const fileStream = createReadStream(path);
fileStream.on('data', (result) => {
    console.log(result)
})
fileStream.on('error', (err) => {
    console.error(err)
})

Por padrão a leitura é realizada em blocos de 64KB, mas o tamanho do bloco pode ser modificado utilizando o parâmetro “highWaterMark”. Abaixo um exemplo de leitura de arquivo utilizando Streams e o servidor http:

var http = require('http')
var { createReadStream, createWriteStream } = require('fs')

const hostname = "127.0.0.1";
const port = 3000;

http.createServer(function (req, res) {
    if (req.url == '/') {
        home(req, res)
    }
    else if (req.url == '/write') {
        write(req, res);
    }
    else if (req.url == '/read') {
        read(req, res);
    }
})
    .listen(port, hostname, () => {
        console.log(`Server running at http://${hostname}:${port}/`)
    })

function home(req, res) {
    res.write('<a href="/write">write</a><br />')
    res.write('<a href="/read">read</a><br />')
    res.end()
}

function write(req, res) {
    const stream = createWriteStream('./temp.txt', { encoding: 'utf-8', flags: 'a' })
    for (let i = 0; i < 10000; i++) {
        stream.write('012345678901234567890123456789\r\n');
    }
    stream.write(`Arquivo atualizado em: ${Date()}\r\n`);
    res.end('File updated!')
}

function read(req, res) {
    const fileStream = createReadStream('./temp.txt', 'utf-8');
    stream.on('open', () => {
        stream.pipe(res)
    })
    stream.on('error', (err) => {
        res.end(err)
    })
}

Ao analisar a requisição no Chrome Developer Tools é possível notar “Transfer-Encoding: chunked”, ou seja, os dados foram retornados em blocos.

Muitos módulos nativos do Node.js permitem a utilização de Streams, por exemplo:

7- Builtin modules

console

Métodos de console de debug semelhante ao de javascript

Documentação oficial: https://nodejs.org/api/console.html

Exemplo de uso:

//TODO: Complementar

Métodos principais:

//TODO: Complementar

OS

Métodos utilitários relacionados ao sistema operacional

Documentação oficial: https://nodejs.org/api/os.html

Exemplo de uso:

const os = require('os')

console.log(os.platform())
//retorna informações do sistema operacional, no windows por exemplo retorna 'win32'

Métodos principais:

os.EOL
// formato de quebra de linha do sistema (é diferente entre windows e linux), retorna: \n ou \r\n

os.cpus()
// informação sobre as CPUs: model, speed (in MHz), etc.

os.freemem()
//quantidade de memória livre em bytes

os.hostname()
//nome do computador

os.networkInterfaces()
//interfaces de rede

os.platform()
//identificação do sistema operacional, valores possíveis: 'aix', 'darwin', 'freebsd','linux', 'openbsd', 'sunos', 'win32'

os.release()
//versão do sistema operacional
//por exemplo no meu caso estou rodando o Windows 11 OS Build 22000.493 (dá para ver em iniciar / executar / "winver") e esse comando retorna: 10.0.22000

os.tmpdir()
//caminho para a pasta temporária do usuário
//no meu computador retorna: C:\Users\educo\AppData\Local\Temp

os.type()
//retorna o tipo do sistema, ex: 'Linux', 'Darwin' (MacOs), 'Windows_NT'

os.uptime()
//tempo de "uptime" do sistema operacional em segundos, é o tempo que o computador está ligado

os.userInfo([options])
//retorna informações do usuário
//exemplo:
//{
//  uid: -1,
//  gid: -1,
//  username: 'educo',
//  homedir: 'C:\\Users\\educo',
//  shell: null
//}

os.version()
//retorna a versão do kernel do sistema operacional
//por exemplo: Windows 10 Pro

Path Module

Informações de Path (caminho e arquivos)

Documentação oficial: https://nodejs.org/api/path.html

Exemplo de uso:

const path = require('path')
const filePath = path.join('/content', 'subfolder', 'test.txt')

console.log(filePath)
// retorna: \content\subfolder\test.txt

console.log(path.basename(filePath))
// retorna: test.txt

Métodos principais:

//path.basename()
//retorna o nome do arquivo no path

//path.dirname(path)
//retorna o diretório (pasta) do caminho

//path.extname(path)
//retorna a extensão do nome do arquivo

//path.join([...paths])
//concatena caminhos

//path.sep
//barra utiliza para formar um caminho no sistema operacional, windows: '\' e no linux: '/'

FS (file system)

Métodos utilitários para arquivos

Documentação oficial: https://nodejs.org/api/fs.html

Exemplo de uso de forma síncrona:

const fs = require('fs')

//Escrever um arquivo de forma sincrona
const contentWrite = `Arquivo atualizado em: ${Date()}`
fs.writeFileSync('./test.txt', contentWrite)

//Ler um arquivo de forma sincrona
const contentRead = fs.readFileSync('./test.txt', 'utf8')
console.log(contentRead)

Exemplo de uso de forma assíncrona:

const fs = require('fs')

//Escrever um arquivo de forma assíncrona
const contentWrite = `Arquivo atualizado em: ${Date()}`
fs.writeFile('./test.txt', contentWrite, (err, result) => {
	if (err) {
		console.log(err)
		return
	}

	//Ler um arquivo de forma assíncrona
	fs.readFile('./test.txt', 'utf8', (err, result) => {
		if (err) {
			console.log(err)
			return
		}
		console.log(result)
	})
})

Métodos principais:

//TODO: Complementar

HTTP

Implementação de servidor http

Documentação oficial: https://nodejs.org/api/http.html

Exemplo de uso:

//TODO: Complementar

Métodos principais:

//TODO: Complementar

net

Criação de servidor TCP ou IPC

Documentação oficial: https://nodejs.org/api/net.html

Exemplo de uso:

//TODO: Complementar

Métodos principais:

//TODO: Complementar

zlib

Compactação

Documentação oficial: https://nodejs.org/api/zlib.html

Exemplo de uso:

//TODO: Complementar

Métodos principais:

//TODO: Complementar

8- Packages / Libs

Veja no tópico acima como instalar ou remover pacotes.

lodash (facilita a utilização de arrays, objetos, strings, etc)

Referência: https://lodash.com/docs

Para instalar o pacote, execute:

npm install lodash

Exemplo:

const _ = require('lodash')

const items = [1, [2, [3, [4]]]]
const newItems = _.flattenDeep(items)
console.log(newItems) //[ 1, 2, 3, 4 ]

Funções de Array:

_.chunk(array, [size=1])
// Separa um array em blocos com os tamanho especificado
_.chunk(['a', 'b', 'c', 'd'], 2); // => [['a', 'b'], ['c', 'd']]
_.chunk(['a', 'b', 'c', 'd'], 3); // => [['a', 'b', 'c'], ['d']]

_.compact(array)
// Cria um array removendo "falsey values": false, null, 0, "", undefined, and NaN
_.compact([0, 1, false, 2, '', 3]); // => [1, 2, 3]

_.concat(array, [values])
// Concatena os elementos em um array
var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
console.log(other); // => [1, 2, 3, [4]]
 	console.log(array); // => [1]

_.difference(array, [values])
// retorna um array com os valores que não estão incluidos no array do primeiro parâmetro
_.difference([2, 1], [2, 3]); // => [1]

_.differenceBy(array, [values], [iteratee=_.identity])
_.differenceWith(array, [values], [comparator])
_.drop(array, [n=1])
_.dropRight(array, [n=1])
_.dropRightWhile(array, [predicate=_.identity])
_.dropWhile(array, [predicate=_.identity])
_.fill(array, value, [start=0], [end=array.length])
_.findIndex(array, [predicate=_.identity], [fromIndex=0])
_.findLastIndex(array, [predicate=_.identity], [fromIndex=array.length-1])
_.flatten(array)
_.flattenDeep(array)
_.flattenDepth(array, [depth=1])
_.fromPairs(pairs)
_.head(array)
_.indexOf(array, value, [fromIndex=0])
_.initial(array)
_.intersection([arrays])
_.intersectionBy([arrays], [iteratee=_.identity])
_.intersectionWith([arrays], [comparator])
_.join(array, [separator=','])
_.last(array)
_.lastIndexOf(array, value, [fromIndex=array.length-1])
_.nth(array, [n=0])
_.pull(array, [values])
_.pullAll(array, values)
_.pullAllBy(array, values, [iteratee=_.identity])
_.pullAllWith(array, values, [comparator])
_.pullAt(array, [indexes])
_.remove(array, [predicate=_.identity])
_.reverse(array)
_.slice(array, [start=0], [end=array.length])
_.sortedIndex(array, value)
_.sortedIndexBy(array, value, [iteratee=_.identity])
_.sortedIndexOf(array, value)
_.sortedLastIndex(array, value)
_.sortedLastIndexBy(array, value, [iteratee=_.identity])
_.sortedLastIndexOf(array, value)
_.sortedUniq(array)
_.sortedUniqBy(array, [iteratee])
_.tail(array)
_.take(array, [n=1])
_.takeRight(array, [n=1])
_.takeRightWhile(array, [predicate=_.identity])
_.takeWhile(array, [predicate=_.identity])
_.union([arrays])
_.unionBy([arrays], [iteratee=_.identity])
_.unionWith([arrays], [comparator])
_.uniq(array)
_.uniqBy(array, [iteratee=_.identity])
_.uniqWith(array, [comparator])
_.unzip(array)
_.unzipWith(array, [iteratee=_.identity])
_.without(array, [values])
_.xor([arrays])
_.xorBy([arrays], [iteratee=_.identity])
_.xorWith([arrays], [comparator])
_.zip([arrays])
_.zipObject([props=[]], [values=[]])
_.zipObjectDeep([props=[]], [values=[]])
_.zipWith([arrays], [iteratee=_.identity])

Funções de Collection, Date, Function, Lang, Math, Number, Object, Seq, String:

//TODO: Complementar

Comentários