node-handbook (pt-br)

Prévia do material em texto

Machine Translated by Google
Índice
Prefácio
O manual do Node.js
Conclusão
1
Machine Translated by Google
Prefácio
Este livro é escrito por Flávio. Eu publico tutoriais de programação no meu blog 
flaviocopes.com e O Vale do Código.
O Manual do Node.js segue a regra 80/20: aprenda em 20% do tempo os 80% de um 
tópico.
Você pode me encontrar no Twitter @flaviocopes.
Em particular, o objetivo é deixá-lo atualizado rapidamente com o Node.js.
Apreciar!
2
Machine Translated by Google
https://flaviocopes.com/
https://thevalleyofcode.com/
https://twitter.com/flaviocopes
O manual do Node.js
2.0.2. 2010
2.0.11. 2019
2.0.10. 2018
2.0.1. 2009
1. Introdução ao Node.js 
1.1. Node.js tem um grande número de 
bibliotecas 1.2. Um exemplo de aplicativo 
Node.js 1.3. Estruturas e ferramentas do 
Node.js 2. Um breve histórico do Node.js
2.0.9. 2017
8. Como sair de um programa Node.js 9. 
Como ler variáveis de ambiente de Node.js 10. Onde 
hospedar um aplicativo Node.js
2.0.8. 2016
2.0.7. 2015
5. Diferenças entre o Node e o Browser 6. O V8 
JavaScript Engine 6.1. Outros motores JS 6.2. A 
busca pelo desempenho 6.3. Compilação 7. 
Execute scripts Node.js a partir da linha de 
comando 7.1. Reinicie o aplicativo 
automaticamente
3. Como instalar o Node.js 
4. Quanto JavaScript você precisa saber para usar o Node?
2.0.6. 2014
2.0.5. 2013
2.0.14. 2022
2.0.4. 2012
2.0.13. 2021
2.0.12. 2020
2.0.3. 2011
3
Machine Translated by Google
11.1. Use a guia para autocompletar 
11.2. Explorando objetos JavaScript 
11.3. Explorar objetos globais 11.4. A 
variável especial _ 11.5. A tecla de seta para cima 11.6. 
Comandos de ponto
10.1. A opção mais simples de sempre: 
túnel local 10.2. Implantações de configuração zero
11. Como usar o REPL do Node.js
11.7. Execute REPL a partir do arquivo 
JavaScript 12. Node, aceite argumentos da linha de 
comando 13. Saída para a linha de comando usando Node
13.1. Saída básica usando o módulo de console 
13.2. Limpe o console 13.3. Elementos de 
contagem 13.4. Reiniciar a contagem 13,5. 
Imprima o rastreamento de pilha 13.6. Calcule o 
tempo gasto 13,7. stdout e stderr 13.8. Colorir a 
saída 13.9. Crie uma barra de progresso 14. 
Aceite a entrada da linha de comando no Nó 15. 
Uma introdução ao gerenciador de pacotes npm
10.2.1. Falha
10.2.2. Codepen 
10.3. Sem servidor 
10.4. PAAS 10.4.1. Zeit 
Now 10.4.2. 
Nanobox 10.4.3. 
Heroku 10.4.4. 
Microsoft Azure 10.4.5. 
Google Cloud Platform 10.5. 
Servidor Privado Virtual 10.6. Metal 
puro
4
Machine Translated by Google
18.2.1. nome
18.2.12. privado 
18.2.13. roteiros 
18.2.14. dependências 
18.2.15. devDependencies 
18.2.16. motores 18.2.17. lista 
de navegadores 18.2.18. 
Propriedades específicas do comando 18.3. 
Versões do pacote 19. O arquivo package-lock.json 
19.1. Um exemplo 20. Encontre a versão instalada de um 
pacote npm
18.2. Detalhamento de propriedades
18.2.7. licença 
18.2.8. palavras-
chave 18.2.9. descrição 
18.2.10. repositório 
18.2.11. a Principal
17. Como usar ou executar um pacote instalado usando npm 18. O 
guia package.json 18.1. A estrutura do arquivo
18.2.3. contribuintes 
18.2.4. erros 18.2.5. 
página inicial 18.2.6. 
versão
15.1. Introdução ao npm 15.2. 
Downloads 15.2.1. Instalando 
todas as dependências 15.2.2. Instalando 
um único pacote 15.2.3. Atualizando 
pacotes 15.3. Versão 15.4. Executando 
Tarefas 16. Onde o npm instala os pacotes?
18.2.2. autor
5
Machine Translated by Google
28. O loop de eventos do Node.js 
28.1. Introdução
31.1. setTimeout()
32. O emissor de eventos do nó 33. 
Trabalhando com descritores de arquivo no nó 34. 
Estatísticas do arquivo do nó 35. Caminhos do 
arquivo do nó 35.1. Obtendo informações de um 
caminho 35.2. Trabalhando com caminhos
27.1. Execute facilmente comandos locais 
27.2. Execução de comandos sem instalação 27.3. 
Execute algum código usando uma versão diferente do Node.js 27.4. 
Execute snippets de código arbitrários diretamente de um URL
31. Descubra temporizadores JavaScript
23. Versão semântica usando npm 24. 
Desinstalando pacotes npm com npm uninstall 25. npm global 
ou pacotes locais 26. npm dependencies e devDependencies 27. 
O npx Node Package Runner
31.3. Conjunto recursivoTempo limite
30. Entendendo setImmediate()
21. Instale uma versão mais antiga de um pacote npm 22. 
Atualize todas as dependências do Node para sua versão mais recente 22.1. 
Como os pacotes se tornam dependências 22.2. Atualizar todos os 
pacotes para a versão mais recente
31.2. setInterval()
28.2. Bloqueando o loop de eventos 
28.3. A pilha de chamadas 28.4. Uma 
explicação simples do loop de eventos 28.5. 
Execução da função de fila 28.6. A fila de 
mensagens 28.7. ES6 Job Queue 29. Entendendo 
o processo.nextTick()
31.1.1. Atraso zero
6
Machine Translated by Google
40.0.2. path.dirname()
41. O módulo Node os
41.9. os.release() 
40.0.10. path.resolve()
40.0.1. path.basename()
41,8. os.platform()
39. O módulo Node fs 40. 
O módulo Node path
40.0.9. caminho.relativo()
41,7. os.networkInterfaces()
41.6. os.loadavg() 
36. Lendo arquivos com o 
Node 37. Gravando arquivos 
com o Node 37.1. Anexar 
a um arquivo 37.2. Usando 
streams 38. Trabalhando com 
pastas 38.1. Verifique se existe 
uma pasta 38.2. Crie uma nova 
pasta 38.3. Ler o conteúdo de um 
diretório 38.4. Renomeie uma pasta 38.5. 
Remover uma pasta
40.0.8. caminho.parse()
40.0.7. caminho.normalize()
41.5. os.hostname() 
41.4. os.homedir() 
40.0.6. caminho.join()
40.0.5. path.isAbsolute()
41.3. os.freemem() 
41.11. os.totalmem() 
40.0.4. caminho.formato()
41.2. os.cpus()
41.1. os.arch()
40.0.3. caminho.extname()
41.10. os.tmpdir() 
7
Machine Translated by Google
42.10. emissor.prependListener()
43.2.1. http.createServer()
42. O módulo de eventos do nó
42.9. emissor.uma vez()
41.13. os.uptime()
42,7. emissor.off()
43.1.1. http.MÉTODOS
43.3.3. http.Servidor
42,5. emissor.listenerCount()
43.3.1. http.Agente
42.14. emissor.setMaxListeners()
42.4. emissor.getMaxListeners()
42.13. emissor.removeListener()
43.3. Aulas
42.2. emissor.emitir()
43.2.2. http.request()
43.1.3. http.globalAgent 
43.2. Métodos
42.11. emissor.prependOnceListener()
43.3.5. http.IncomingMessage
42,8. emissor.on()
43.1.2. http.STATUS_CODES
43.3.4. http.ServerResponse
41.14. os.userInfo() 
41.12. os.type()
43. O módulo Nó http 43.1. 
Propriedades
42.6. emissor.ouvintes()
43.3.2. http.ClientRequest
42.3. emissor.eventNames()
42.12. emissor.removeAllListeners()
43.2.3. http.get()
44. Streams Node.js
42.1. emissor.addListener()
8
Machine Translated by Google
O Node.js é um ambiente de tempo de execução JavaScript de código aberto e 
multiplataforma. É uma ferramenta popular para quase qualquer tipo de projeto!
44.1. O que são fluxos 
44.2. Por que streams 
44.3. Um exemplo de um fluxo 
44.4. cano()
O Node.js executa o mecanismo JavaScript V8, o núcleo do Google Chrome, fora do 
navegador. Isso permite que o Node.js tenha um alto desempenho.
44,5. APIs Node.js baseadas em streams 
44.6. Diferentes tipos de fluxos 44.7."^7.1.2", 
"babel-core": "^6.22.1", "babel-
eslint": "^8.2.1", "babel-helper-
vue -jsx-merge-props": "^2.0.3", "babel-jest": "^21.0.2", 
"babel-loader": "^7.1.1", "babel-plugin-dynamic-import- 
node": "^1.2.0", "babel-plugin-syntax-jsx": "^6.18.0", 
"babel-plugin-transform-es2015-modules-commonjs": 
"^6.26.0", "babel -plugin-transform-runtime": "^6.22.0", 
"babel-plugin-transform-vue-jsx": "^3.5.0", "babel-preset-env": "^1.3.2", " 
babel-preset-stage-2": "^6.22.0", "chalk": "^2.0.1", "copy-webpack-plugin": 
"^4.0.1", "css-loader": "^ 0.28.0", "eslint": "^4.15.0", "eslint-config-airbnb-
base": "^11.3.0", "eslint-friendly-formatter": "^3.0.0", "eslint -import-
resolver-webpack": "^0.8.3", "eslint-loader": "^1.7.1", "eslint-plugin-
import": "^2.7.0", "eslint-plugin-vue" : "^4.0.0", "extract-text-webpack-
plugin": "^3.0.0", "file-loader": "^1.1.4", "friendly-errors-webpack-plugin": 
"^ 1.6.1", "html-webpack-plugin": "^2.30.1",
{
55
Machine Translated by Google
versão indica a versão atual
}
"ora": "^1.2.0", 
"portfinder": "^1.0.13", 
"postcss-import": "^11.0.0", 
"postcss-loader": "^2.0.8", 
"postcss -url": "^7.2.1", "rimraf": 
"^2.6.0", "semver": "^5.3.0", 
"shelljs": "^0.7.6", "uglifyjs-
webpack-plugin ": "^1.1.1", "url-
loader": "^0.5.8", "vue-jest": "^1.0.2", "vue-
loader": "^13.3.0", "vue -style-loader": 
"^3.0.1", "vue-template-compiler": "^2.5.2", 
"webpack": "^3.6.0", "webpack-bundle-
analyzer": "^2.9 .0", "webpack-dev-server": 
"^2.9.1", "webpack-merge": "^4.1.0" }, 
"engines": { "node": ">= 6.0.0", "npm": ">= 
3.0.0" }, "browserslist": ["> 1%", "últimas 2 
versões", "not ie (https://whatever.com)"
{
"name": "Joe", 
"email": "joe@whatever.com", 
"url": "https://whatever.com"
{
}
{
"colaboradores": [
}
"author": 
{ "name": "Joe", 
"email": "joe@whatever.com", 
"url": "https://whatever.com"
{
}
"contributors": ["Joe (https://whatever.com)"]
]
58
Também pode ser usado com este formato:
Exemplo:
Exemplo:
Também pode ser usado com este formato:
Além do autor, o projeto pode ter um ou mais colaboradores. Esta propriedade é um array 
que os lista.
Machine Translated by Google
{
}
}
{
"homepage": "https://whatever.com/package"
"versão": "1.0.0"
"bugs": "https://github.com/whatever/package/issues"
Indica a versão atual do pacote.
Exemplo:
O primeiro número é a versão principal, o segundo a versão secundária e o terceiro é 
a versão do patch.
Exemplo:
.
Exemplo:
Links para o rastreador de problemas do pacote, provavelmente uma página de problemas do GitHub
Há um significado nesses números: uma versão que corrige apenas bugs é uma 
versão de patch, uma versão que introduz alterações compatíveis com versões 
anteriores é uma versão menor, uma versão principal pode ter alterações importantes.
Esta propriedade segue a notação de versionamento semântico (semver) para versões, 
o que significa que a versão é sempre expressa com 3 números: xxx
Define a página inicial do pacote
59
18.2.5. pagina inicial
18.2.6. versão
18.2.4. insetos
Machine Translated by Google
"description": "Um pacote para trabalhar com strings"
"palavras-chave": 
[ "email", 
"aprendizado de máquina", 
"ai"
"licença": "MIT"
]
Esta propriedade contém uma breve descrição do pacote
Essa propriedade contém uma matriz de palavras-chave que se associam ao que 
seu pacote faz.
Isso é especialmente útil se você decidir publicar seu pacote no npm para que as 
pessoas possam descobrir do que se trata o pacote.
Isso ajuda as pessoas a encontrar seu pacote ao navegar em pacotes semelhantes 
ou ao navegar no https://www.npmjs.com/ local na rede Internet.
Exemplo:
Exemplo:
Indica a licença do pacote.
Exemplo:
60
18.2.7. licença
18.2.10. repositório
18.2.9. Descrição
18.2.8. palavras-chave
Machine Translated by Google
https://www.npmjs.com/
18.2.11. a Principal
"repository": "github:whatever/testing",
"repository": 
{ "type": "svn", 
"url": "..."
"main": "src/main.js"
}
"repository": 
{ "type": "git", 
"url": "https://github.com/whatever/testing.git"
"repository": "gitlab:whatever/testing",
}
"repository": "bitbucket:whatever/testing",
61
Define o ponto de entrada para o pacote.
Quando você importa este pacote em um aplicativo, é onde o aplicativo buscará as exportações 
do módulo.
Esta propriedade especifica onde este repositório de pacotes está localizado.
Você pode usar diferentes sistemas de controle de versão:
Você pode definir explicitamente o sistema de controle de versão:
Exemplo:
Exemplo:
Observe o prefixo do github . Existem outros serviços populares preparados em:
Machine Translated by Google
}
npm run XXXX ou yarn XXXX
npm install 
yarn add 
"scripts": 
{ "dev": "webpack-dev-server --inline --progress --config build/webpack.de "start": "npm 
run dev", "unit": "jest --config test/ unit/jest.conf.js --coverage", "test": "npm run unit", 
"lint": "eslint --ext .js,.vue src test/unit", "build": "node build/ build.js"
"privado": verdadeiro
npm executar dev .
Você pode usar qualquer nome que quiser para um comando, e os scripts podem fazer 
literalmente o que você quiser.
Define um conjunto de scripts de nós que você pode executar
Esses scripts são aplicativos de linha de comando. Você podeexecutá-los chamando 
onde XXXX é o nome do comando. Exemplo:
Exemplo:
Exemplo:
Define uma lista de pacotes npm instalados como dependências.
se definido como true , impede que o aplicativo/pacote seja publicado acidentalmente no npm
,
Quando você instala um pacote usando npm ou yarn:
62
18.2.13. roteiros
18.2.12. privado
18.2.14. dependências
Machine Translated by Google
18.2.15. devDependencies
18.2.16. motores
npm install -D 
yarn add --dev 
}
"dependencies": 
{ "vue": "^2.5.2"
"devDependencies": 
{ "autoprefixer": "^7.1.2", 
"babel-core": "^6.22.1"
}
63
Define uma lista de pacotes npm instalados como dependências de desenvolvimento.
Define quais versões do Node.js e outros comandos funcionam neste pacote/aplicativo
esse pacote é inserido automaticamente nesta lista.
esse pacote é inserido automaticamente nesta lista.
Eles diferem das dependências porque devem ser instalados apenas em uma máquina de 
desenvolvimento, não sendo necessários para executar o código em produção.
sobre
Exemplo:
Exemplo:
Exemplo:
Quando você instala um pacote usando npm ou yarn:
Machine Translated by Google
É usado para informar quais navegadores (e suas versões) você deseja oferecer suporte. 
Ele é referenciado pelo Babel, Autoprefixer e outras ferramentas, para adicionar apenas 
os polyfills e fallbacks necessários aos navegadores que você segmenta.
Esta configuração significa que você deseja suportar as últimas 2 versões principais de 
todos os navegadores com pelo menos 1% de uso (do site CanIUse.com estatísticas), 
exceto IE8 e inferior.
Exemplo:
Cada um tem uma propriedade específica, como 
eslintConfig são específicos do comando, e você pode encontrar como usá-los na 
respectiva documentação do comando/projeto.
O arquivo package.json também pode hospedar configuração específica de comando, por 
exemplo, para Babel, ESLint e muito mais.
,
18.2.17. lista de navegadores
18.2.18. Propriedades específicas do comando
18.3. Versões do pacote
64
"lista de navegadores": [
}
babel e outros. Aqueles
"> 1%", 
"últimas 2 versões", 
"not ie = 6.0.0", 
"npm": ">= 3.0.0", 
"yarn": "^0.13.0"
(ver mais)
Machine Translated by Google
https://caniuse.com/
https://www.npmjs.com/package/browserslist
19. O arquivo package-lock.json
=1.1.0
, você obterá versões de patch e secundárias: 1.13.1 1.14.0 e
cada pacote que é instalado para que um produto seja 100% reprodutível no
lançamento do patch, você tem essas "Regras".
O objetivo do arquivo package-lock.json é acompanhar a versão exata do
número diferente de zero mais à esquerda: 0.13.1 0.13.2 e assim por diante. Se você escrever
Dado que usando semver (versão semântica) todas as versões têm 3 dígitos, o
O que é isso? Você provavelmente conhece o arquivo package.json , que é muito
ok, mas 0.14.0 não é.
minor), usando a notação semver, por exemplo:
essa é a versão exata que será usada, sempre
package.json, você pode definir para quais versões deseja atualizar (patch ou
,
usar?
Você viu na descrição acima números de versão como estes: ~3.0.0
para usar 1.0.0 ou uma versão de 1.1.0 para cima, mas inferior a 1.2.0.
da mesma forma, mesmo que os pacotes sejam atualizados por seus mantenedores.
assim por diante até 2.0.0 mas não 2.0.0 .
sendo o primeiro o lançamento principal, o segundo o lançamento secundário e o terceiro o lançamento
mais comum e existe há muito mais tempo.
se você escrever ̂ 0.13.0 , você deseja obter atualizações que não alteram o
,
,
dependência.
Machine Translated by Google
https://nodejs.dev/learn/semantic-versioning-using-npm/
Se você especificar versões exatas, como 0.13.0 no exemplo, você não será afetado 
por esse problema.
O arquivo package-lock.json precisa ser confirmado no seu repositório Git, para que 
possa ser buscado por outras pessoas, se o projeto for público ou se você tiver 
colaboradores, ou se você usar o Git como fonte para implantações.
Pode ser você ou outra pessoa tentando inicializar o projeto do outro lado do mundo 
executando npm install .
As versões de dependências serão atualizadas no arquivo package-lock.json quando 
você executar npm update .
Portanto, seu projeto original e o projeto recém-iniciado são realmente diferentes. 
Mesmo que um patch ou uma versão menor não introduza mudanças importantes, todos 
nós sabemos que os bugs podem (e assim, eles vão) aparecer.
O package-lock.json define sua versão atualmente instalada de cada pacote em pedra, 
e o npm usará essas versões exatas ao executar o npm ci .
Você não se compromete com o Git sua pasta node_modules, que geralmente é enorme, 
e quando você tenta replicar o projeto em outra máquina usando o comando npm install , 
se você especificou a sintaxe ~ e uma versão de patch de um pacote foi lançada , esse 
vai ser instalado. O mesmo para ̂ e versões menores.
Esta é uma estrutura de exemplo de um arquivo package-lock.json que obtemos quando 
executamos npm install cowsay em uma pasta vazia:
Este conceito não é novo, e outros gerenciadores de pacotes de linguagens de 
programação (como o Composer em PHP) usam um sistema similar há anos.
19.1. Um exemplo
66
Machine Translated by Google
"requires": true, 
"lockfileVersion": 1, 
"dependencies": { "ansi-
regex": { "version": 
"3.0.0", "resolved": 
"https://registry.npmjs.org/ansi -regex/-/ansi-regex-3. 0.0.tgz", "integridade": 
"sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" }, "cowsay": { "version": "1.3.1", "resolved": 
"https: //registry.npmjs.org/cowsay/-/cowsay-1.3.1.tgz"
} }, 
"get-stdin": 
{ "version": "5.0.1", 
"resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-5.0. 1.tgz ", 
"integridade": "sha1-Ei4WFZHiH/TFJTAwVpPyDmOTo5g=" }, "is-fullwidth-code-point": 
{ "version": "2.0.0", "resolved": "https://registry.npmjs. org/is-fullwidth-code-
point/-/
,
is-fullwidth-code-point-2.0.0.tgz", 
"integridade": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=" }, 
"minimista": {
"integridade": "sha512-3PVFe6FePVtPj1HTeLin9v8WyLl+VmM1l1H/5P+BTTDkM
"version": "0.0.10", 
"resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10 .tgz", "integrity": 
"sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8 =" }, "otimista": { "versão": "0.6.1", "resolvido": 
"https://registry.npmjs.org/optimist/-/optimist-0.6.1.tg "integridade": " 
sha1-2j6nRob6IaGaERwybpDrFaAZZoY=",
Ajufp+0F9eLjzRnOHzVAYeIYFF5po5NjRrgefnRMQ==",
{
"requires": 
{ "get-stdin": "^5.0.1", 
"optimist": "~0.6.1", "string-
width": "~2.1.1", "strip-eof": "^ 
1.0.0"
67
Machine Translated by Google
"is-fullwidth-code-point": "^2.0.0", "strip-
ansi": "^4.0.0"
Instalamos o cowsay
"version": "2.1.1", 
"resolved":"https://registry.npmjs.org/string-width/-/string-width- "integrity": "sha512-
nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLN "requer": {
} }, 
"largura da string": {
}
"requires": 
{ "minimist": "~0.0.1", 
"wordwrap": "~0.0.2"
}
}
largura da corda
tira-eof
}, 
"strip-eof": 
{ "version": "1.0.0", 
"resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0. "integridade ": "sha1-
u0P/VZim6wXYm1n80SnJgzE2Br8=" }, "wordwrap": { "version": "0.0.3", "resolved": 
"https://registry.npmjs.org/wordwrap/-/wordwrap-0.0. 3.tg "integridade": "sha1-
o9XabNXAvAAI03I0u68b7WMFkQc="
}
otimista
get-stdin
}, 
"strip-ansi": 
{ "version": "4.0.0", 
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0. "integrity": "sha1-
qEeQIusaw2iocTibY1JixQXuNo8=", "requer": { "ansi-regex": "^3.0.0"
}
que depende de,
68
Machine Translated by Google
20. Encontre a versão instalada de 
um pacote npm
is-fullwidth-code-point
lista npm
do mínimo
ansi-regente
tira-eof
ÿ npm list /
Users/joe/dev/node/cowsay ÿÿÿ 
cowsay@1.3.1 ÿÿÿ get-
stdin@5.0.1 ÿÿÿ optimist@0.6.1 
ÿ ÿÿÿ minimist@0.0.10 ÿ ÿ ÿÿ 
wordwrap@0.0.3 ÿÿÿ string-
width@2.1.1 ÿ ÿÿÿ is-fullwidth-
code-point@2.0.0 ÿ ÿÿÿ strip-
ansi@4.0.0 ÿ ÿÿÿ ansi-regex @3.0.0 ÿÿÿ 
strip-eof@1.0.0
quebra de linha
69
requer propriedade que alguns têm:
Por exemplo:
Por sua vez, esses pacotes requerem outros pacotes, como podemos ver na
Eles são adicionados em ordem alfabética no arquivo e cada um tem um 
campo de versão , um campo resolvido que aponta para o local do pacote 
e uma string de integridade que podemos usar para verificar o pacote.
Para ver a versão de todos os pacotes npm instalados, incluindo suas 
dependências:
Machine Translated by Google
21. Instale uma versão mais antiga 
de um pacote npm
ÿ npm list minimist /
Users/joe/dev/node/cowsay 
ÿÿÿ cowsay@1.3.1 ÿÿÿ 
optimist@0.6.1
1.3.1
ÿ npm list --depth=0 /
Users/joe/dev/node/cowsay 
ÿÿÿ cowsay@1.3.1
ÿ npm list cowsay /
Users/joe/dev/node/cowsay 
ÿÿÿ cowsay@1.3.1
ÿÿÿ minimista@0.0.10
ÿ npm ver versão cowsay
70
npm list -g é o mesmo, mas para pacotes instalados globalmente.
Você pode obter a versão de um pacote específico especificando seu nome:
Para obter apenas seus pacotes de nível superior (basicamente, aqueles que você disse 
ao npm para instalar e listou no package.json ), execute npm list --depth=0 :
Você também pode simplesmente abrir o arquivo package-lock.json , mas isso envolve 
alguma verificação visual.
Isso também funciona para dependências de pacotes que você instalou:
Se você quiser ver qual é a versão mais recente disponível do pacote no repositório 
npm, execute npm view [package_name] version :
Machine Translated by Google
Você também pode estar interessado em listar todas as versões anteriores de um pacote.
Você pode fazer isso com npm view version :
instala a versão 1.3.1 (no momento da escrita).
Exemplo:
Você pode instalar uma versão antiga de um pacote npm usando a sintaxe @ :
O mesmo pode ser feito com pacotes globais:
Instale a versão 1.2.0 com:
npm install @
npm instalar cowsay
npm instala cowsay@1.2.0
npm install -g webpack@4.16.4
71
Machine Translated by Google
72
22.1. Como os pacotes se tornam dependências
22. Atualize todas as 
dependências do Node para sua versão mais recente
Quando você executa o npm, instale o arquivo 
cowsay:
,
uma ferramenta de linha de comando bacana que permite fazer um
O npm determina as dependências e também instala suas versões mais recentes.
,
,
Quando você instala um pacote usando npm install 
a versão é baixada para a pasta node_modules . Uma entrada correspondente 
é adicionada a package.json e package-lock.json na pasta atual.
o mais recente
ÿ npm ver versões de cowsay
esta entrada é adicionada ao package.json
[ '1.0.0', 
'1.0.1', 
'1.0.2', 
'1.0.3', 
'1.1.0', 
'1.1.1', 
'1.1.2', 
'1.1.3', ' 
1.1.4', 
'1.1.5', 
'1.1.6', 
'1.1.7', 
'1.1.8', 
'1.1.9', 
'1.2.0', 
'1.2.1', 
'1.3. 0', 
'1.3.1' ]
Digamos que você instale 
cowsay vaca dizer coisas.
Machine Translated by Google
https://www.npmjs.com/package/cowsay
{
{
"cowsay": "^1.3.1"
"dependências": {
}
}
"requires": true, 
"lockfileVersion": 1, 
"dependencies": 
{ "cowsay": { "version": 
"1.3.1", "resolved": 
"https://registry.npmjs.org/cowsay/- /cowsay-1.3.1.tgz", "integridade": 
"sha512-3PVFe6FePVtPj1HTeLin9v8WyLl+VmM1l1H/5P+BTTDkMAj "requires": { "get-
stdin": "^5.0.1", "optimist": "~0.6. 1", "string-width": "~2.1.1", "strip-eof": "^1.0.0"
}
}
}
}
Agora, esses 2 arquivos nos dizem que instalamos a versão 1.3.1 do cowsay e nossa 
regra de versão do npm para atualizações é ̂ 1.3.1 . Isso significa que o npm pode 
atualizar para patches e versões secundárias: 1.3.21.4.0 e assim por diante.
pacote.json .
a
Desde a versão 5.0.0 do npm, o npm update atualiza o package.json com versões 
secundárias ou de patch mais recentes. Use npm update --no-save para evitar modificações
Para descobrir novos lançamentos de pacotes, use npm disabled .
,
Este é um extrato de package-lock.json (dependências aninhadas foram removidas 
para maior clareza):
Se houver uma nova versão secundária ou de patch e digitarmos npm 
update , a versão instalada será atualizada e o arquivo package-lock.json 
preenchido diligentemente com a nova versão.
,
73
Machine Translated by Google
https://docs.npmjs.com/about-semantic-versioning
22.2. Atualizar todos os pacotes para a versão mais recente
ncu -u
pacote.json
npm install -g npm-check-updates
74
para atualizar todas as dicas de versão em 1. Agora execute npm-check-updates , permitindo a instalação das novas versões 
principais: package.json
Aqui está a lista de alguns pacotes desatualizados em um repositório:
Aproveitando npm-check-updates, você pode atualizar todas as 
dependências para a versão mais recente.
1. Instale o pacote npm-check-updates globalmente:
Algumas dessas atualizações são lançamentos importantes . Executar a atualização do 
npm não ajudará aqui. Os principais lançamentos nunca são atualizados dessa maneira 
porque eles (por definição) introduzem alterações importantes e o npm quer evitar problemas.
Machine Translated by Google
https://www.npmjs.com/package/npm-check-updates
23. Versão semântica usando npm
~
^
npm instalar
75
o primeiro dígito é a versão principal o 
segundo dígito é a versão secundária o 
terceiro dígito é a versão do patch
A convenção é adotada em todas as linguagens de programação, e é muito importante que 
cada pacote npm adere a ela, porque todo o sistema depende disso.
Por que isso é tão importante?
Se há uma grande coisa nos pacotes Node.js, é que todos eles concordaram em usar o Controle 
de Versão Semântica para a numeração de suas versões.
Como o npm define algumas regras que podemos usar no arquivo package.json para escolher 
para quais versões ele pode atualizar nossos pacotes, quando executamos o npm update .
Quando você faz um novo lançamento, você não apenas aumenta um número como quiser, 
mas tem regras:
O conceito de Versionamento Semântico é simples: todas as versões possuem 3 dígitos:
As regras usamestes símbolos:
você atualiza a versão principal quando faz alterações de API incompatíveis você 
atualiza a versão secundária quando adiciona funcionalidade de maneira compatível com 
versões anteriores você atualiza a versão de patch quando faz correções de bugs 
compatíveis com versões anteriores
xyz .
1. Por fim, execute uma instalação padrão:
Machine Translated by Google
76
24. Desinstalando pacotes npm com
,não na versão principal. Se você escrever ̂ 13.1.0 , 
ele pode atualizar para 13.2.0 e não para 14.0.0 
ou superior.
Vamos ver essas regras em detalhes:
lançamentos de patches: 0.13.1 está ok, mas 0.14.0 não.
: Ele só fará atualizações que não alteram o valor diferente de zero mais à esquerda
,
,
Existem outras regras também:
,
número, ou seja, pode haver alterações na versão secundária ou versão de patch, mas
sem símbolo: você aceita apenas a versão específica que você especificar ( 1.2.1 )
npm desinstalar
=
~ : se você escrever ~0.13.0 ao executar o npm update , ele pode atualizar para
Você pode combinar algumas dessas notações, por exemplo, use 1.0.0 || >=1.1.0
>
|| : você combina conjuntos. Exemplo: 2,6
- : você aceita várias versões. Exemplo: 2.1.0 - 2.6.2
13.3.0 até 13.3.1
= : você aceita essa versão exata
||
13.3.2 e assim por diante, mas
= : você aceita qualquer versão igual ou superior à que você especificar
> : você aceita qualquer versão superior à especificada
Machine Translated by Google
25. pacotes globais ou locais npm
dependências
npm desinstalar -g webpack
npm desinstalar 
devDependencies
Dependências opcionais
npm uninstall -g 
instale 
-g 
77
onde depende da sua configuração), independentemente de onde você executa o npm install
da pasta raiz do projeto (a pasta que contém o node_modules
Use a opção --no-save se não quiser atualizar o package.json e
arquivos package-lock.json .
e você pode executar este comando de qualquer lugar que desejar em seu sistema
pacotes globais são todos colocados em um único lugar em seu sistema (exatamente
install ), execute
arquivos package-lock.json .
sob este diretório
Para desinstalar um pacote que você instalou anteriormente localmente (usando npm
por exemplo:
e peerDependencies em package.json e
,
,
,
e eles são colocados na pasta node_modules
,
os pacotes locais são instalados no diretório em que você executa o npm
bandeira:
A principal diferença entre pacotes locais e globais é esta:
pasta). Isso irá atualizar
Se o pacote estiver instalado globalmente, você precisa adicionar o -g / --global
porque, para pacotes globais, o diretório atual não importa.
Machine Translated by Google
A atualização de um pacote global faria com que todos os seus projetos usassem a 
nova versão e, como você pode imaginar, isso pode causar pesadelos em termos de 
manutenção, pois alguns pacotes podem quebrar a compatibilidade com outras 
dependências e assim por diante.
então quando você deve instalar de uma forma ou de outra?
Todos os projetos têm sua própria versão local de um pacote, mesmo que isso possa 
parecer um desperdício de recursos, é mínimo em comparação com as possíveis 
consequências negativas.
Um pacote deve ser instalado globalmente quando fornece um comando executável 
que você executa a partir do shell (CLI) e é reutilizado nos projetos.
Em geral, todos os pacotes devem ser instalados localmente.
Você também pode instalar comandos executáveis localmente e executá-los usando 
npx, mas alguns pacotes são apenas melhor instalados globalmente.
Isso garante que você possa ter dezenas de aplicativos em seu computador, todos 
executando uma versão diferente de cada pacote, se necessário.
No seu código, você só pode exigir pacotes locais:
Grandes exemplos de pacotes globais populares que você pode conhecer são
react-native-cli
npm
mocha
nómon
para todo sempre
grunt-cli
view-cli
gatsby-cli
require('nome do pacote')
78
Machine Translated by Google
27. O npx Node Package Runner
26. dependências do npm e 
devDependencies
npm lista -g --profundidade 0
79
Quando você instala um pacote npm usando npm install está 
instalando-o como uma dependência.
Quando você entra em produção, se você digitar npm install e a pasta contiver um 
arquivo package.json , eles serão instalados, pois o npm assume que esta é uma 
implantação de desenvolvimento.
Você provavelmente já tem alguns pacotes instalados globalmente em seu sistema.
As dependências de desenvolvimento destinam-se a pacotes somente de 
desenvolvimento, que são desnecessários na produção. Por exemplo, pacotes de teste, 
webpack ou Babel.
versão 5.2, lançada em julho de 2017.
npx é um comando muito poderoso que está disponível no npm começando
Ao adicionar o sinalizador -D ou --save-dev , você o está instalando como uma 
dependência de desenvolvimento, que o adiciona à lista devDependencies .
na sua linha de comando.
Você precisa definir o sinalizador --production ( npm install --production ) para evitar a 
instalação dessas dependências de desenvolvimento.
O pacote é listado automaticamente no arquivo package.json, na lista de dependências 
(a partir do npm 5. anteriormente, você tinha que especificar manualmente -- save ).
, você
Você pode vê-los executando
Machine Translated by Google
A execução de npx commandname encontra automaticamente a referência correta 
do comando dentro da pasta node_modules de um projeto, sem precisar saber o 
caminho exato e sem exigir que o pacote seja instalado globalmente e no caminho 
do usuário.
Isso é bastante útil, principalmente porque:
Se você não quiser instalar o npm, poderá instalar o npx como um pacote 
autônomo
,
Isso foi uma dor porque você não poderia realmente instalar versões diferentes do 
mesmo comando.
Uma demonstração típica do uso do npx é através do comando cowsay . cowsay 
imprimirá uma vaca dizendo o que você escreveu no comando. Por exemplo:
cowsay "Olá" será impresso
que está permitindo executar comandos
Os desenvolvedores do Node.js costumavam publicar a maioria dos comandos 
executáveis como pacotes globais, para que eles estivessem no caminho e fossem 
executáveis imediatamente.
1. você não precisa instalar nada 2. 
você pode executar diferentes versões do mesmo comando, usando a sintaxe
Há outro ótimo recurso do npx sem 
primeiro instalá-los.
@versão
O npx permite executar código criado com Node.js e publicado por meio do 
registro npm.
27.1. Execute facilmente comandos locais
27.2. Execução de comandos sem instalação
80
Machine Translated by Google
https://www.npmjs.com/package/npx
https://www.npmjs.com/package/npx
27.3. Execute algum código usando uma versãodiferente do Node.js
Agora, este é um comando inútil engraçado. Outros cenários incluem:
e muitos mais.
Isso só funciona se você tiver o comando cowsay instalado globalmente do 
npm anteriormente. Caso contrário, você receberá um erro ao tentar executar 
o comando.
vai fazer o trabalho.
81
npx permite que você execute esse comando npm sem instalá-lo primeiro. Se o comando não 
for encontrado, o npx o instalará em um cache central:
@vue/cli cria meu-vue-app
executando a ferramenta vue CLI para criar novos aplicativos e executá-los: npx
_______
Use o @ para especificar a versão e combine isso com o pacote node npm :
npx node@10 -v #v10.18.1 npx 
node@12 -v #v12.14.1
\ ̂ __^ \ 
(oo)\_______ (__)\ )
\/\ ||----w | || ||
criando um novo aplicativo React usando create-react-app : npx create-react-app
meu-reagir-aplicativo
npx cowsay "Olá"
-------
Machine Translated by Google
https://www.npmjs.com/package/node
https://www.npmjs.com/package/node
https://www.npmjs.com/package/node
https://www.npmjs.com/package/node
https://www.npmjs.com/package/node
82
28.1. Introdução
27.4. Execute snippets de código arbitrários 
diretamente de um URL
npx https://gist.github.com/zkat/4bc19503fe9e9309e2bfaa2c58074d32
28. O loop de eventos do Node.js
Claro, você precisa ter cuidado ao executar o código que você não controla, pois com grandes 
poderes vêm grandes responsabilidades.
Por que isso é tão importante? Porque explica como o Node.js pode ser assíncrono e ter E/S 
sem bloqueio, e explica basicamente o "recurso matador" do Node.js, o que o tornou tão bem-
sucedido.
Isso ajuda a evitar ferramentas como nvm ou outras ferramentas de gerenciamento de versão 
do Node.js.
O Event Loop é um dos aspectos mais importantes a serem entendidos sobre o Node.js.
Você pode executar o código que fica em um gist do GitHub, por exemplo:
Esta é uma limitação que é realmente muito útil, pois simplifica muito como você programa sem 
se preocupar com problemas de simultaneidade.
Você só precisa prestar atenção em como escreve seu código e evitar qualquer coisa que possa 
bloquear o encadeamento, como chamadas de rede síncronas ou loops infinitos.
npx não limita você aos pacotes publicados no registro npm.
O código JavaScript do Node.js é executado em um único encadeamento. Há apenas uma coisa 
acontecendo de cada vez.
Machine Translated by Google
Quase todas as primitivas de E/S em JavaScript não são bloqueantes. Solicitações de rede, 
operações do sistema de arquivos e assim por diante. O bloqueio é a exceção, e é por isso que 
o JavaScript é baseado tanto em retornos de chamada e, mais recentemente, em promessas e 
async/await.
cada um em ordem.
Em geral, na maioria dos navegadores existe um event loop para cada guia do navegador, para 
tornar cada processo isolado e evitar uma página web com loops infinitos ou processamento 
pesado para bloquear todo o seu navegador.
Ao fazer isso, ele adiciona qualquer chamada de função que encontrar na pilha de chamadas e executa
Qualquer código JavaScript que demore muito para retornar o controle ao loop de eventos 
bloqueará a execução de qualquer código JavaScript na página, até mesmo bloqueará o thread 
da interface do usuário, e o usuário não poderá clicar, rolar a página e assim por diante.
O loop de eventos verifica continuamente a pilha de chamadas para ver se há alguma função 
que precisa ser executada.
Você conhece o rastreamento de pilha de erros com o qual pode estar familiarizado, no depurador 
ou no console do navegador? O navegador procura os nomes das funções na pilha de chamadas 
para informar qual função origina a chamada atual:
A pilha de chamadas é uma pilha LIFO (Last In, First Out).
Você precisa se preocupar principalmente que seu código será executado em um único loop de 
evento e escrever código com isso em mente para evitar bloqueá-lo.
O ambiente gerencia vários loops de eventos simultâneos, para lidar com chamadas de API, por 
exemplo. Os Web Workers também são executados em seu próprio loop de eventos.
28.2. Bloqueando o loop de eventos
28.3. A pilha de chamadas
83
Machine Translated by Google
28.4. Uma explicação simples do loop de eventos
Vamos escolher um exemplo:
84
Machine Translated by Google
bar()
}
bar
foo()
const bar = () => console.log('bar')
const foo = () => {
base
const baz = () => console.log('baz')
console.log('foo') bar() 
baz()
foo
Quando este código é executado, primeiro foo() é chamado. Dentro de foo() nós primeiro chamamos
Neste ponto, a pilha de chamadas se parece com isso:
, então chamamos baz() .
como esperado.
Este código imprime
85
Machine Translated by Google
O loop de eventos em cada iteração verifica se há algo na pilha de 
chamadas e o executa:
86
Machine Translated by Google
O exemplo acima parece normal, não há nada de especial nele: JavaScript encontra coisas para executar, 
executa-as em ordem.
até que a pilha de chamadas esteja vazia.
28,5. Execução da função de fila
87
Machine Translated by Google
Tome este exemplo:
Vamos ver como adiar uma função até que a pilha esteja limpa.
Este código imprime, talvez surpreendentemente:
Quando este código é executado, primeiro foo() é chamado. Dentro de foo(), primeiro chamamos 
setTimeout, passando bar como argumento, e o instruímos a executar imediatamente o mais 
rápido possível, passando 0 como o cronômetro. Então chamamos baz().
O caso de uso de setTimeout(() => {}, 0) é chamar uma função, mas executá-la assim que todas 
as outras funções no código forem executadas.
Neste ponto, a pilha de chamadas se parece com isso:
foo()
const bar = () => console.log('bar')
base
}
console.log('foo') 
setTimeout(bar, 0) baz()
bar
foo
const foo = () => {
const baz = () => console.log('baz')
88
Machine Translated by Google
Aqui está a ordem de execução para todas as funções em nosso programa:
89
Machine Translated by Google
Por que isso está acontecendo?
28.6. A fila de mensagens
90
Machine Translated by Google
Semelhante a um passeio de montanha-russa em um parque de diversões: a fila de 
mensagens coloca você no final da fila, atrás de todas as outras pessoas, onde você terá 
que esperar sua vez, enquanto a fila de trabalhos é o ticket fastpass que permite que 
você pegue outro passeio logo após terminar o anterior.
O loop dá prioridade à pilha de chamadas e primeiro processa tudo o que encontra na 
pilha de chamadas e, uma vez que não há nada lá, ele pega coisas na fila de mensagens.
A fila de mensagens também é onde os eventos iniciados pelo usuário, como eventos de 
clique ou teclado, ou busca de respostas, são enfileirados antes que seu código tenha a 
oportunidade de reagir a eles. Ou também eventos DOM como onload .
Exemplo:
Não precisamos esperar por funções como setTimeout
ECMAScript 2015 introduziu o conceito de Job Queue, que é usado por Promises 
(também introduzido no ES6/ES2015). É uma maneira de executar o resultado de uma 
função assíncrona o mais rápido possível, em vez de sercolocado no final da pilha de 
chamadas.
fetch ou outras coisas para 
fazer seu próprio trabalho, porque eles são fornecidos pelo navegador e vivem em seus 
próprios threads. Por exemplo, se você definir o tempo limite setTimeout para 2 segundos, 
não precisará esperar 2 segundos - a espera acontece em outro lugar.
Promessas que são resolvidas antes do término da função atual serão executadas logo 
após a função atual.
,
Quando setTimeout() é chamado, o Browser ou Node.js inicia o cronômetro. Uma vez 
que o temporizador expira, neste caso imediatamente quando colocamos 0 como o 
tempo limite, a função de retorno de chamada é colocada na Fila de Mensagens.
28.7. Fila de Trabalho ES6
91
Machine Translated by Google
}
const foo = () => {
const baz = () => console.log('baz')
foo
base
console.log('foo') 
setTimeout(bar, 0) new 
Promise((resolver, rejeitar) =>
deve ser logo depois do baz, antes do bar bar
foo()
resolve('deveria estar logo depois do baz, antes do bar')
).then((resolver) => console.log(resolver)) baz()
const bar = () => console.log('bar')
Isso imprime
Finalmente, aqui está a aparência da pilha de chamadas para o exemplo acima:
Essa é uma grande diferença entre Promises (e Async/await, que é construído em 
promessas) e funções assíncronas simples por meio de setTimeout() ou outras APIs 
de plataforma.
92
Machine Translated by Google
Machine Translated by Google
,
process.nextTick() .
Ao tentar entender o loop de eventos do Node.js, uma parte importante dele é
Chamar setTimeout(() => {}, 0) executará a função no final do próximo tick, muito mais 
tarde do que ao usar nextTick() , que prioriza a chamada e a executa logo antes do 
início do próximo tick.
Toda vez que o loop de eventos faz uma viagem completa, chamamos de tick.
Use nextTick() quando quiser ter certeza de que na próxima iteração do loop de eventos 
esse código já foi executado.
O loop de eventos está ocupado processando o código de função atual.
Quando passamos uma função para process.nextTick() , instruímos o mecanismo a 
invocar essa função no final da operação atual, antes que o próximo ciclo de evento 
comece:
Quando você deseja executar algum código de forma assíncrona, mas o mais rápido 
possível, uma opção é usar a função setImmediate() fornecida pelo Node.js:
Quando essa operação termina, o mecanismo JS executa todas as funções passadas 
para as chamadas nextTick durante essa operação.
É a maneira como podemos dizer ao mecanismo JS para processar uma função de 
forma assíncrona (após a função atual), mas o mais rápido possível, não a enfileirar.
process.nextTick(() => { // 
faça algo })
29. Entendendo o 
processo.nextTick()
30. Entendendo setImmediate()
94
Machine Translated by Google
process.nextTick() e Promise.then() :
})
// executa algo
promete fila de microtarefas
setTimeout O retorno de chamada setImmediate é adicionado à fila de macrotarefas .
O retorno de chamada Promise.then() é adicionado à fila de microtarefas de promessas .
Aqui está um exemplo para mostrar a ordem entre setImmediate()
setImediato(() => {
e, em seguida, executa a fila de macrotarefas .
Qualquer função passada como o argumento setImmediate() é um callback que é
A ordem de execução dependerá de vários fatores, mas ambos serão executados
na próxima iteração do loop de eventos.
Um retorno de chamada setTimeout() com um atraso de 0ms é muito semelhante a setImmediate() .
significa que ele sempre será executado antes de setTimeout e setImmediate .
O loop de eventos executa as tarefas na fila process.nextTick primeiro e depois executa
,
iteração atual do loop de eventos, após o término da operação atual. este
UMA
,
Uma função passada para process.nextTick() será executada no
0ms tempo limite), e de process.nextTick() e Promise.then() ?
UMA
Como setImmediate() é diferente de setTimeout(() => {}, 0) (passando um
executado na próxima iteração do loop de eventos.
Um retorno de chamada process.nextTick é adicionado à fila process.nextTick .
,
95
Machine Translated by Google
Ao escrever código JavaScript, você pode querer atrasar a execução de um
,
,
Este é o trabalho de setTimeout . Você especifica uma função de retorno de chamada para executar 
mais tarde e um valor que expressa quanto tempo depois você deseja que ela seja executada, em milissegundos:
função.
então chame foo() em process.nextTick 
que imprime 
bar e adiciona zoo() na fila process.nextTick ao mesmo tempo. Em 
seguida, ele chamará zoo() que acabou de ser adicionado. No final, o 
baz() na fila de macrotarefas é chamado.
31. Descubra temporizadores JavaScript
96
const baz = () => console.log('baz') const 
foo = () => console.log('foo') const zoo = 
() => console.log('zoo') const start = () => 
{
} começar()
Este código irá primeiro chamar start()
console.log('start') 
setImmediate(baz) new 
Promise((resolver, rejeitar) => 
{ resolve('bar') }).then((resolver) => 
{ console.log(resolve) 
process.nextTick( zoo) }) 
process.nextTick(foo)
// inicia foo bar zoo baz
fila . Depois disso, ele lidará com a fila de microtarefas de promessas
31.1. setTimeout()
Machine Translated by Google
Se você especificar o atraso de tempo 
limite para 0 o mais rápido possível, mas após a execução da função atual:
,
Essa sintaxe define uma nova função. Você pode chamar qualquer outra função que 
desejar, ou pode passar um nome de função existente e um conjunto de parâmetros:
a função de retorno de chamada será executada
31.1.1. Atraso zero
// executa após 2 segundos
setTimeout(() => { // 
executa após 2 segundos }, 
2000)
const id = setTimeout(() => {
}
setTimeout retorna o ID do temporizador. Isso geralmente não é usado, mas você pode armazenar esse 
id e limpá-lo se quiser excluir esta execução de função agendada:
// deve ser executado após 2 
segundos }, 2000)
const myFunction = (firstParam, secondParam) => { // faça algo
setTimeout(myFunction, 2000, firstParam, secondParam)
// Mudei de ideia 
clearTimeout(id)
setTimeout(() => { // 
executa após 50 milissegundos
}, 50)
97
Machine Translated by Google
Alguns navegadores (IE e Edge) implementam um método setImmediate() que faz 
exatamente a mesma funcionalidade, mas não é padrão e não está disponível em 
outros navegadores. Mas é uma função padrão no Node.js.
com uma diferença: em vez
Isso é especialmente útil para evitar o bloqueio da CPU em tarefas intensivas e permitir 
que outras funções sejam executadas durante a execução de um cálculo pesado, 
enfileirando funções no escalonador.
, passando o ID do intervalo que setInterval retornou:
A função acima é executada a cada 2 segundos, a menos que você diga para parar, usando
de executar a função de retorno de chamada uma vez, ela a executará para sempre, no intervalo 
de tempo específico que você especificar (em milissegundos):
,
Este código será impresso
31.2. setInterval()
setTimeout(() => 
{ console.log('depois ') }, 0)
depois
setInterval é uma função semelhante a setTimeout
console.log(' antes ')
antes da
setInterval(()=> { // executa 
a cada 2 segundos }, 2000)
clearInterval
98
Machine Translated by Google
https://caniuse.com/#feat=setimmediate
https://caniuse.com/#feat=setimmediate
É comum chamar clearInterval dentro da função de retorno de chamada setInterval, para 
permitir que ela determine automaticamente se deve ser executada novamente ou parar. 
Por exemplo, este código executa algo, a menos que App.somethingIWait tenha o valor chegado :
consideração sobre quando uma função terminou sua execução.
Talvez a função leve tempos de execução diferentes, dependendo das condições da rede, 
por exemplo:
Se uma função sempre leva a mesma quantidade de tempo, está tudo bem:
E talvez uma longa execução se sobreponha à próxima:
inicia uma função a cada n milissegundos, sem nenhum
31.3. Conjunto recursivoTempo limite
const id = setInterval(() => { // executa 
a cada 2 segundos }, 2000)
if (App.somethingIWait === 'chegou') 
{ clearInterval(interval)
setInterval
clearInterval(id)
const intervalo = setInterval(() => {
} // caso contrário faça as 
coisas }, 100)
99
Machine Translated by Google
setTimeout(minhaFunção, 1000)
setTimeout(minhaFunção, 1000)
const minhaFunção = () => { // 
faça algo
}
No backend, o Node.js nos oferece a opção de construir um sistema semelhante usando o 
módulo de eventos .
32. O emissor do evento do nó
, usado principalmente para trabalhar com o loop de eventos do Node.js. setTimeout(() => {}, 0)
para alcançar este cenário:
que é equivalente a usar
Para evitar isso, você pode agendar um setTimeout recursivo para ser chamado quando a 
função de retorno de chamada terminar:
Se você trabalhou com JavaScript no navegador, sabe quanto da interação do 
usuário é tratada por meio de eventos: cliques do mouse, pressionamentos de 
botões do teclado, reação aos movimentos do mouse e assim por diante.
Node.js também fornece setImmediate()
módulo.
,
setTimeout e setInterval estão disponíveis no Node.js, por meio dos Timers
100
Machine Translated by Google
https://nodejs.org/api/events.html
https://nodejs.org/api/events.html
https://nodejs.org/api/timers.html
https://nodejs.org/api/timers.html
https://nodejs.org/api/timers.html
https://nodejs.org/api/timers.html
https://nodejs.org/api/timers.html
Você inicializa isso usando
emitéusado para acionar um evento 
on é usado para adicionar uma função de retorno de chamada que será executada 
quando o evento for acionado
a função do manipulador de eventos é acionada e obtemos o log do console.
Este módulo, em particular, oferece a classe EventEmitter , que usaremos para lidar 
com nossos eventos.
Este objeto expõe, entre muitos outros, os métodos on e emit .
Quando nós corremos
argumentos para emitir() :
Você pode passar argumentos para o manipulador de eventos passando-os como adicionais
Por exemplo, vamos criar um evento start e, para fornecer uma amostra, reagimos a 
isso apenas logando no console:
Vários argumentos:
const eventEmitter = new EventEmitter()
eventEmitter.emit('start', 23)
const EventEmitter = require('eventos')
eventEmitter.emit('start')
eventEmitter.on('start', () => 
{ console.log('started') })
eventEmitter.on('start', (number) => 
{ console.log(`started ${number}`) })
101
Machine Translated by Google
O objeto EventEmitter também expõe vários outros métodos para interagir com eventos, como
Antes de poder interagir com um arquivo que está em seu sistema de arquivos, você deve obter 
um descritor de arquivo.
Outros sinalizadores que você costuma usar são:
Observe o r que usamos como o segundo parâmetro para a chamada fs.open() .
Um descritor de arquivo é uma referência a um arquivo aberto, um número (fd) retornado pela 
abertura do arquivo usando o método open() oferecido pelo módulo fs . Este número ( fd ) identifica 
exclusivamente um arquivo aberto no sistema operacional:
Esse sinalizador significa que abrimos o arquivo para leitura.
33. Trabalhando com descritores de arquivo 
no Node
console.log(`começou de ${start} a ${end}`) })
const fs = require('fs')
removeListener() / off() : remove um ouvinte de evento de um evento 
removeAllListeners() : remove todos os ouvintes de um evento
eventEmitter.on('start', (start, end) => {
once() : adiciona um ouvinte único
// fd é nosso descritor de arquivo })
fs.open('/Users/joe/test.txt', 'r', (err, fd) => {
eventEmitter.emit('start', 1, 100)
Você pode ler todos os detalhes na página do módulo de eventos em https://nodejs.org/api/
events.html
102
Machine Translated by Google
https://nodejs.org/api/events.html
w+ abre o arquivo para leitura e escrita, posicionando o stream na
a abra o arquivo para escrita, posicionando o stream no final do arquivo.
const fs = require('fs')
}
r+ abre o arquivo para leitura e escrita, se o arquivo não existir ele não será criado.
try 
{ const fd = fs.openSync('/Users/joe/test.txt', 'r') } catch (err) 
{ console.error(err)
Você também pode abrir o arquivo usando o método fsPromises.open baseado em 
promessa oferecido pelo módulo fs/promises .
métodos.
O arquivo é criado se não existir. 
a+ abre o arquivo para leitura e escrita, posicionando o stream no final do 
arquivo. O arquivo é criado se não existir.
início do arquivo. O arquivo é criado se não existir.
Depois de obter o descritor de arquivo, da maneira que você escolher, você pode 
executar todas as operações que o requerem, como chamar fs.close() e muitas 
outras operações que interagem com o sistema de arquivos.
O módulo fs/promises está disponível apenas a partir do Node.js v14. Antes da v14, 
depois da v10, você pode usar require('fs').promises . Antes da v10, após a v8, você 
pode usar util.promisify para converter métodos fs em métodos baseados em promessa
Você também pode abrir o arquivo usando o método fs.openSync , que retorna o 
descritor do arquivo, em vez de fornecê-lo em um retorno de chamada:
103
Machine Translated by Google
API.
Cada arquivo vem com um conjunto de detalhes que podemos inspecionar usando o Node.js.
Você o chama passando um caminho de arquivo e, assim que o Node.js obtiver os detalhes do arquivo, 
ele chamará a função de retorno de chamada que você passar, com 2 parâmetros: uma mensagem de 
erro e as estatísticas do arquivo:
Em particular, usando o método stat() fornecido pelo módulo fs .
Aqui está um exemplo de util.promisify :
34. Estatísticas do arquivo do nó
} exemplo()
exemplo de função assíncrona () 
{ const open = util.promisify(fs.open) const 
fd = await open('/Users/joe/test.txt', 'r')
} exemplo()
const fs = require('fs/promessas')
Para ver mais detalhes sobre o módulo fs/promises , verifique fs/promises
const fs = require('fs') const 
util = require('util')
try 
{ filehandle = await fs.open('/Users/joe/test.txt', 'r') 
console.log(filehandle.fd) console.log(await 
filehandle.readFile({ encoding: 'utf8' })) } finalmente { await filehandle.close()
// Ou const fs = require('fs').promises antes da v14. exemplo de 
função assíncrona () { let filehandle
}
104
Machine Translated by Google
https://nodejs.org/docs/latest-v17.x/api/fs.html#promises-api
https://nodejs.org/docs/latest-v17.x/api/fs.html#promises-apihttps://nodejs.org/docs/latest-v17.x/api/fs.html#promises-api
https://nodejs.org/docs/latest-v17.x/api/fs.html#promises-api
})
try 
{ const stats = fs.statSync('/Users/joe/test.txt') } catch (err) 
{ console.error(err)
stats.isDirectory()
}
const fs = require('fs')
const fs = require('fs')
console.error(err)
fs.stat('/Users/joe/test.txt', (err, stats) => { if (err) {
} // temos acesso ao arquivo stats em ̀stats`
As informações do arquivo são incluídas na variável stats. Que tipo de
Muito, incluindo:
Existem outros métodos avançados, mas a maior parte do que você usará em sua programação 
do dia-a-dia é isso.
informações que podemos extrair usando as estatísticas?
se o arquivo for um diretório ou um arquivo, usando stats.isFile() e
O Node.js também fornece um método de sincronização, que bloqueia o encadeamento até que as estatísticas 
do arquivo estejam prontas:
se o arquivo for um link simbólico usando stats.isSymbolicLink() o 
tamanho do arquivo em bytes usando stats.size .
105
Machine Translated by Google
Você também pode usar o método fsPromises.stat() baseado em promessa oferecido pelo
Cada arquivo no sistema tem um caminho.
No Linux e no macOS, um caminho pode ter a seguinte aparência:
35. Caminhos de arquivos de nós
console.log(err)
Retorna
} pegar (errar) {
console.error(err)
fs.stat('/Users/joe/test.txt', (err, stats) => { if (err) {
async function example() { try 
{ const stats = await fs.stat('/
Users/joe/test.txt') stats.isFile() // true stats.isDirectory() // false 
stats.isSymbolicLink() // false stats.size // 1024000 //= 1 MB
/users/joe/arquivo.txt
const fs = require('fs')
const fs = require('fs/promessas')
fs/promises se você quiser:
})
stats.isFile() // true 
stats.isDirectory() // false 
stats.isSymbolicLink() // false stats.size // 
1024000 //= 1 MB
} exemplo()
}
}
106
Machine Translated by Google
path.basename(notes, path.extname(notes)) // notas
const notas = '/users/joe/notes.txt'
path.dirname(notes) // /users/joe 
path.basename(notes) // notes.txt 
path.extname(notes) // .txt
const caminho = require('caminho')
C:\users\joe\arquivo.txt
35.1. Obtendo informações de um caminho
35.2. Trabalhando com caminhos
argumento para basename :
Exemplo:
Você precisa prestar atenção ao usar caminhos em seus aplicativos, pois isso
e você pode começar a usar seus métodos.
diferença deve ser levada em consideração.
Dado um caminho, você pode extrair informações dele usando esses métodos:
Você pode unir duas ou mais partes de um caminho usando path.join() :
Você pode obter o nome do arquivo sem a extensão especificando um segundo
Você inclui este módulo em seus arquivos usando
enquanto os computadores Windows são diferentes e possuem uma estrutura como:
dirname : obtém a pasta pai de um arquivo 
basename : obtém a parte do nome do arquivo 
extname : obtém a extensão do arquivo
107
Machine Translated by Google
A maneira mais simples de ler um arquivo em Node.js é usar o método 
fs.readFile() , passando o caminho do arquivo, a codificação e uma função de 
callback que será chamada com os dados do arquivo (e o erro):
Você pode obter o cálculo do caminho absoluto de um caminho relativo usando
,
Nesse caso, o Node.js simplesmente anexará /joe.txt ao diretório de trabalho 
atual. Se você especificar uma segunda pasta de parâmetros, o resolve usará a 
primeira como base para a segunda:
Se o primeiro parâmetro começar com uma barra, isso significa que é um caminho absoluto:
caminho real, quando contém especificadores relativos como . 
ou .. barras:
Nem resolver nem normalizar verificarão se o caminho existe. Eles apenas 
calculam um caminho com base nas informações que obtiveram.
36. Lendo arquivos com o Node
path.resolve('/etc', 'joe.txt') // '/etc/joe.txt'
const name = 'joe' 
path.join('/', 'users', name, 'notes.txt') // '/users/joe/notes.txt'
path.resolve('joe.txt') // '/Users/joe/joe.txt' se executado da minha pasta pessoal
path.resolve('tmp', 'joe.txt') // '/Users/joe/tmp/joe.txt' se executado a partir do meu
path.normalize() é outra função útil, que tentará calcular o ou double
path.normalize('/users/joe/..//test.txt') // '/users/test.txt'
path.resolve() :
108
Machine Translated by Google
console.error(err)
função assíncrona example() { try 
{ const data = await fs.readFile('/
Users/joe/test.txt', { encoding: 'utf console.log(data) } catch (err) {
const fs = require('fs/promessas')
se (erro) {
fs.readFile('/Users/joe/test.txt', 'utf8', (err, data) => {
fs.readFileSync() e fsPromises.readFile()
const fs = require('fs')
}
try 
{ const data = fs.readFileSync('/Users/joe/test.txt', 'utf8') console.log(data) } 
catch (err) { console.error(err)
Todos os três de fs.readFile()
const fs = require('fs')
} exemplo()
} console.log(dados) })
}
console.log(err)
Retorna
Como alternativa, você pode usar a versão síncrona fs.readFileSync() :
leia todo o conteúdo do arquivo na memória antes de retornar os dados.
Você também pode usar o método fsPromises.readFile() baseado em promessa 
oferecido pelo módulo fs/promises :
,
109
Machine Translated by Google
37. Gravando arquivos com Node
const content = 'Algum conteúdo!'
fs.writeFile('/Users/joe/test.txt', content, (err) => {
const fs = require('fs')
const content = 'Algum conteúdo!'
}
const fs = require('fs')
} catch (err) 
{ console.error(err)
} // arquivo escrito com sucesso })
try 
{ fs.writeFileSync('/Users/joe/test.txt', content) // arquivo escrito com 
sucesso
if (err) 
{ console.error(err)
Isso significa que arquivos grandes terão um grande impacto no consumo de 
memória e na velocidade de execução do programa.
Exemplo:
Nesse caso, a melhor opção é ler o conteúdo do arquivo usando fluxos.
A maneira mais fácil de gravar em arquivos no Node.js é usar a API fs.writeFile() .
Como alternativa, você pode usar a versão síncrona fs.writeFileSync() :
Você também pode usar o método fsPromises.writeFile() baseado em promessa 
oferecido pelo módulo fs/promises :
110
Machine Translated by Google
no
Um método útil para anexar conteúdo ao final de um arquivo é fs.appendFile() (e sua contraparte 
fs.appendFileSync() ):
bandeiras
Os sinalizadores que você provavelmente usará são
O arquivo é criado se não existir
maisachar
Você pode modificar o padrão especificando um sinalizador:
início do arquivo. O arquivo é criado se não existir
posso
Por padrão, esta API substituirá o conteúdo do arquivo se ele já existir.
final do arquivo. O arquivo é criado se não existir
37.1. Anexar a um arquivo
console.log(err)
a abra o arquivo para escrita, posicionando o stream no final do arquivo.
(você 
https://nodejs.org/api/fs.html#fs_file_system_flags)
await fs.writeFile('/Users/joe/test.txt', content) } catch (err) {
async function example() { try 
{ const content = 'Algum 
conteúdo!'
r+ abre o arquivo para leitura e escrita w+ abre 
o arquivo para leitura e escrita, posicionando o stream na
} exemplo()
a+ abre o arquivo para leitura e escrita, posicionando o stream na
const fs = require('fs/promessas')
}
fs.writeFile('/Users/joe/test.txt', content, { flag: 'a+' }, (err) => {})
111
Machine Translated by Google
https://nodejs.org/api/fs.html#fs_file_system_flagsO módulo principal do Node.js fs fornece muitos métodos úteis que você pode usar para
Nesse caso, uma opção melhor é gravar o conteúdo do arquivo usando fluxos.
Aqui está um exemplo de fsPromises.appendFile() :
trabalhar com pastas.
Todos esses métodos gravam o conteúdo completo no arquivo antes de retornar o 
controle de volta ao seu programa (na versão assíncrona, isso significa executar o 
retorno de chamada)
37.2. Como usar fluxos
38.1. Verifique se existe uma pasta
112
}
} exemplo()
const fs = require('fs/promessas')
}
console.error(err)
fs.appendFile('file.log', content, (err) => { if (err) {
console.log(err)
})
const content = 'Algum conteúdo!'
await fs.appendFile('/Users/joe/test.txt', content) } catch (err) {
// feito!
async function example() { try 
{ const content = 'Algum 
conteúdo!'
38. Trabalhando com pastas
Machine Translated by Google
}
tente 
{ if (!fs.existsSync(folderName)) 
{ fs.mkdirSync(folderName)
fs.readdirSync(folderPath)
const folderName = '/Users/joe/test'
const folderPath = '/Users/joe'
}
const fs = require('fs')
const fs = require('fs')
} catch (err) 
{ console.error(err)
38.2. Criar uma nova pasta
38.3. Ler o conteúdo de um diretório
Use fs.access() (e seu equivalente baseado em promessa fsPromises.access() ) 
para verificar se a pasta existe e o Node.js pode acessá-la com suas permissões.
pasta.
Use fs.readdir() ou fs.readdirSync() ou fsPromises.readdir() para ler o conteúdo 
de um diretório.
Este pedaço de código lê o conteúdo de uma pasta, tanto arquivos quanto 
subpastas, e retorna seu caminho relativo:
Você pode obter o caminho completo:
Use fs.mkdir() ou fs.mkdirSync() ou fsPromises.mkdir() para criar um novo
113
Machine Translated by Google
Você também pode filtrar os resultados para retornar apenas os arquivos e excluir as pastas:
pasta. O primeiro parâmetro é o caminho atual, o segundo o novo caminho:
Use fs.rename() ou fs.renameSync() ou fsPromises.rename() para renomear
38.4. Renomear uma pasta
return fs.lstatSync(fileName).isFile()
if (err) 
{ console.error(err)
fs.rename('/Users/joe', '/Users/roger', (err) => {
const isFile = (fileName) => {
const fs = require('fs')
}
} catch (err) 
{ console.error(err)
fs.readdirSync(folderPath).map((fileName) => { return 
path.join(folderPath, fileName) })
tente 
{ fs.renameSync('/Users/joe', '/Users/roger')
const fs = require('fs')
return path.join(folderPath, fileName) }) .filter(isFile)
fs.renameSync() é a versão síncrona:
fs.readdirSync(folderPath) .map((fileName) => {
})
} // feito
}
114
Machine Translated by Google
Use fs.rmdir() ou fs.rmdirSync() ou fsPromises.rmdir() para remover uma pasta.
Você pode passar a opção { recursive: true } para remover recursivamente o
NOTA: No Node v16.x , a opção recursiva está obsoleta para fs.rmdir da API 
de retorno de chamada, em vez disso, use fs.rm para excluir pastas que tenham
conteúdo neles:
Remover uma pasta com conteúdo pode ser mais complicado do que você precisa.
conteúdo.
38,5. Remover uma pasta
}
jogar errar
fsPromises.rename() é a versão baseada em promessa:
}
console.log(err)
fs.rmdir(dir, { recursive: true }, (err) => { if (err) {
console.log(`${dir} foi deletado!̀ ) })
} pegar (errar) {
const fs = require('fs')
} exemplo()
exemplo de função assíncrona () 
{ try { await fs.rename('/Users/
joe', '/Users/roger')
const fs = require('fs/promessas')
115
Machine Translated by Google
jogar errar
pasta const = '/Usuários/joe'
const fs = require('fs-extra')
se (erro) {
fs.rm(dir, { recursive: true, force: true }, (err) => {
})
const fs = require('fs')
npm instalar fs-extra
console.error(err)
// 
feito }) .catch((err) => {
fs.remove(pasta) .then(() 
=> {
Ou você pode instalar e usar o fs-extra módulo, que é muito popular e bem conservado. É uma substituição 
imediata do módulo fs , que fornece mais recursos em cima dele.
console.log(`${dir} foi deletado!̀ ) })
fs.remove(pasta, (err) => 
{ console.error(err) })
}
Nesse caso, o método remove() é o que você deseja.
e use assim:
Instale-o usando
Também pode ser usado com promessas:
116
Machine Translated by Google
https://www.npmjs.com/package/fs-extra
// feito
const fs = require('fs')
}
fs.fchmod()
try 
{ await fs.remove(pasta)
}
função assíncrona removeFolder(pasta) {
fs.lcown()
console.error(err)
} pegar (errar) {
pasta const = '/Usuários/joe' 
removeFolder(pasta)
39. O módulo Node fs
,
fs.appendFile() : anexa dados a um arquivo. Se o arquivo não existir, é
Não há necessidade de instalá-lo. Sendo parte do núcleo do Node.js, ele pode ser 
usado simplesmente exigindo:
permissões
,
O módulo fs fornece muitas funcionalidades muito úteis para acessar e interagir com 
o sistema de arquivos.
passado. Relacionado: fs.lchmod()
fs.access() : verifica se o arquivo existe e o Node.js pode acessá-lo com seu
fs.chmod() : altera as permissões de um arquivo especificado pelo nome do arquivo
ou com assíncrono/aguardar:
Depois de fazer isso, você tem acesso a todos os seus métodos, que incluem:
fs.chown() : altera o proprietário e o grupo de um arquivo especificado pelo 
nome do arquivo passado. Relacionado: fs.fchown() fs.close() : fecha um descritor 
de arquivo fs.copyFile() : copia um arquivo
criada
117
Machine Translated by Google
fs.mkdir() : cria uma nova pasta
fs.lstat()
fs.renameSync()
passado. Relacionado: fs.fstat() 
fs.symlink() : cria um novo link simbólico para um arquivo 
fs.truncate() : trunca para o tamanho especificado o arquivo identificado pelo nome do 
arquivo passado. Relacionado: fs.ftruncate() fs.unlink() : remover um arquivo ou um link 
simbólico fs.unwatchFile() : parar de observar alterações em um arquivo fs.utimes() : alterar 
o carimbo de data/hora do arquivo identificado pelo nome do arquivo passado . Relacionado: 
fs.futimes()
fs.link() : cria um novo link físico para um arquivo
fs.rename()
fs.createWriteStream() : cria um fluxo de arquivo gravável
fs.stat() : retorna o status do arquivo identificado pelo nome do arquivo
Sincronizar .
fs.createReadStream() : cria um fluxo de arquivo legível
fs.rmdir() : remove uma pasta
fs.writeFile() : grava dados em um arquivo. Relacionado: fs.write()
.. ) ao máximo
fs.readlink() : lê o valor de um link simbólico fs.realpath() : 
resolve ponteiros de caminho de arquivo relativo ( . path 
fs.rename() : renomeia um arquivo ou pasta
fs.watch()
manipulação 
fs.readdir() : lê o conteúdo de um diretório fs.readFile() : 
lê o conteúdo de um arquivo. Relacionado: fs.read()
fs.watchFile() : comece a observar as alterações em um arquivo. Relacionado:
fs.write()
fs.mkdtemp() : cria um diretório temporário fs.open() : 
abre o arquivo e retorna um descritor de arquivo para permitir o arquivo
Uma coisa peculiar sobre o módulo fs é que todos os métodos são 
assíncronos por padrão, mas também podem funcionar de forma síncrona anexando
,
,
Por exemplo:
118
Machine Translated by Google
}
// feito })
try 
{ fs.renameSync('before.json', 'after.json') // feito } 
catch (err) { console.error(err)
}
const fs = require('fs')
fs.rename('before.json', 'after.json', (err) => { if (err) { return 
console.error(err)
fs.writeSync()const fs = require('fs')
Por exemplo, vamos examinar o método fs.rename() . A API assíncrona é usada 
com um retorno de chamada:
Isso faz uma enorme diferença no fluxo do seu aplicativo.
Uma API síncrona pode ser usada assim, com um bloco try/catch para manipular
Node.js 10 inclui suporte experimental para uma API baseada em promessa
erros:
A principal diferença aqui é que a execução do seu script será bloqueada no 
segundo exemplo, até que a operação do arquivo seja bem-sucedida.
Você pode usar a API baseada em promessa fornecida pelo módulo fs/promises para evitar o uso da 
API baseada em retorno de chamada, o que pode causar um inferno de retorno de chamada. Aqui está um exemplo:
119
Machine Translated by Google
https://nodejs.org/api/fs.html#fs_fs_promises_api
http://callbackhell.com/
} console.log(data) 
const content = 'Algum conteúdo!'
if (err3) {
}) }) })
Retorna
} console.log('Escreveu algum conteúdo!') 
fs.readFile(fileName, 'utf8', (err3, data3) => {
const fileName = '/Users/joe/test.txt' 
fs.readFile(fileName, 'utf8', (err, data) => { if (err) 
{ console.log(err)
} console.log(data3)
Retorna
// Exemplo: Ler um arquivo e alterar seu conteúdo e lê-lo // novamente 
usando a API baseada em retorno de chamada. const fs = require('fs')
Retorna
fs.writeFile(fileName, content, (err2) => { if (err2) 
{ console.log(err2)
console.log(err3)
A API baseada em retorno de chamada pode aumentar o inferno de retorno de chamada quando há muitos 
retornos de chamada aninhados. Podemos simplesmente usar a API baseada em promessas para evitá-la:
120
Machine Translated by Google
121
40. O módulo do caminho do nó
Não há necessidade de instalá-lo. Sendo parte do núcleo do Node.js, ele pode ser 
usado simplesmente exigindo:
Este módulo fornece path.sep que fornece o separador de segmento de caminho ( \ 
no Windows e / no Linux / macOS) e path.delimiter que fornece o delimitador de 
caminho ( ; no Windows e : no Linux / macOS).
Estes são os métodos de caminho :
O módulo path fornece muitas funcionalidades muito úteis para acessar e interagir 
com o sistema de arquivos.
await fs.writeFile(fileName, content) 
console.log('Escreveu algum conteúdo!') 
const newData = await fs.readFile(fileName, 'utf8') 
console.log(newData) } catch (err) {
const fileName = '/Users/joe/test.txt' try { const 
data = await fs.readFile(fileName, 'utf8') 
console.log(data) const content = 'Algum conteúdo!'
} exemplo()
exemplo de função assíncrona () {
const caminho = require('caminho')
}
// Exemplo: Ler um arquivo e alterar seu conteúdo e // lê-lo novamente 
usando a API baseada em promessa. const fs = require('fs/promessas')
console.log(err)
40.0.1. path.basename()
Machine Translated by Google
''
require('path').basename('/test/something') // algo 
require('path').basename('/test/something.txt') // algo.txt 
require('path').basename ('/test/something.txt', '.txt') // algo
require('path').extname('/test/something') // 
require('path').extname('/test/something/file.txt') // '.txt'
require('path').dirname('/test/something') // /test 
require('path').dirname('/test/something/file.txt') // /test/something
40.0.3. caminho.extname()
40.0.2. path.dirname()
40.0.4. caminho.formato()
122
dir : o caminho da pasta a partir da base raiz : o nome 
do arquivo + extensão
Retorne a parte do diretório de um caminho:
raiz : a raiz
Retorna a parte de extensão de um caminho
a raiz é ignorada se o dir for fornecido ext 
e o nome será ignorado se a base existir
Retorna uma string de caminho de um objeto. Este é o oposto de path.parse path.format 
aceita um objeto como argumento com as seguintes chaves:
ext : a extensão do arquivo
Retorna a última parte de um caminho. Um segundo parâmetro pode filtrar a extensão do arquivo:
nome : o nome do arquivo
Machine Translated by Google
40.0.7. caminho.normalize()
40.0.8. caminho.parse()
40.0.5. path.isAbsolute()
40.0.6. caminho.join()
123
ou ..
raiz : a raiz
// WINDOWS 
require('path').format({ dir: 'C:\\Users\\joe', base: 'test.txt' }) // 'C
require('path').format({ root: '/Users/joe', name: 'test', ext: '.txt' })
Tenta calcular o caminho real quando contém especificadores relativos como .
require('path').isAbsolute('/test/something') // true 
require('path').isAbsolute('./test/something') // false
require('path').normalize('/users/joe/..//test.txt') // '/users/test.txt'
// POSIX 
require('path').format({ dir: '/Users/joe', base: 'test.txt' }) // '/User
dir : o caminho da pasta a partir da raiz
const name = 'joe' 
require('path').join('/', 'users', name, 'notes.txt') // '/users/joe/notes
Retorna true se for um caminho absoluto
Une duas ou mais partes de um caminho:
,
Analisa um caminho para um objeto com os segmentos que o compõem:
ou barras duplas:
Machine Translated by Google
Exemplo:
Você pode obter o cálculo do caminho absoluto de um caminho relativo usando
resulta em
Exemplo:
Aceita 2 caminhos como argumentos. Retorna o caminho relativo do primeiro 
caminho para o segundo, com base no diretório de trabalho atual.
40.0.10. path.resolve()
40.0.9. caminho.relativo()
124
require('path').relative('/Users/joe', '/Users/joe/test.txt') // 'test.txt require('path').relative('/
Users/joe', ' /Users/joe/something/test.txt') //
path.resolve() :
root: '/', dir: 
'/users', base: 
'test.txt', ext: '.txt',
require('path').resolve('joe.txt') // '/Users/joe/joe.txt' se executado a partir do meu
ext : a extensão do arquivo
{
nome : o nome do arquivo
base : o nome do arquivo + extensão
}
require('path').parse('/users/test.txt')
nome: 'teste'
Machine Translated by Google
require('path').resolve('/etc', 'joe.txt') // '/etc/joe.txt'
require('path').resolve('tmp', 'joe.txt') // '/Users/joe/tmp/joe.txt' if r
os.constants.errno
const os = require('os')
41. O módulo Node os
125
Se o primeiro parâmetro começar com uma barra, isso significa que é um caminho absoluto:
os.EOL fornece a sequência do delimitador de linha. É \n no Linux e macOS, e
Vejamos agora os principais métodos que o sistema operacional disponibiliza:
manipulação de arquivos:
https://nodejs.org/api/os.html#os_signal_constants.
segundo:
Existem algumas propriedades úteis que nos dizem algumas coisas importantes relacionadas a
Você ler
Ao especificar um segundo parâmetro, o resolve usará o primeiro como base para o
sobre
EADDRINUSE, EOVERFLOW e muito mais.
programa é executado e interage com ele.
define as constantes para relatórios de erros, como
informações do sistema operacional subjacente e do computador que
posso
Este módulo fornece muitas funções que você pode usar para recuperar
sinais, como SIGHUP, SIGKILL e assim por diante.
tudoeles
os.constants.signals nos informa todas as constantes relacionadas ao processo de manipulação
\r\n no Windows.
41.1. os.arch()
Machine Translated by Google
https://nodejs.org/api/os.html#os_signal_constants
/*
modelo: 'Intel(R) Core(TM)2 Duo velocidade 
da CPU: 2400, vezes: { user: 282348700, 
nice: 0, sys: 161800480, idle: 703509470, 
irq: 0, }, },
modelo: 'Intel(R) Core(TM)2 Duo velocidade 
da CPU: 2400, vezes: { user: 281685380, 
nice: 0, sys: 187986530, idle: 685833750, 
irq: 0, }, }, {
*/
]
x64
{
P8600 @ 2,40Como criar um fluxo legível 44.8. Como 
criar um fluxo gravável 44.9. Como obter 
dados de um fluxo legível 44.10. Como enviar dados 
para um fluxo gravável 44.11. Sinalizando um fluxo 
gravável que você terminou de escrever 44.12. Como criar um 
stream de transformação 45. Node, a diferença entre 
desenvolvimento e produção 46. Tratamento de erros no Node.js 46.1. 
Criando exceções 46.2. Objetos de erro 46.3. Tratamento de exceções 
46.4. Capturando exceções não capturadas 46.5. Exceções com 
promessas 46.6. Tratamento de erros com async/await
47. Construir um servidor 
HTTP 48. Fazendo solicitações HTTP com 
Node.js 48.1. Executar uma solicitação 
GET 48.2. Execute uma solicitação POST 
48.3. PUT e DELETE 49. Obtenha dados 
do corpo da solicitação HTTP
1. Introdução ao Node.js
9
Machine Translated by Google
Quando o Node.js executa uma operação de E/S, como ler da rede, acessar um 
banco de dados ou sistema de arquivos, em vez de bloquear a thread e desperdiçar 
ciclos de CPU esperando, o Node.js retomará as operações quando a resposta 
voltar.
O Node.js tem uma vantagem única porque milhões de desenvolvedores front-end 
que escrevem JavaScript para o navegador agora podem escrever o código do 
lado do servidor, além do código do lado do cliente, sem a necessidade de aprender 
uma linguagem completamente diferente.
No Node.js, os novos padrões ECMAScript podem ser usados sem problemas, 
pois você não precisa esperar que todos os seus usuários atualizem seus 
navegadores - você é responsável por decidir qual versão do ECMAScript usar 
alterando a versão do Node.js, e você também pode ativar recursos experimentais 
específicos executando o Node.js com sinalizadores.
Isso permite que o Node.js lide com milhares de conexões simultâneas com um 
único servidor sem introduzir o fardo de gerenciar a simultaneidade de threads, o 
que pode ser uma fonte significativa de bugs.
Um aplicativo Node.js é executado em um único processo, sem criar um novo 
thread para cada solicitação. O Node.js fornece um conjunto de primitivas de E/S 
assíncronas em sua biblioteca padrão que impedem o bloqueio do código 
JavaScript e, geralmente, as bibliotecas no Node.js são escritas usando paradigmas 
sem bloqueio, tornando o comportamento de bloqueio a exceção e não a norma.
npm com sua estrutura simples ajudou o ecossistema de node.js a proliferar e 
agora o registro npm hospeda quase 500.000 pacotes de código aberto que você 
pode usar livremente.
O exemplo mais comum Hello World of Node.js é um servidor web:
1.1. Node.js tem um grande número de bibliotecas
1.2. Um exemplo de aplicativo Node.js
10
Machine Translated by Google
https://flaviocopes.com/npm/
porta const = 3000
server.listen(porta, hostname, () => {
const http = require('http')
const nome do host = '127.0.0.1'
const server = http.createServer((req, res) => { res.statusCode 
= 200
Esse código inclui primeiro o módulo http Node.js.
console.log(`Servidor rodando em http://${hostname}:${port}/`) })
res.setHeader('Content-Type', 'text/plain') res.end('Hello 
World\n')
})
Sempre que uma nova solicitação é recebida, o evento de solicitação é chamado, fornecendo 
dois objetos: um pedido (um http.IncomingMessage objeto) e uma resposta (um 
http.ServerResponse objeto).
Esses 2 objetos são essenciais para lidar com a chamada HTTP.
O Node.js tem uma biblioteca padrão incrível, incluindo um suporte de primeira classe 
para redes.
devolve.
O primeiro fornece os detalhes da solicitação. Neste exemplo simples, isso não é usado, 
mas você pode acessar os cabeçalhos da solicitação e os dados da solicitação.
O método createServer() de http cria um novo servidor HTTP e
O servidor está configurado para escutar na porta e no nome do host especificados. 
Quando o servidor está pronto, a função callback é chamada, neste caso nos informando 
que o servidor está rodando.
Para executar esse trecho, salve-o como um arquivo server.js e execute o node server.js 
em seu terminal.
O segundo é usado para retornar dados ao chamador.
11
Machine Translated by Google
https://nodejs.org/api/http.html
https://nodejs.org/api/http.html
https://nodejs.org/api/http.html#http_event_request
https://nodejs.org/api/http.html#http_event_request
https://nodejs.org/api/http.html#http_class_http_incomingmessage
https://nodejs.org/api/http.html#http_class_http_serverresponse
https://nodejs.org/api/
1.3. Estruturas e ferramentas do Node.js
res.setHeader('Content-Type', 'text/plain')
res.statusCode = 200
res.end('Hello World\n')
12
definimos a propriedade statusCode como 200, para indicar uma resposta bem-sucedida.
Muitos daqueles estabelecidos ao longo do tempo como opções populares. Aqui está 
uma lista não abrangente dos que considero muito relevantes e que valem a pena aprender:
Neste caso com
Expressar, uma das maneiras mais simples e poderosas de criar um servidor web. 
Sua abordagem minimalista, sem opinião, focada nos principais recursos de um 
servidor, é a chave para seu sucesso.
Definimos o cabeçalho Content-Type:
forneceu tudo, agora integra com libs frontend React, Vue e Angular. Pode ser usado 
para criar aplicativos móveis também. koa, construído pela mesma equipe por trás 
do Express, pretende ser ainda mais simples e menor, com base em anos de 
conhecimento. O novo projeto nasceu da necessidade de criar mudanças 
incompatíveis sem atrapalhar a comunidade existente.
Meteoro, uma estrutura de pilha completa incrivelmente poderosa, fornecendo uma 
abordagem isomórfica para criar aplicativos com JavaScript, compartilhando código 
no cliente e no servidor. Uma vez uma ferramenta de prateleira que
Next.js, um framework para renderizar React renderizado no lado do servidor formulários.
Node.js é uma plataforma de baixo nível e, para tornar as coisas mais fáceis e 
interessantes para os desenvolvedores, milhares de bibliotecas foram construídas sobre o Node.js.
e encerramos a resposta, adicionando o conteúdo como argumento para end() :
Machine Translated by Google
https://expressjs.com/
https://flaviocopes.com/vue-introduction/
http://koajs.com/
https://flaviocopes.com/meteor/
https://flaviocopes.com/nextjs/
https://flaviocopes.com/react/
SvelteKit: O Sapper é um framework para construir aplicações web de todos os 
tamanhos, com uma bela experiência de desenvolvimento e roteamento flexível 
baseado em sistema de arquivos. Oferece SSR e muito mais!
Acredite ou não, o Node.js tem apenas 13 anos.
Micro, um servidor muito leve para criar microsserviços HTTP assíncronos.
Socket.io, um mecanismo de comunicação em tempo real para criar aplicativos de 
rede.
Remixar: O Remix é um framework web fullstack para construir excelentes 
experiências de usuário para a web. Ele vem pronto para uso com tudo o que você 
precisa para criar aplicativos da Web modernos (tanto front-end quanto back-end) e 
implantá-los em qualquer ambiente de tempo de execução baseado em JavaScript 
(incluindo Node.js).
Neste post, desenhamos o panorama geral do Node.js em sua história, para colocar as 
coisas em perspectiva.GHz',
[
P8600 @ 2,40 GHz',
41.4. os.homedir() 
41.2. os.cpus()
41.3. os.freemem() 
braço64 .
,
Retorne informações sobre as CPUs disponíveis em seu sistema.
Exemplo:
Retorna o número de bytes que representam a memória livre no sistema.
,Retorna a string que identifica a arquitetura subjacente, como arm
126
Machine Translated by Google
'/Usuários/joe'
//[3.68798828125, 4.00244140625, 11.1181640625]
41.5. os.hostname() 
41.6. os.loadavg() 
41,7. os.networkInterfaces()
Exemplo:
Exemplo:
Retorna os detalhes das interfaces de rede disponíveis em seu sistema.
Ele retorna apenas um valor significativo no Linux e no macOS.
Retorna o cálculo feito pelo sistema operacional na média de carga.
Exemplo:
Retorne o caminho para o diretório inicial do usuário atual.
Retorne o nome do host.
127
Machine Translated by Google
41,8. os.platform()
Retorne a plataforma para a qual o Node.js foi compilado:
[ { endereço: 'fe80::2513:72bc:f405:61d0', máscara 
de rede: 'ffff:ffff:ffff:ffff::', família: 'IPv6', mac: 
'fe:80:00:20:00: 00', scopeid: 8, internal: 
false } ] }
netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', family: 'IPv6', mac: 
'fe:82:00:00:00:00', scopeid: 0, internal: true } , { endereço: 
'fe80::1', máscara de rede: 'ffff:ffff:ffff:ffff::', família: 'IPv6', mac: 
'fe:82:00:00:00:00', scopeid: 1 , interno: verdadeiro } ],
darwin
utun0:
máscara de rede: '255.255.255.0', 
família: 'IPv4', mac: 
'06:00:00:02:0e:00', interno: 
false } ],
{ Endereço 1',
[ { endereço: '127.0.0.1', 
máscara de rede: 
'255.0.0.0', família: 'IPv4', 
mac: 'fe:82:00:00:00:00', 
interno: true },
[ { endereço: 'fe82::9b:8282:d7e6:496e', máscara 
de rede: 'ffff:ffff:ffff:ffff::', família: 'IPv6', 
mac: '06:00:00:02:0e: 00', scopeid: 5, 
internal: false }, { address: '192.168.1.38',
{ lo0:
en1:
128
Machine Translated by Google
...mais
Retorna uma string que identifica o número da versão do sistema operacional
Identifica o sistema operacional:
Retorna o caminho para a pasta temporária atribuída.
Retorna o número de bytes que representam a memória total disponível no sistema.
Retorna o número de segundos que o computador está em execução desde a última 
reinicialização.
41.11. os.totalmem() 
41.10. os.tmpdir() 
41.9. os.release() 
41.12. os.type()
41.13. os.uptime()
41.14. os.userInfo() 
Linux
freebsd
win32
Darwin no macOS
Windows_NT no Windows
linux
openbsd
129
Machine Translated by Google
const porta = new EventEmitter()
Conchafluido
const EventEmitter = require('eventos')
door.emit('slam') // emitindo o evento "slam"
gid
42. O módulo de eventos do nó
130
foram registrados.
trabalhando com eventos em Node.js.
Emite um evento. Ele chama de forma síncrona todos os ouvintes de eventos na ordem em que eles
O módulo de eventos nos fornece a classe EventEmitter, que é a chave para
,
Alias para emissor.on() .
Retorna um objeto que contém o nome de usuário atual e o 
homedir
,,
Aqui está uma descrição detalhada dos métodos mais úteis:
,
Objeto EventEmitter :
removeListener quando um ouvinte é removido
Retorna um array de strings que representam os eventos registrados no atual
newListener quando um ouvinte é adicionado
O ouvinte de eventos tem estes eventos integrados:
42.2. emissor.emitir()
42.3. emissor.eventNames()
42.1. emissor.addListener()
Machine Translated by Google
42.4. emissor.getMaxListeners()
42,7. emissor.off()
42,5. emissor.listenerCount()
42.6. emissor.ouvintes()
42,8. emissor.on()
Alias para emissor.removeListener() adicionado no Node.js 10
Adiciona uma função de retorno de chamada que é chamada quando um evento é emitido.
Obtém um array de listeners do evento passado como parâmetro:
objeto, cujo padrão é 10, mas pode ser aumentado ou diminuído usando
Uso:
Obtenha a contagem de listeners do evento passado como parâmetro:
door.listenerCount('open')
setMaxListeners()
Obtenha a quantidade máxima de ouvintes que se pode adicionar a um EventEmitter
door.eventNames()
door.listeners('open')
door.getMaxListeners()
131
Machine Translated by Google
42.12. emissor.removeAllListeners()
42.9. emissor.uma vez()
42.11. emissor.prependOnceListener()
42.10. emissor.prependListener()
Quando você adiciona um ouvinte usando a fila de ouvintes 
on ou addListener e é chamado por último. Usando prependListener , ele é adicionado e 
chamado antes de outros ouvintes.
é adicionado por último na fila de ouvintes,
Remove todos os ouvintes de um objeto EventEmitter ouvindo um evento específico:
Adiciona uma função de retorno de chamada que é chamada quando um evento é emitido pela primeira vez
Quando você adiciona um ouvinte usando 
uma vez e chamado por último. Usando prependOnceListener , ele é adicionado e chamado 
antes de outros ouvintes.
é adicionado por último no,
tempo depois de registrar isso. Este retorno de chamada só será chamado uma vez, 
nunca mais.
,
door.removeAllListeners('open')
})
const EventEmitter = require('eventos')
ee.once('meu-evento', () => {
door.on('abrir', () => 
{ console.log('A porta foi aberta') })
// chama a função callback uma vez
const ee = new EventEmitter()
132
Machine Translated by Google
133
Remova um ouvinte específico. Você pode fazer isso salvando a função de retorno de chamada 
em uma variável, quando adicionada, para poder referenciá-la posteriormente:
O módulo principal HTTP é um módulo chave para a rede Node.js.
Define a quantidade máxima de ouvintes que se pode adicionar a um EventEmitter
Esta propriedade lista todos os métodos HTTP suportados:
Pode ser incluído usando
O módulo fornece algumas propriedades e métodos, e algumas classes.
objeto, cujo padrão é 10, mas pode ser aumentado ou diminuído.
door.setMaxListeners(50)
const doSomething = () => {} 
door.on('open', doSomething) 
door.removeListener('open', doSomething)
const http = require('http')
43.1. Propriedades
43.1.1. http.MÉTODOS
42.14. emissor.setMaxListeners()
42.13. emissor.removeListener()
43. O módulo Nó http
Machine Translated by Google
43.1.2. http.STATUS_CODES
134
> require('http').METHODS 
[ 'ACL', 'BIND', 'CHECKOUT', 
'CONNECT', 'COPY', 
'DELETE', 'GET', 'HEAD', 
'LINK', 'LOCK', 'M-SEARCH', 
'MERGE', 'MKACTIVITY', 
'MKCALENDAR', 'MKCOL', 
'MOVE', 'NOTIFY', 'OPTIONS', 
'PATCH', 'POST', 'PROPFIND', 
'PROPPATCH', 'PURGE', 
'PUT', 'REBIND', 'REPORT', 
'SEARCH', 'SUBSCRIBE', 
'TRACE', 'UNBIND', 
'UNLINK', 'UNLOCK', 
'UNSUBSCRIBE']
Esta propriedade lista todos os códigos de status HTTP e sua descrição:
Machine Translated by Google
> require('http').STATUS_CODES 
{ '100': 'Continuar', '101': 'Protocolos 
de comutação', '102': 
'Processando', '200': 'OK', '201': 
'Criado' , '202': 'Aceito', '203': 
'Informações não autorizadas', 
'204': 'Sem conteúdo', '205': 
'Redefinir conteúdo', '206': 'Conteúdo parcial', 
'207' : 'Multi-Status', '208': 'Já reportado', 
'226': 'IM usado', '300': 'Várias opções', '301': 
'Movido permanentemente', '302': 
'Encontrado' , '303': 'Ver outro', '304': 'Não 
modificado', '305': 'Usar proxy', '307': 
'Redirecionamento temporário', '308': 
'Redirecionamento permanente', '400': 
'Solicitação inválida', '401': 'Não autorizado', 
'402': 'Pagamento obrigatório', '403': 
'Proibido', '404':'Não encontrado', '405': 
'Método não permitido', ' 406': 'Não aceitável', 
'407': 'Autenticação de proxy necessária', 
'408': 'Tempo limite da solicitação', '409': 
'Conflito', '410': 'Desaparecido', '411': 
'Comprimento necessário ', '412': 'Falha na 
pré-condição', '413': 'Payload muito grande', 
'414': 'URI muito longo', '415': 'Tipo de mídia 
não suportado', '416': 'Intervalo não 
satisfatório' , '417': 'Falha na expectativa', 
'418': 'Eu \'ma teapot', '421': 'Solicitação mal 
direcionada', '422': 'Entidade não processável', 
'423': 'Bloqueado', '424': 'Falha na 
dependência',
135
Machine Translated by Google
43.1.3. http.globalAgent
43.2.1. http.createServer()
43.2. Métodos
136
'506': 'Variante também negocia',
'429': 'Muitas solicitações',
'505': 'Versão HTTP não suportada',
'428': 'Pré-condição necessária',
http.Classe de agente .
// trata cada requisição com este callback })
'426': 'Atualização necessária',
'504': 'Tempo limite do gateway',
const server = http.createServer((req, res) => {
'425': 'Coleção não ordenada',
'503 serviço indisponível',
'502 Bad Gateway',
'511': 'Autenticação de rede necessária' }
'510': 'Não estendido',
'501': 'Não implementado',
'500': 'Erro do servidor interno',
'509': 'Limite de largura de banda excedido',
'451': 'Indisponível por motivos legais',
'508': 'Loop detectado',
'507': 'Armazenamento insuficiente',
'431': 'Campos de cabeçalho de solicitação muito grandes',
Retorna uma nova instância da classe http.Server .
Aponta para a instância global do objeto Agent, que é uma instância do
Mais informações na descrição da classe http.Agent posteriormente.
Ele é usado para gerenciar a persistência e a reutilização de conexões para 
clientes HTTP e é um componente chave da rede HTTP Node.js.
Uso:
Machine Translated by Google
Um objeto http.ClientRequest é criado quando http.request() ou
Esse objeto garante que todas as solicitações feitas a um servidor sejam enfileiradas e 
um único soquete seja reutilizado.
Faz uma solicitação HTTP para um servidor, criando uma instância da classe 
http.ClientRequest .
Semelhante a http.request() 
e chama req.end() automaticamente.
Ele também mantém um pool de soquetes. Isso é fundamental por razões de desempenho.
O módulo HTTP fornece 5 classes:
http.get() é chamado.
mas define automaticamente o método HTTP para GET,,
O Node.js cria uma instância global da classe http.Agent para gerenciar a persistência 
e a reutilização de conexões para clientes HTTP, um componente chave da rede HTTP 
Node.js.
137
43.3. Aulas
43.2.3. http.get()
43.3.1. http.Agente
43.3.2. http.ClientRequest
43.2.2. http.request()
http.Agente
http.Servidor
http.IncomingMessage
http.ClientRequest
http.ServerResponse
Machine Translated by Google
const server = http.createServer((req, res) => { // res é 
um objeto http.ServerResponse })
43.3.3. http.Servidor
43.3.4. http.ServerResponse
138
O método que você sempre chamará no manipulador é a resposta 
end() , a mensagem está completa e o servidor pode enviá-la ao cliente. Deve ser chamado 
em cada resposta.
você pode chamar o método response.read() no 
manipulador de eventos de resposta . Você pode configurar um ouvinte de eventos para 
o evento de dados , para que possa ouvir os dados transmitidos.
Os dados retornados de uma resposta podem ser lidos de 2 maneiras:
Comumente conhecido e usado no código como res :
Quando uma resposta é recebida, o evento de resposta é chamado com a resposta, com uma 
instância http.IncomingMessage como argumento.
evento de solicitação que ele é acionado.
Criado por um http.Server e passado como segundo parâmetro para o
definir
getHeaderNames() obtém a lista dos nomes dos cabeçalhos HTTP já
close() impede o servidor de aceitar novas conexões listen() inicia o 
servidor HTTP e escuta as conexões
Estes métodos são usados para interagir com cabeçalhos HTTP:
Depois de ter um objeto de servidor, você tem acesso aos seus métodos:
, que fecha o
Essa classe geralmente é instanciada e retornada ao criar um novo servidor usando 
http.createServer() .
Machine Translated by Google
Se os cabeçalhos ainda não foram enviados usando os 
cabeçalhos response.writeHead() primeiro, com o código de status e a mensagem 
definidos na solicitação, que você pode editar definindo os valores das propriedades 
statusCode e statusMessage :
Método HTTP usando seu método de método
Para enviar dados ao cliente no corpo da resposta, use write() . Ele enviará dados 
em buffer para o fluxo de resposta HTTP.
,
URL usando o método url
Ele pode ser usado para acessar a resposta:
a mensagem de status opcional e o objeto headers.
ele vai enviar o
Um objeto http.IncomingMessage é criado por:
,
Versão HTTP usando o método httpVersion
Depois de processar os cabeçalhos você pode enviá-los para o cliente chamando 
que aceita o statusCode como o primeiro parâmetro,
43.3.5. http.IncomingMessage
139
response.statusCode = 500 
response.statusMessage = 'Erro interno do servidor'
getHeaders() obtém uma cópia dos cabeçalhos HTTP já definidos 
setHeader('headername', value) define um valor de cabeçalho HTTP 
getHeader('headername') obtém um cabeçalho HTTP já definido 
removeHeader('headername') remove um cabeçalho HTTP já definido 
hasHeader ('headername') retorna true se a resposta tiver esse cabeçalho definido 
headersSent() retorna true se os cabeçalhos já foram enviados ao cliente
resposta.writeHead()
http.Server ao ouvir o evento de solicitação 
http.ClientRequest ao ouvir o evento de resposta
status usando seus métodos statusCode e statusMessage 
cabeçalhos usando seu método headers ou rawHeaders
Machine Translated by Google
44. Streams Node.js
140
Streams não são um conceito exclusivo do Node.js. Eles foram introduzidos no sistema 
operacional Unix décadas atrás, e os programas podem interagir uns com os outros 
passando fluxos através do operador pipe ( | ).
socket subjacente usando o método socket
O módulo de fluxo Node.js fornece a base sobre a qual todas as APIs de streaming são 
construídas. Todos os fluxos são instâncias de EventEmitter
Eles são uma maneira de lidar com a leitura/gravação de arquivos, comunicações de 
rede ou qualquer tipo de troca de informações de ponta a ponta de maneira eficiente.
Usando streams você lê peça por peça, processando seu conteúdo sem manter tudo na 
memória.
Eficiência de tempo: leva muito menos tempo para iniciar o processamento de 
dados, pois você pode começar a processá-los assim que os tiver, em vez de esperar até
Os fluxos são um dos conceitos fundamentais que alimentam os aplicativos Node.js.
Por exemplo, da maneira tradicional, quando você diz ao programa para ler um arquivo, 
o arquivo é lido na memória, do início ao fim, e então você o processa.
Streams basicamente fornecem duas vantagens principais sobre o uso de outros 
métodos de manipulação de dados:
Eficiência de memória: você não precisa carregar grandes quantidades de dados 
na memória antes de poder processá-los
Os dados são acessados usando streams, pois http.IncomingMessage implementa a 
interfaceReadable Stream.
44.2. Por que streams
44.1. O que são fluxos
Machine Translated by Google
https://nodejs.org/api/stream.html
https://nodejs.org/api/stream.html
https://nodejs.org/api/events.html#events_class_eventemitter
44.3. Um exemplo de fluxo
const http = require('http') const fs 
= require('fs')
}) }) 
server.listen(3000)
const server = http.createServer(function (req, res) { fs.readFile(`$
{__dirname}/data.txt`, (err, data) => {
const http = require('http') const fs 
= require('fs')
const server = http.createServer((req, res) => {
const stream = fs.createReadStream(`${__dirname}/data.txt`) stream.pipe(res) }) 
server.listen(3000)
res.end(dados)
funcionar quando terminar.
toda a carga útil de dados está disponível
readFile() lê o conteúdo completo do arquivo e invoca o retorno de chamada
cliente.
Usando o módulo Node.js fs , você pode ler um arquivo e servi-lo por HTTP quando 
uma nova conexão for estabelecida com seu servidor HTTP:
Se o arquivo for grande, a operação levará um pouco de tempo. Aqui está a mesma 
coisa escrita usando streams:
Em vez de esperar até que o arquivo seja totalmente lido, começamos a transmiti-lo 
para o cliente HTTP assim que temos um bloco de dados pronto para ser enviado.
res.end(data) no retorno de chamada retornará o conteúdo do arquivo para o HTTP
Um exemplo típico é a leitura de arquivos de um disco.
141
Machine Translated by Google
Esta construção é o mesmo que fazer
Devido às suas vantagens, muitos módulos principais do Node.js fornecem recursos 
nativos de manipulação de fluxo, principalmente:
process.stdin retorna um fluxo conectado a stdin 
process.stdout retorna um fluxo conectado a stdout 
process.stderr retorna um fluxo conectado a stderr 
fs.createReadStream() cria um fluxo legível para um arquivo
zlib.createGzip() compactar dados usando gzip (um algoritmo de compactação)
em um fluxo
http.request() retorna uma instância da classe http.ClientRequest, que é um 
fluxo gravável
O valor de retorno do método pipe() é o fluxo de destino, que é uma coisa muito 
conveniente que nos permite encadear várias chamadas pipe() , assim:
fs.createWriteStream() cria um fluxo gravável para um arquivo
Você o chama no fluxo de origem, portanto, nesse caso, o fluxo de arquivo é 
canalizado para a resposta HTTP.
net.connect() inicia uma conexão baseada em fluxo
zlib.createGunzip() descompacta um fluxo gzip.
O exemplo acima usa a linha stream.pipe(res) : o método pipe() é chamado no fluxo 
do arquivo.
O que faz este código? Ele pega a fonte e a canaliza para um destino.
src.pipe(dest1) 
dest1.pipe(dest2)
src.pipe(destino1).pipe(destino2)
44.4. cano()
44,5. APIs Node.js baseadas em streams
142
Machine Translated by Google
combinação de um fluxo legível e gravável
Você também pode implementar _read usando a opção read :
algoritmo) em um fluxo 
zlib.createInflate() descompactar um fluxo deflate
então implemente _read :
Existem quatro classes de fluxos:
Primeiro crie um objeto de fluxo:
44.6. Diferentes tipos de fluxos
44,7. Como criar um fluxo legível
Duplex : um fluxo no qual você pode canalizar e canalizar, basicamente um
zlib.createDeflate() compacta dados usando deflate (uma compactação
readableStream._read = () => {}
Writable : um fluxo no qual você pode canalizar, mas não canalizar (você pode 
enviar dados, mas não receber dele)
Transform : um fluxo Transform é semelhante a um Duplex, mas a saída é uma 
transformação de sua entrada
const readableStream = new Stream.Readable()
Legível : um fluxo do qual você pode canalizar, mas não canalizar (você pode 
receber dados, mas não enviar dados para ele). Quando você envia dados para um 
fluxo legível, ele é armazenado em buffer até que um consumidor comece a ler os dados.
const Stream = require('stream')
Obtemos o fluxo legível do módulo de fluxo , e nós o inicializamos e implementamos o 
método readable._read() .
143
Machine Translated by Google
https://nodejs.org/api/stream.html
https://nodejs.org/api/stream.html
Para criar um fluxo gravável, estendemos o objeto Writable básico e implementamos 
seu método _write().
Primeiro crie um objeto de fluxo:
Agora que o stream foi inicializado, podemos enviar dados para ele:
Agora você pode canalizar um fluxo legível em:
Como lemos dados de um fluxo legível? Usando um fluxo gravável:
então implemente _write :
44,8. Como criar um fluxo gravável
44.9. Como obter dados de um fluxo legível
process.stdin.pipe(writableStream)
const writableStream = new Stream.Writable()
const readableStream = new Stream.Readable({
const Stream = require('stream')
}
readableStream.push('oi!') 
readableStream.push('ho!')
writableStream._write = (pedaço, codificação, próximo) => {
console.log(chunk.toString()) next()
leia() {},
})
144
Machine Translated by Google
Você também pode consumir um fluxo legível diretamente, usando o evento legível :
Usando o método stream write() :
Use o método end() :
44.11. Sinalizando um fluxo gravável que você 
terminou de escrever
44.10. Como enviar dados para um fluxo gravável
}
const Stream = require('stream')
readableStream.on('readable', () => 
{ console.log(readableStream.read()) })
console.log(chunk.toString()) next()
readableStream.push('oi!') 
readableStream.push('ho!')
writableStream.write('Ei!\n')
writableStream._write = (pedaço, codificação, próximo) => {
readableStream.pipe(writableStream)
}) 
const writableStream = new Stream.Writable()
const readableStream = new Stream.Readable({
leia() {},
145
Machine Translated by Google
No exemplo acima, end() é chamado dentro de um ouvinte para o evento close no 
fluxo legível para garantir que não seja chamado antes que todos os eventos de gravação tenham
passou pelo pipe, pois isso faria com que um evento de erro fosse emitido. Chamar 
destroy() no stream legível faz com que o evento close seja emitido. O ouvinte do 
evento close no fluxo gravável
Primeiro, crie um objeto de stream de transformação:
demonstra a conclusão do processo como é emitido após a chamada para
44.12. Como criar um fluxo de transformação
}
const Stream = require('stream')
readableStream.on('close', () => writableStream.end()) 
writableStream.on('close', () => console.log('terminado'))
console.log(chunk.toString()) next()
readableStream.push('oi!') 
readableStream.push('ho!')
readableStream.destroy()
fim() .
writableStream._write = (pedaço, codificação, próximo) => {
readableStream.pipe(writableStream)
}) 
const writableStream = new Stream.Writable()
Obtemos o stream Transform do módulo stream , e nós o inicializamos e implementamos o método 
transform._transform() .
const readableStream = new Stream.Readable({
leia() {},
146
Machine Translated by Google
https://nodejs.org/api/stream.html
https://nodejs.org/api/stream.html
O Node.js assume que está sempre sendo executado em um ambiente de 
desenvolvimento. Você pode sinalizar ao Node.js que está executando em 
produção configurando a variável de ambiente NODE_ENV=production .
Fluxo legível do tubo:
Você pode ter configurações diferentes para ambientes de produção e 
desenvolvimento.
Você também pode aplicar a variável de ambiente anexando-aao comando de 
inicialização do aplicativo:
persistir em caso de reinicialização do sistema.
no shell, mas é melhor colocá-lo em seu arquivo de configuração do shell (por 
exemplo, .bash_profile com o shell Bash) porque, caso contrário, a configuração não
Isso geralmente é feito executando o comando
então implemente _transform :
45. Nó, a diferença entre 
desenvolvimento e produção
}
const { Transform } = require('stream')
transformStream._transform = (chunk, encoding, callback) => 
{ transformStream.push(chunk.toString().toUpperCase()) callback()
process.stdin.pipe(transformStream).pipe(process.stdout)
export NODE_ENV=produção
const transformStream = new Transform()
147
Machine Translated by Google
}
NODE_ENV=nó de produção app.js
// ...
}
if (process.env.NODE_ENV === 'desenvolvimento') {
app.use(express.errorHandler({ dumpExceptions: true, showStack: true }))
// ...
// ...
} if (['production', 'staging'].indexOf(process.env.NODE_ENV) >= 0) {
if (process.env.NODE_ENV === 'desenvolvimento') {
}
} if (process.env.NODE_ENV === 'produção') {
if (process.env.NODE_ENV === 'produção') 
{ app.use(express.errorHandler())
Definir o ambiente para produção geralmente garante que
Por exemplo, em um aplicativo Express, você pode usar isso para definir diferentes 
manipuladores de erros por ambiente:
Há muitos mais exemplos.
Por exemplo, Pug, a biblioteca de modelos usada pelo Express, compila no modo de 
depuração se NODE_ENV não estiver definido como production . As visualizações expressas 
são compiladas em cada solicitação no modo de desenvolvimento, enquanto na produção são armazenadas em cache.
ambientes:
o registro é mantido em um nível mínimo, essencial, 
mais níveis de armazenamento em cache ocorrem para otimizar o desempenho
Essa variável de ambiente é uma convenção amplamente usada também em bibliotecas 
externas.
Você pode usar instruções condicionais para executar código em diferentes
148
Machine Translated by Google
ou
No Node.js, não lançamos strings, apenas lançamos objetos Error.
Assim que o JavaScript executa essa linha, o fluxo normal do programa é interrompido e 
o controle é retido para o manipulador de exceção mais próximo.
Uma exceção é criada usando a palavra-chave throw :
Erros no Node.js são tratados por meio de exceções.
Um manipulador de exceção é uma instrução try / catch .
Normalmente, o valor do código do lado do cliente pode ser qualquer valor JavaScript, 
incluindo uma string, um número ou um objeto.
46.2. Objetos de erro
46.3. Tratamento de exceções
46.1. Criando exceções
149
46. Tratamento de erros no Node.js
Um objeto de erro é um objeto que é uma instância do objeto Error 
ou estende a classe Error, fornecida no módulo principal Error:
// ...
} throw new NotEnoughCoffeeError()
class NotEnoughCoffeeError estende Erro {
throw new Error(' O café acabou')
valor de lançamento
Machine Translated by Google
https://nodejs.org/api/errors.html
process.on('uncaughtException', (err) => {
doSomething1() .then(doSomething2) .then(doSomething3) .catch((err) => console.error(err))
console.error('Houve um erro não detectado', err) 
process.exit(1) // obrigatório (conforme a documentação do 
Node.js) })
try 
{ // linhas de 
código } catch (e) {}
46,5. Exceções com promessas
46,4. Capturando exceções não capturadas
Qualquer exceção levantada nas linhas de código incluídas no bloco try é tratada no bloco 
catch correspondente :
e neste exemplo é o valor de exceção.
Se uma exceção não capturada for lançada durante a execução do seu programa, seu 
programa irá travar.
Você pode adicionar vários manipuladores, que podem detectar diferentes tipos de erros.
Você não precisa importar o módulo principal do processo para isso, pois ele é injetado 
automaticamente.
Usando promessas, você pode encadear diferentes operações e lidar com erros no final:
Para resolver isso, você escuta o evento uncaughtException no objeto de processo :
150
Machine Translated by Google
// ...
} pegar (errar) {
return doSomething2().catch((err) => { // trata o erro
}
// ... lidar com isso localmente 
throw new Error(err.message)
throw err // quebra a corrente!
}) }) .then(() => {
}
const fazerAlgo1 = () => {
fazerAlgumacoisa1()
return doSomething3().catch((err) => { // trata o erro 
throw err // quebra a cadeia! })
}) .catch((err) => console.error(err))
// ... 
tente 
{ // ...
.then(() => {
46.6. Tratamento de erros com async/await
Como saber onde ocorreu o erro? Você realmente não sabe, mas pode lidar 
com erros em cada uma das funções que você chama ( doSomethingX ), e 
dentro do manipulador de erros lança um novo erro, que chamará o exterior
Para poder lidar com erros localmente sem manipulá-los na função que 
chamamos, podemos quebrar a cadeia. Você pode criar uma função em cada 
then() e processar a exceção:
Usando async/await, você ainda precisa capturar erros e faz assim:
manipulador de captura :
151
Machine Translated by Google
47. Construa um servidor HTTP
Usamos o módulo para criar um servidor HTTP.
Aqui está um exemplo de servidor web HTTP Hello World:
O servidor está configurado para escutar na porta especificada, 3000 . Quando o servidor 
estiver pronto, a função de retorno de chamada de escuta é chamada.
const porta = process.env.PORT || 3000
const server = http.createServer((req, res) => { res.statusCode 
= 200
A função de retorno de chamada que passamos é aquela que será executada a cada solicitação 
recebida. Sempre que uma nova solicitação é recebida, o evento é chamado, fornecendo dois 
objetos: uma solicitação (uma solicitação http.IncomingMessage objeto) e 
uma resposta (um http.ServerResponse objeto).
função assíncrona someFunction() 
{ try { await someOtherFunction()
res.setHeader('Content-Type', 'text/html') 
res.end('Olá, Mundo!') })
const http = require('http')
}
} catch (err) 
{ console.error(err.message)
server.listen(porta, () => 
{ console.log(`Servidor rodando na porta ${port}`) })
solicitar
}
Vamos analisá-lo brevemente. Incluímos o módulo http .
152
Machine Translated by Google
https://nodejs.org/api/http.html#http_class_http_incomingmessage
https://nodejs.org/api/http.html#http_class_http_serverresponse
https://nodejs.org/api/http.html#http_event_request
https://nodejs.org/api/http.html
https://nodejs.org/api/http.html
Também definimos o cabeçalho Content-Type:
e encerramos a resposta, adicionando o conteúdo como argumento para end() :
cabeçalhos e dados de solicitação.
Neste caso com
definimos a propriedade statusCode como 200, para indicar uma resposta bem-sucedida.
Há muitas maneiras de realizar uma solicitação HTTP GET no Node.js, dependendo do nível de 
abstração que você deseja usar.
48. Fazendo solicitações HTTP 
com Node.js
153
response é usado para preencher os dados que vamos retornar ao cliente.
request fornece os detalhes da solicitação. Através dele, acessamos a solicitação
res.setHeader('Content-Type', 'text/html')
res.end('Olá, Mundo!')
A maneira mais simples de realizar uma solicitação HTTP usando Node.js é usar a biblioteca 
Axios:
res.statusCode = 200
48.1. Executar uma solicitação GET
Machine Translated byGoogle
https://github.com/axios/axios
No entanto, o Axios requer o uso de uma biblioteca de terceiros.
Uma solicitação GET é possível apenas usando os módulos padrão do Node.js, 
embora seja mais detalhado do que a opção acima:
48.2. Executar uma solicitação POST
const https = require('https')
.get('https://example.com/todos') .then((res) 
=> { console.log(`statusCode: ${res.status}
`) console.log(res) }) .catch( (erro) => {
axios
const req = https.request(options, (res) => 
{ console.log(`statusCode: ${res.statusCode}`)
res.on('dados', (d) => {
console.error(erro) })
process.stdout.write(d) })
const options = 
{ hostname: 'example.com', 
porta: 443, caminho: '/todos', 
método: 'GET',
})
req.on('erro', (erro) => 
{ console.error(erro)
req.end()
}
})
eixos const = require('eixos')
154
Machine Translated by Google
Semelhante a fazer uma solicitação HTTP GET, você pode usar a biblioteca Axios para 
executar uma solicitação POST:
Ou, alternativamente, use os módulos padrão do Node.js:
axios
todo: 'Compre o 
leite', }) .then((res) => 
{ console.log(`statusCode: $
{res.status}`) console.log(res) }) .catch((error) => {
})
eixos const = require('eixos')
.post('https://whatever.com/todos', {
console.error(erro)
155
Machine Translated by Google
https://github.com/axios/axios
48.3. COLOCAR E APAGAR
As solicitações PUT e DELETE usam o mesmo formato de solicitação 
POST - você só precisa alterar o valor options.method para o método apropriado.
156
const options = 
{ hostname: 'whatever.com', 
port: 443, path: '/todos', method: 
'POST', headers: { 'Content-
Type': 'application/json', 
'Content-Length': data.length, },
process.stdout.write(d) })
const https = require('https')
const data = JSON.stringify({ todo: 
'Compre o leite', })
}
})
})
req.write(data) 
req.end()
const req = https.request(options, (res) => 
{ console.log(`statusCode: ${res.statusCode}`)
req.on('erro', (erro) => 
{ console.error(erro)
res.on('dados', (d) => {
49. Obtenha dados do corpo da solicitação HTTP
Machine Translated by Google
Se você não estiver usando o Express e quiser fazer isso no Node.js vanilla, você precisa 
trabalhar um pouco mais, é claro, pois o Express abstrai muito disso para
Se você estiver usando o Express, é bem simples: use o middleware express.json() que está 
disponível no Express v4.16.0 em diante.
Por exemplo, para obter o corpo desta solicitação:
Este é o código do lado do servidor correspondente:
vocês.
cabeçalhos, mas não o corpo da solicitação.
A principal coisa a entender é que quando você inicializa o servidor HTTP usando o retorno 
de chamada é chamado quando o servidor obtém todo o HTTP,
Veja como você pode extrair os dados que foram enviados como JSON no corpo da solicitação.
app.use( express.urlencoded({
estendido: 
verdadeiro, })
eixos const = require('eixos')
app.use(express.json())
const express = require('express')
)
app.post('/todos', (req, res) => 
{ console.log(req.body.todo) })
axios.post('https://whatever.com/todos', {
const app = express()
http.createServer()
todo: 'Compre o leite', })
157
Machine Translated by Google
Portanto, para acessar os dados, supondo que esperamos receber uma string, 
devemos concatenar os pedaços em uma string ao ouvir os dados do fluxo e 
quando o fluxo terminar
O objeto de solicitação passado no retorno de chamada de conexão é um fluxo.
,
A partir do Node.js v10, uma sintaxe para await .. está disponível para uso. 
Simplifica o exemplo acima e faz com que pareça mais linear:
analisamos a string para JSON:
,
Primeiro, obtemos os dados ouvindo os eventos de dados de fluxo e, quando os 
dados terminam, o evento final de fluxo é chamado, uma vez:
Portanto, devemos ouvir o conteúdo do corpo a ser processado, e ele é 
processado em partes.
const server = http.createServer((req, res) => { let data =
})
''
const server = http.createServer((req, res) => { // podemos 
acessar os cabeçalhos HTTP req.on('data', (chunk) => 
{ console.log(`Data chunk available: ${chunk}` ) }) 
req.on('fim', () => { // fim dos dados })
dados += pedaço
req.on('dados', (pedaço) => {
}) 
req.on('end', () => 
{ console.log(JSON.parse(data).todo) // 'Compre o leite' res.end()
})
})
158
Machine Translated by Google
for await ( pedaço constante de req) 
{ buffers.push(chunk)
const server = http.createServer(async (req, res) => {
console.log(JSON.parse(data).todo) // 'Compre o leite' res.end()
}
buffers const = []
})
const data = Buffer.concat(buffers).toString()
159
Machine Translated by Google
Conclusão
Para mais, vá até The Valley Of Code.
Muito obrigado por ler este livro.
Envie qualquer feedback, errata ou opiniões em hello@thevalleyofcode.com
160
Machine Translated by Google
https://thevalleyofcode.com/
mailto:hello@thevalleyofcode.comEm comparação, o JavaScript tem 26 anos e a Web tem 33 anos.
Um pouco de história JavaScript é uma linguagem de programação que foi criada na 
Netscape como uma ferramenta de script para manipular páginas da web dentro de seu 
navegador, o Netscape Navigator.
Parte do modelo de negócios da Netscape era vender servidores Web, que incluíam um 
ambiente chamado Netscape LiveWire que podia criar páginas dinâmicas usando 
JavaScript do lado do servidor. Infelizmente, o Netscape LiveWire não foi
Fixar um framework web rápido e eficiente altamente focado em fornecer a melhor 
experiência de desenvolvedor com o mínimo de sobrecarga e uma poderosa 
arquitetura de plugins, inspirada no Hapi e Express.
13 anos não é muito tempo em tecnologia, mas o Node.js parece ter existido desde 
sempre.
2. Uma breve história do Node.js
13
Machine Translated by Google
https://kit.svelte.dev/
https://github.com/zeit/micro
https://socket.io/
https://remix.run/
https://www.fastify.io/
Nasce o Node.js 
A primeira versão do npm
Um fator chave que levou ao surgimento do Node.js foi o tempo. Apenas alguns anos 
antes, o JavaScript começou a ser considerado uma linguagem mais séria, graças aos 
aplicativos "Web 2.0" (como Flickr, Gmail, etc.) que mostraram ao mundo como poderia 
ser uma experiência moderna na web.
Os mecanismos JavaScript também se tornaram consideravelmente melhores, pois 
muitos navegadores competiam para oferecer aos usuários o melhor desempenho. As 
equipes de desenvolvimento por trás dos principais navegadores trabalharam duro para 
oferecer melhor suporte ao JavaScript e encontrar maneiras de fazer o JavaScript rodar 
mais rápido. O mecanismo que o Node.js usa sob o capô, V8 (também conhecido como 
Chrome V8 por ser o mecanismo JavaScript de código aberto do The Chromium Project), 
melhorou significativamente devido a essa competição.
npm chega à versão 
1.0 Grandes empresas começam a adotar Node: LinkedIn, Uber, etc
Expressar nasce 
Socket.io nasce
JavaScript muito bem-sucedido e do lado do servidor não foi popularizado até 
recentemente, pela introdução do Node.js.
O Node.js foi construído no lugar certo e na hora certa, mas a sorte não é a única razão 
pela qual é popular hoje. Ele apresenta muitos pensamentos e abordagens inovadoras 
para o desenvolvimento do lado do servidor JavaScript que já ajudaram muitos 
desenvolvedores.
2.0.1. 2009
2.0.2. 2010
2.0.3. 2011
14
Machine Translated by Google
https://flaviocopes.com/npm/
https://flaviocopes.com/express/
https://socket.io/
2.0.6. 2014
2.0.9. 2017
2.0.5. 2013
Koa nasce
2.0.7. 2015
2.0.4. 2012
2.0.8. 2016
A adoção continua muito rapidamente
O incidente da esquerda
npm se concentra mais na segurança
A Fundação Node.js nasce o io.js é 
mesclado de volta ao Node.js Node 
4 (nenhuma versão 1, 2, 3 foi lançada anteriormente)
V8 introduz o Node em seu conjunto de testes, tornando o Node oficialmente um 
alvo para o mecanismo JS, além de downloads de 3 bilhões de npm do Chrome 
toda semana
Primeira grande plataforma de blogs usando Node: Ghost
Nó 6
HTTP/2
Fio nasce
O Big Fork: io.js é um grande fork do Node.js, com o objetivo de introduzir o 
suporte ao ES6 e avançar mais rápido
Nó 8 - 9
15
Machine Translated by Google
https://koajs.com/
https://blog.npmjs.org/post/141577284765/kik-left-pad-and-npm
https://foundation.nodejs.org/
https://flaviocopes.com/v8/
https://flaviocopes.com/yarn/
https://iojs.org/
3. Como instalar o Node.js
Nó 10 - 11
Deixe-me como você os mais comuns e convenientes.
Node.js 16 
Node.js 17
O Node.js pode ser instalado de diferentes maneiras.
Nó 12 - 13
Lá você pode optar por baixar uma versão LTS (LTS significa Long Term 
Support) ou a versão mais recente disponível. Como de costume, a versão 
mais recente contém as novidades mais recentes.
GitHubGenericName (propriedade da Microsoft) adquiriu a NPM
Node.js 18
Nó 14 - 15
Pacotes oficiais para todas as principais plataformas estão disponíveis em 
https://nodejs.org/en/download/.
16
2.0.12. 2020
2.0.13. 2021
Módulos ES suporte experimental .mjs
2.0.14. 2022
2.0.10. 2018
2.0.11. 2019
Machine Translated by Google
https://flaviocopes.com/github/
https://flaviocopes.com/npm/
https://nodejs.org/en/download/
https://flaviocopes.com/es-modules/
4. Quanto JavaScript você 
precisa saber para usar o Node?
brew nó de instalação
17
Uma maneira muito conveniente de instalar o Node.js é por meio de um gerenciador 
de pacotes. Nesse caso, cada sistema operacional tem o seu.
nvm é uma maneira popular de executar o Node. Ele permite que você alterne 
facilmente a versão do Node e instale novas versões para tentar reverter facilmente se 
algo quebrar, por exemplo.
No site eles têm pacotes para Windows, Linux, macOS.
De qualquer forma, quando o Node estiver instalado, você terá acesso ao programa 
executável do nó na linha de comando.
Outros gerenciadores de pacotes para Linux e Windows estão listados em https://
nodejs.org/en/download/package-manager/
Minha sugestão é usar o instalador oficial se você está apenas começando e ainda 
não usa o Homebrew, caso contrário, o Homebrew é minha solução favorita porque 
posso atualizar facilmente o node executando brew upgrade node .
Ao aprender a codificar, você também pode ficar confuso sobre onde termina o 
JavaScript e onde começa o Node.js e vice-versa.
Veja https://github.com/nvm-sh/nvm para obter mais informações sobre esta opção.
Como iniciante, é difícil chegar a um ponto em que você esteja confiante o suficiente 
em suas habilidades de programação.
No macOS, Homebrew é o padrão de fato e - uma vez instalado - permite instalar o 
Node.js com muita facilidade, executando este comando na CLI:
Também é muito útil testar seu código com versões antigas do Node.
Machine Translated by Google
https://nodejs.org/en/download/package-manager/
https://github.com/nvm-sh/nvm
https://flaviocopes.com/homebrew/
Fechamentos
18
Promessas
5. Diferenças entre o Node e o Browser
O ciclo de eventos
Tipos
Ponto e vírgula
Literais Modelo
Assíncrono e Aguardo
Expressões
Estrutura Lexical
Matrizes
Eu recomendo que você tenha uma boa compreensão dos principais conceitos de JavaScript 
antes de mergulhar no Node.js:
Loops e Escopo
Temporizadores
rotações
Os conceitos a seguir também são fundamentais para entender a programação assíncrona, que 
é uma parte fundamental do Node.js:
Programação assíncrona e retornos de chamada
Funções de seta
isto
Com esses conceitos em mente, você está no caminho certo para se tornar um desenvolvedor 
JavaScript proficiente, tanto no navegador quanto no Node.js.
Tanto o navegador quanto o Node.js usam JavaScript como linguagem de programação.
Funções
ECMAScript 6, 2016, 2017
Variáveis
modo estrito
Machine Translated by Google
https://flaviocopes.com/javascript-closures/
https://flaviocopes.com/javascript-promises/
https://flaviocopes.com/javascript-event-loop/
https://flaviocopes.com/javascript-async-await/
https://flaviocopes.com/javascript-timers/
https://flaviocopes.com/javascript-callbacks/
Apesar do fato de ser sempre JavaScript, existem algumas diferençasimportantes que 
tornam a experiência radicalmente diferente.
No navegador, na maioria das vezes o que você está fazendo é interagir com o DOM, ou 
outras APIs da Plataforma Web como Biscoitos. Isso não existe no Node, é claro. Você não 
tem a janela do documento e todos os outros objetos
Comparado com o ambiente do navegador, onde você não tem o luxo de escolher qual 
navegador seus visitantes usarão, isso é muito conveniente.
Construir aplicativos executados no navegador é uma coisa completamente diferente de 
construir um aplicativo Node.js.
Outra grande diferença é que no Node.js você controla o ambiente. A menos que você esteja 
criando um aplicativo de código aberto que qualquer pessoa possa implantar em qualquer 
lugar, você sabe em qual versão do Node.js executará o aplicativo.
O que muda é o ecossistema.
E no navegador, não temos todas as boas APIs que o Node.js fornece por meio de seus 
módulos, como a funcionalidade de acesso ao sistema de arquivos.
Você tem uma grande oportunidade porque sabemos como é difícil aprender uma linguagem 
de programação de forma completa e profunda, e usando a mesma linguagem para realizar 
todo o seu trabalho na web - tanto no cliente quanto no servidor, você está em um posição 
única de vantagem.
Como o JavaScript se move tão rápido, mas os navegadores podem ser um pouco lentos e 
os usuários um pouco lentos para atualizar, às vezes na web, você fica preso a usar versões 
mais antigas de JavaScript / ECMAScript.
que são fornecidos pelo navegador.
Isso significa que você pode escrever todos os modernos ES6-7-8-9 JavaScript compatível 
com sua versão do Node.
Do ponto de vista de um desenvolvedor front-end que usa amplamente JavaScript, os 
aplicativos Node.js trazem consigo uma enorme vantagem: o conforto de programar tudo - 
o frontend e o backend - em uma única linguagem.
,
19
Machine Translated by Google
https://flaviocopes.com/dom/
https://flaviocopes.com/web-platform/
https://flaviocopes.com/ecmascript/
20
6. O mecanismo JavaScript V8
6.1. Outros motores JS
Outra diferença é que o Node originalmente usava o sistema de módulos CommonJS , 
enquanto no navegador usamos Módulos ES, um padrão que também foi lançado 
recentemente no Node.js (https://nodejs.org/api/esm.html)
V8 é o nome do mecanismo JavaScript que alimenta o Google Chrome. É o que pega 
nosso JavaScript e o executa enquanto navega com o Chrome.
Outros navegadores têm seu próprio mecanismo JavaScript:
Você pode usar o Babel para transformar seu código para ser compatível com ES5 
antes de enviá-lo para o navegador, mas no Node, você não precisará disso.
O ecossistema Node.js é enorme e, graças a ele, o V8 também alimenta aplicativos de 
desktop, com projetos como o Electron.
sintaxe.
O Edge foi originalmente baseado no Chakra, mas mais recentemente foi 
reconstruído usando o Chromium e o motor V8.
O legal é que o mecanismo JavaScript é independente do navegador em que está 
hospedado. Esse recurso-chave permitiu o surgimento do Node.js. O V8 foi escolhido 
para ser o mecanismo que alimentava o Node.js em 2009 e, à medida que a popularidade 
do Node.js explodiu, o V8 se tornou o mecanismo que agora alimenta uma quantidade 
incrível de código do lado do servidor escrito em JavaScript.
Firefox tem Macaco -Aranha 
Safari tem JavaScriptCore (também chamado Nitro)
No futuro, os módulos ES ( import ) são a maneira de carregar módulos em todo o 
JavaScript, front-end ou back-end, mas o Node.js ainda suporta o require
A V8 fornece o ambiente de tempo de execução no qual o JavaScript é executado. O 
DOM, e as outras APIs da Plataforma Web são fornecidos pelo navegador.
Machine Translated by Google
https://flaviocopes.com/commonjs/
https://flaviocopes.com/commonjs/
https://flaviocopes.com/es-modules/
https://nodejs.org/api/esm.html
https://flaviocopes.com/nodejs/
https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey
https://flaviocopes.com/dom/
https://flaviocopes.com/web-platform/
Todos esses motores implementam o padrão ECMA ES-262, também chamado de 
ECMAScript, o padrão usado pelo JavaScript.
O V8 está sempre evoluindo, assim como os outros mecanismos JavaScript 
existentes, para acelerar a Web e o ecossistema Node.js.
O JavaScript é compilado internamente pela V8 com compilação just-in-time (JIT) 
para acelerar a execução.
e muitos outros também existem.
Isso vem acontecendo desde 2009, quando o compilador JavaScript SpiderMonkey 
foi adicionado ao Firefox 3.5, e todos seguiram essa ideia.
Nesta introdução ao V8, vamos ignorar os detalhes de implementação do V8: eles 
podem ser encontrados em sites mais confiáveis (por exemplo, o site oficial do V8), 
e eles mudam com o tempo, muitas vezes radicalmente.
O JavaScript é geralmente considerado uma linguagem interpretada, mas os 
mecanismos JavaScript modernos não apenas interpretam o JavaScript, eles o compilam.
O V8 é escrito em C++ e é continuamente aprimorado. É portátil e roda em Mac, 
Windows, Linux e vários outros sistemas.
Isso pode parecer contra-intuitivo, mas desde a introdução do Google Maps em 2004, 
o JavaScript evoluiu de uma linguagem que geralmente executava algumas dezenas 
de linhas de código para aplicativos completos com milhares a centenas de milhares 
de linhas em execução no navegador.
Na web, há uma corrida por desempenho que vem acontecendo há anos, e nós (como 
usuários e desenvolvedores) nos beneficiamos muito dessa competição porque 
temos máquinas mais rápidas e otimizadas ano após ano.
6.2. A busca pelo desempenho
6.3. Compilação
21
Machine Translated by Google
https://flaviocopes.com/ecmascript/
#!/usr/bin/env nó
#!/usr/bin/node
nó app.js
// seu código
7. Execute scripts Node.js na 
linha de comando
22
Nesse novo mundo, compilar JavaScript faz todo o sentido porque, embora possa demorar um 
pouco mais para ter o JavaScript pronto, uma vez feito, ele terá muito mais desempenho do que o 
código puramente interpretado.
A maneira usual de executar um programa Node.js é executar o comando node disponível 
globalmente (depois de instalar o Node.js) e passar o nome do arquivo que você deseja
executar.
Acima, estamos dando explicitamente o caminho absoluto do intérprete. Nem todos os sistemas 
operacionais têm node na pasta bin, mas todos devem ter env . Você pode dizer ao sistema 
operacional para executar env com node como parâmetro:
Nossos aplicativos agora podem ser executados por horas dentro de um navegador, em vez de 
serem apenas algumas regras de validação de formulário ou scripts simples.
Acima, você está dizendo explicitamente ao shell para executar seu script com node . Você também 
pode incorporar essas informações em seu arquivo JavaScript com uma linha "shebang". O 
"shebang" é a primeira linha do arquivo e informa ao sistema operacional qual interpretador usar 
para executar o script. Abaixo está a primeira linha do JavaScript:
Se o arquivo principal do aplicativo Node.js for app.js , você poderá chamá-lo digitando:
Machine Translatedby Google
23
7.1. Reinicie o aplicativo automaticamente
chmod u+x app.js
nodemon app.js
npm i -D nodemon
npm i -g nodemon
8. Como sair de um programa 
Node.js
Você também pode instalar o nodemon como uma dependência de desenvolvimento
Execute o aplicativo usando nodemon seguido pelo nome do arquivo do aplicativo.
Instale o módulo nodemon globalmente no caminho do sistema
Ao executar o comando, verifique se você está no mesmo diretório que contém o 
arquivo app.js.
Essa instalação local do nodemon pode ser executada chamando-a de dentro do script 
npm, como npm start ou usando npx nodemon.
alteração no aplicativo, para reiniciar o aplicativo automaticamente, o módulo nodemon 
é usado.
Existem várias maneiras de encerrar um aplicativo Node.js.
Para usar um shebang, seu arquivo deve ter permissão executável. Você pode conceder 
ao app.js a permissão executável executando:
O comando node deve ser reexecutado no bash sempre que houver um
Machine Translated by Google
Você também pode definir a propriedade process.exitCode :
isto.
sistema o código de saída:
Ao executar um programa no console, você pode fechá-lo com ctrl-C , o que queremos 
discutir aqui é sair programaticamente.
vai ser desgraciosamente encerrado imediatamente.
saída
Isso significa que qualquer retorno de chamada pendente, qualquer solicitação de rede ainda sendo
mais
,
Quando o Node.js executa esta linha, o processo é imediatamente forçado a terminar.
o que significa sucesso. Diferentes códigos de saída têm
posso
saia programaticamente de um programa Node.js: process.exit() .
Por padrão, o código de saída tem 
0 significado diferente, que você pode querer usar em seu próprio sistema para ter
códigos
https://nodejs.org/api/process.html#process_exit_codes
Um programa será encerrado normalmente quando todo o processamento estiver concluído.
Se isso for bom para você, você pode passar um número inteiro que sinaliza o funcionamento
Você
e quando o programa terminar, o Node.js retornará esse código de saída.
Vamos começar com o mais drástico e ver por que é melhor não usar
mas
enviado, qualquer acesso ao sistema de arquivos ou processos gravando em stdout ou stderr - tudo é
ler sobre
,
o programa se comunica com outros programas.
no
Muitas vezes com o Node.js iniciamos servidores, como este servidor HTTP:
O módulo do núcleo do processo fornece um método prático que permite
process.exitCode = 1
processo.saída(1)
24
Machine Translated by Google
https://nodejs.org/api/process.html#process_exit_codes
})
app.get('/', (req, res) => {
res.send('Olá!')
process.on('SIGTERM', () => 
{ server.close(() => 
{ console.log('Processo encerrado') }) })
app.get('/', (req, res) => { res.send('Olá!')
const app = express()
const app = express()
const server = app.listen(3000, () => console.log('Servidor pronto'))
const express = require('express')
const express = require('express')
app.listen(3000, () => console.log('Servidor pronto'))
})
Nota: o processo não requer um "require", está disponível automaticamente.
Este programa nunca vai acabar. Se você chamar process.exit() , qualquer solicitação 
pendente ou em execução será abortada. Isso não é legal.
É melhor permitir que a solicitação em execução seja concluída antes de encerrar. 
Nesse caso, você precisa enviar ao comando um sinal SIGTERM e lidar com isso 
com o manipulador de sinal de processo:
Express é uma estrutura que usa o módulo http sob o capô, app.listen() retorna 
uma instância de http. Você usaria https.createServer se precisasse servir seu 
aplicativo usando HTTPS, pois app.listen usa apenas o módulo http.
25
Machine Translated by Google
9. Como ler variáveis de 
ambiente do Node.js
USER_ID=239482 USER_KEY=nó foobar app.js
process.kill(process.pid, 'SIGTERM')
26
O módulo central do processo do Node.js fornece a propriedade env que hospeda 
todas as variáveis de ambiente que foram definidas no momento em que o processo 
foi iniciado.
SIGTERM é o sinal que diz a um processo para terminar normalmente. É o sinal 
que é enviado por gerentes de processo, como novato ou supervisor e muitos 
outros.
Isso passará o usuário USER_ID como 239482 e o USER_KEY como foobar.
Isso é adequado para teste, mas para produção, você provavelmente estará 
configurando alguns scripts bash para exportar variáveis.
Ou de outro programa em execução Node.js ou qualquer outro aplicativo em 
execução em seu sistema que conheça o PID do processo que você deseja encerrar.
idealmente agiria como process.exit() .
SIGKILL é o sinal que diz a um processo para terminar imediatamente e
O que são sinais? Os sinais são um sistema de intercomunicação POSIX: uma 
notificação enviada a um processo para notificá-lo de um evento ocorrido.
O código abaixo executa app.js e define USER_ID e USER_KEY .
Você pode enviar este sinal de dentro do programa, em outra função:
Nota: o processo não requer um "require", está disponível automaticamente.
Machine Translated by Google
10. Onde hospedar um aplicativo Node.js
USER_KEY="foobar"
NODE_ENV="desenvolvimento"
USER_ID="239482"
require('dotenv').config()
process.env.USER_ID // "239482" 
process.env.USER_KEY // "foobar"
process.env.USER_ID // "239482" 
process.env.USER_KEY // "foobar" 
process.env.NODE_ENV // "desenvolvimento"
# arquivo .env
27
Da mesma forma, você pode acessar qualquer variável de ambiente personalizada que definir.
Aqui está um exemplo que acessa as variáveis de ambiente USER_ID e USER_KEY , que 
definimos no código acima.
Você também pode executar seu arquivo js com o comando node -r dotenv/config 
index.js se não quiser importar o pacote em seu código.
Se você tiver várias variáveis de ambiente em seu projeto de nó, também poderá criar um 
arquivo .env no diretório raiz de seu projeto e, em seguida, usar o dotenv pacote para carregá-
los durante o tempo de execução.
Aqui está uma lista não exaustiva das opções que você pode explorar quando quiser implantar 
seu aplicativo e torná-lo acessível ao público.
No seu arquivo js
Vou listar as opções das mais simples e restritas às mais complexas e poderosas.
Machine Translated by Google
https://www.npmjs.com/package/dotenv
Uma ferramenta muito bacana para isso, disponível em todas as plataformas, é o ngrok.
10.2. Implantações de configuração zero
10.1. A opção mais simples de sempre: túnel local
10.2.1. Falha
10.2.2. Codepen
Eu uso muito para fins de demonstração.
Outro serviço que você pode usar é https://github.com/localtunnel/localtunnel
Mesmo se você tiver um IP dinâmico ou estiver sob um NAT, poderá implantar seu aplicativo e atender 
às solicitações diretamente do seu computador usando um túnel local.
Fornecido pela empresa por trás do FogBugz e do Trello (e co-criadores do Stack Overflow).
Usando-o, você pode simplesmente digitar ngrok PORT e o PORT desejado é exposto à internet. Você 
obterá um domínio ngrok.io, mas com uma assinatura paga poderá obter um URL personalizado, além 
de mais opções de segurança (lembre-se de que você está abrindo sua máquina para a Internet 
pública).
Falha é umplayground e uma maneira de criar seus aplicativos mais rápido do que nunca e vê-los ao 
vivo em seu próprio subdomínio glitch.com. No momento, você não pode ter um domínio personalizado 
e há algumas restrições no lugar, mas é muito bom prototipar. Parece divertido (e isso é uma 
vantagem), e não é um ambiente estúpido - você obtém todo o poder do Node.js, um CDN, 
armazenamento seguro para credenciais, importação/exportação do GitHub e muito mais.
Codepen é uma plataforma e uma comunidade incríveis. Você pode criar um projeto com vários 
arquivos e implantá-lo com um domínio personalizado.
Esta opção é adequada para alguns testes rápidos, demonstração de um produto ou compartilhamento 
de um aplicativo com um grupo muito pequeno de pessoas.
28
Machine Translated by Google
https://ngrok.com/
https://github.com/localtunnel/localtunnel
https://glitch.com/
https://glitch.com/faq#restrictions
https://flaviocopes.com/cdn/
https://codepen.io/
10.4.1. hora agora
10.4. PAAS
10.4.3. Heroku
10.3. Sem servidor
10.4.2. Nanobox
Uma maneira de publicar seus aplicativos e não ter nenhum servidor para gerenciar é 
sem servidor. Serverless é um paradigma em que você publica seus aplicativos como 
funções e eles respondem em um endpoint de rede (também chamado de FAAS - 
Functions As A Service).
Ambos fornecem uma camada de abstração para publicação no AWS Lambda e outras 
soluções FAAS baseadas no Azure ou na oferta do Google Cloud.
Zeit é uma opção interessante. Você acabou de digitar agora no seu terminal e ele 
cuida da implantação do seu aplicativo. Existe uma versão gratuita com limitações e 
a versão paga é mais poderosa. Você esquece que existe um servidor, você apenas 
implanta o aplicativo.
Zeit agora se chama Vercel
Heroku é uma plataforma incrível.
Biblioteca padrão
Estrutura sem servidor
Nanobox
PAAS significa Platform As A Service. Essas plataformas eliminam muitas coisas com 
as quais você deveria se preocupar ao implantar seu aplicativo.
Para soluções muito populares são
29
Machine Translated by Google
https://flaviocopes.com/serverless/
https://vercel.com/
https://stdlib.com/
https://serverless.com/framework/
https://nanobox.io/
Linode
O Google Cloud é uma estrutura incrível para seus aplicativos.
Este é um ótimo artigo sobre como começar a usar o Node.js no Heroku.
Oceano Digital
Há muito mais opções na categoria VPS, essas são apenas as que usei e recomendo.
Nesta seção você encontra os suspeitos usuais, ordenados do mais amigável ao menos 
amigável:
Confira como criar um aplicativo Web Node.js no Azure.
Como eles fornecem uma máquina Linux vazia na qual você pode trabalhar, não há um 
tutorial específico para eles.
Vultr Bare Metal serviço)
Amazon Web Services, em particular, menciono o Amazon Elastic Beanstalk, pois 
abstrai um pouco a complexidade da AWS.
O Azure é a oferta do Microsoft Cloud.
Eles têm uma boa seção de documentação do Node.js
Outra solução é obter um servidor bare metal, instalar uma distribuição Linux, conectá-
lo à internet (ou alugar um mensalmente, como você pode fazer usando o
10.4.4. Microsoft Azure
10.4.5. Google Cloud Platform
10.5. Servidor Privado Virtual
10.6. Metal puro
30
Machine Translated by Google
https://www.linode.com/
https://devcenter.heroku.com/articles/getting-started-with-nodejs
https://www.digitalocean.com/
https://docs.microsoft.com/en-us/azure/app-service/app-service-web-get-started-nodejs
https://www.vultr.com/pricing/baremetal/
https://aws.amazon.com/
https://cloud.google.com/node/
nó
nó script.js
ÿ nó
>
> console.log('teste') teste
Indefinido
>
O comando node é aquele que usamos para executar nossos scripts Node.js:
Dica: se você não tiver certeza de como abrir seu terminal, pesquise no Google 
"Como abrir o terminal no seu sistema operacional".
Observação: REPL significa Read Evaluate Print Loop e é um ambiente de 
linguagem de programação (basicamente uma janela de console) que recebe uma 
expressão única como entrada do usuário e retorna o resultado de volta ao 
console após a execução. A sessão REPL fornece uma maneira conveniente de 
testar rapidamente o código JavaScript simples.
O comando fica no modo ocioso e espera que insiramos algo.
Se executarmos o comando node sem nenhum script para executar ou sem argumentos, 
iniciaremos uma sessão REPL:
Comece simples e entre
O REPL está esperando que insiramos algum código JavaScript, para ser mais preciso.
Se você tentar agora no seu terminal, é isso que acontece:
31
11. Como usar o REPL do Node.js
Machine Translated by Google
é a saída que dissemos ao console para imprimir, então 
obtemos undefined , que é o valor de retorno da execução de console.log() . O 
Node leu essa linha de código, avaliou, imprimiu o resultado e voltou a esperar 
por mais linhas de código. O Node percorrerá essas três etapas para cada 
pedaço de código que executarmos no REPL até sairmos da sessão. Foi aí que 
o REPL recebeu seu nome.
O primeiro valor, teste
,
Em alguns casos, o código que você deseja testar pode precisar de várias linhas. 
Por exemplo, digamos que você queira definir uma função que gere um número 
aleatório, na sessão REPL digite na linha a seguir e pressione enter:
O Node imprime automaticamente o resultado de qualquer linha de código 
JavaScript sem a necessidade de instruí-lo a fazê-lo. Por exemplo, digite a 
seguinte linha e pressione enter:
O Node REPL é inteligente o suficiente para determinar que você ainda não 
terminou de escrever seu código e entrará em um modo de várias linhas para 
você digitar mais código. Agora termine sua definição de função e pressione enter:
Observe a diferença nas saídas das duas linhas acima. O Node REPL imprimiu 
undefined após a execução de console.log() enquanto, por outro lado, apenas imprimiu o resultado de 5 
=== '5' . Você precisa ter em mente que o primeiro é apenas uma declaração em 
JavaScript e o último é uma expressão.
,
> 5 === '5'
>
função gerarAleatório() {
function generateRandom() 
{ ...return Math.random() }
falso
Indefinido
...
32
Machine Translated by Google
editor em destaque dentro do REPL. Discutimos isso abaixo em comandos Dot.
O REPL imprimirá todas as propriedades e métodos que você pode acessar nessa 
classe:
O nó sairá do modo de várias linhas e imprimirá indefinido , pois não há valor 
retornado. Este modo de várias linhas é limitado. Node oferece mais
guia .
Conforme você escreve seu código, se você pressionar a tecla tab , o REPL tentará 
completar automaticamente o que você escreveu para corresponder a uma 
variável já definida ou predefinida.
,
O legal do REPL é que ele é interativo.
adicione um ponto e pressioneTente inserir o nome de uma classe JavaScript, como Number
11.1. Use a guia para completar automaticamente
11.2. Explorando objetos JavaScript
11.3. Explorar objetos globais
33
Machine Translated by Google
Se você pressionar a tecla de seta para cima , terá acesso ao histórico das 
linhas de código anteriores executadas nas sessões REPL atuais e até 
anteriores.
Se depoisde algum código você digitar _ , isso vai imprimir o resultado da 
última operação.
Você pode inspecionar os globais aos quais tem acesso digitando global. e 
pressionando tab :
11.5. A tecla de seta para cima
11.4. A variável especial _
34
Machine Translated by Google
[1, 2, 3].forEach(num => {
... console.log(num) ... })
.help : mostra os comandos de ponto 
help .editor : ativa o modo de editor, para escrever código JavaScript multilinha com
.exit : sai do repl (o mesmo que pressionar ctrl-C duas vezes)
O REPL sabe quando você está digitando uma instrução de várias linhas sem a necessidade de 
invocar .editor .
. Eles sãoO REPL possui alguns comandos especiais, todos começando com um ponto .
nome do arquivo)
,
.load : carrega um arquivo JavaScript, relativo ao diretório de trabalho atual .save : 
salva tudo o que você digitou na sessão REPL em um arquivo (especifique o
Se você digitar .break no final de uma linha, o modo multilinha será interrompido e a instrução 
não será executada.
expressão de várias linhas que está sendo inserida no momento.
e você pressiona enter 
indicando que agora pode continuar a trabalhar nesse bloco.
.clear : redefine o contexto REPL para um objeto vazio e limpa qualquer
comando irá abortar mais entradas. O mesmo que pressionar ctrl-C.
o REPL irá para uma nova linha que começa com 3 pontos,
.break : ao inserir uma expressão de várias linhas, inserir o .break
facilidade. Quando estiver nesse modo, digite ctrl-D para executar o código que você escreveu.
Por exemplo, se você começar a digitar uma iteração como esta:
Podemos importar o REPL em um arquivo JavaScript usando repl .
35
11.6. Comandos de ponto
11.7. Execute o REPL do arquivo JavaScript
Machine Translated by Google
12. Nó, aceite argumentos da linha 
de comando
Você pode passar uma string que mostra quando o REPL é iniciado. O padrão é '> 
' (com um espaço à direita), mas podemos definir um prompt personalizado.
Usando a variável repl podemos realizar várias operações. Para iniciar o prompt de 
comando REPL, digite a seguinte linha
Você pode exibir uma mensagem ao sair do REPL
Execute o arquivo na linha de comando.
Você pode passar qualquer número de argumentos ao invocar um aplicativo Node.js 
usando
36
const rep = require('repl')
repl.start()
> const n = 10
// um prompt de estilo Unix 
const local = repl.start('$ ')
local.on('saída', () => {
console.log('exiting repl') 
process.exit() })
nó repl.js
Machine Translated by Google
nó app.js
process.argv.forEach((val, index) => 
{ console.log(`${index}: ${val}`) })
nó app.js nome=joe
nó app.js joe
const args = process.argv.slice(2)
A maneira como você o recupera é usando o objeto de processo integrado ao Node.js.
ou
Todos os argumentos adicionais estão presentes a partir da terceira posição daqui para frente.
Você pode iterar sobre todos os argumentos (incluindo o caminho do nó e o caminho do arquivo) 
usando um loop:
Os argumentos podem ser autônomos ou ter uma chave e um valor.
Por exemplo:
Isso altera como você recuperará esse valor no código Node.js.
O segundo elemento é o caminho completo do arquivo que está sendo executado.
O primeiro elemento é o caminho completo do comando node .
Você pode obter apenas os argumentos adicionais criando uma nova matriz que exclui os 2 
primeiros parâmetros:
Ele expõe uma propriedade argv , que é uma matriz que contém todos os argumentos de invocação 
da linha de comando.
37
Machine Translated by Google
38
13. Saída para a linha de comando 
usando o Node
const args = require('minimist')(process.argv.slice(2))
nó app.js --name=joe
nó app.js nome=joe
const args = process.argv.slice(2) args[0]
nó app.js joe
args.name // joe
npm install minimist
13.1. Saída básica usando o módulo do console
e você precisa analisá-lo. A melhor maneira de fazer isso é por
Instale o pacote minimist necessário usando o npm (a lição sobre o gerenciador de 
pacotes vem mais tarde sobre).
Nesse caso:
você pode acessá-lo usando
args[0] é name=joe 
usando o minimist library, que ajuda a lidar com argumentos:
Se você tiver um argumento sem um nome de índice, assim:
,
Desta vez, você precisa usar traços duplos antes de cada nome de argumento:
Machine Translated by Google
https://nodejs.dev/learn/an-introduction-to-the-npm-package-manager
https://www.npmjs.com/package/minimist
13.2. Limpe o console
const x = 'x'
console.log('%o', Número)
console.log('Meu %s tem %d orelhas', 'gato', 2)
const y = 'y' 
console.log(x, y)
39
que imprime o
e o Node.js imprimirá ambos.
Também podemos formatar frases bonitas passando variáveis e um especificador de 
formato.
console.clear() limpa o console (o comportamento pode depender do
O método mais básico e mais usado é console.log() string que 
você passa para ele no console.
É basicamente o mesmo que o objeto de console que você encontra no navegador.
Node.js fornece um módulo de console que fornece toneladas de maneiras muito úteis 
de interagir com a linha de comando.
,
%i formata uma variável apenas como parte 
inteira %o formata uma variável como um objeto
Exemplo:
por exemplo:Você pode passar várias variáveis para console.log
%s formata uma variável como uma 
string %d formata uma variável como um número
Se você passar um objeto, ele irá renderizá-lo como uma string.
,
Por exemplo:
console usado)
Machine Translated by Google
https://nodejs.org/api/console.html
https://nodejs.org/api/console.html
Pegue este código:
O que acontece é que console.count() contará o número de vezes que um
Você pode apenas contar maçãs e laranjas:
Usaremos o exemplo das maçãs e laranjas para demonstrar isso.
string é impressa e imprime a contagem ao lado dela:
O método console.countReset() redefine o contador usado com console.count().
'
console.count(
const x = 1
)
console.count() é um método útil.
e foi verificado... quantas vezes?'
)
})
'
)
e foi verificado... quantas vezes?'
maçãs.forEach((fruta) => {
'O valor de x é
'
+ e +
})
const z = 3
laranjas.forEach((fruta) => {
const laranjas = ['laranja', 'laranja']
'O valor de x é
'
'O valor de y é
+ x +
console.count(
'
+ x +
console.count(fruta)
console.count(
'
e foi verificado... quantas vezes?'
const maçãs = ['apenas uma maçã']
console.count(fruta)
const y = 2
40
13.4. Redefinir contagem
13.3. Elementos de contagem
Machine Translated by Google
13.5. Imprima o rastreamento de pilha
Você pode fazer isso usando console.trace() :
Isso imprimirá o rastreamento de pilha. Isto é o que é impresso se tentarmos isso no Node.js 
REPL:
Observe como a chamada para console.countReset('orange') redefine o contador de valores
Pode haver casos em que seja útil imprimir o rastreamento da pilha de chamadas de uma função, 
talvez para responder à pergunta como você alcançou essa parte do código?
para zero.
41
})
const laranjas = ['laranja', 'laranja'] const 
maçãs = ['apenas uma maçã'] 
laranjas.forEach((fruta) => { console.count(fruta)
console.countReset('laranja')
}) 
maçãs.forEach((fruta) => 
{ console.count(fruta)
const function2= () => console.trace() const 
function1 = () => function2() function1()
oranges.forEach((fruta) => 
{ console.count(fruta) })
Machine Translated by Google
Ele não aparecerá no console, mas aparecerá no log de erros.
Como vimos console.log é ótimo para imprimir mensagens no Console. Isso é o 
que chamamos de saída padrão, ou stdout .
Você pode calcular facilmente quanto tempo uma função leva para ser executada, usando
Você pode colorir a saída do seu texto no console usando sequências de escape . 
Uma sequência de escape é um conjunto de caracteres que identifica uma cor.
13.7. stdout e stderr
13.8. Colorir a saída
13.6. Calcule o tempo gasto
42
Vestígio
} medidaFazendoAlgo()
const doSomething = () => console.log('test') const 
measureDoingSomething = () => 
{ console.time('doSomething()') // faça algo e 
meça o tempo que leva doSomething() console.timeEnd 
('faça alguma coisa()')
console.error imprime no fluxo stderr .
em function2 (repl:1:33) em 
function1 (repl:1:25) em 
repl:1:1 em 
ContextifyScript.Script.runInThisContext (vm.js:44:33) em 
REPLServer.defaultEval (repl.js:239: 29) no limite (domain.js:301:14) 
em REPLServer.runBound [as eval] (domain.js:314:12) em 
REPLServer.onLine (repl.js:440:10) em emitOne (events.js: 120:20) 
em REPLServer.emit (events.js:210:7)
time() e timeEnd()
Machine Translated by Google
https://gist.github.com/iamnewton/8754917
https://gist.github.com/iamnewton/8754917
13.9. Crie uma barra de progresso
const giz = require('giz')
console.log('\x1b[33m%s\x1b[0m', 'oi!')
console.log(chalk.yellow('oi!'))
43
Exemplo:
Você pode tentar isso no REPL do Node.js, e ele imprimirá oi! em amarelo.
,
Usar chalk.yellow é muito mais conveniente do que tentar lembrar os códigos de escape, 
e o código é muito mais legível.
No entanto, esta é a maneira de baixo nível de fazer isso. A maneira mais simples de 
colorir a saída do console é usando uma biblioteca. Giz é uma biblioteca desse tipo e, 
além de colorir, também ajuda com outros recursos de estilo, como tornar o texto em 
negrito, itálico ou sublinhado.
Verifique o link do projeto postado acima para mais exemplos de uso.
Progresso é um pacote incrível para criar uma barra de progresso no console.
Instale-o usando o progresso de instalação do npm
Você instala com npm install Chalk@4 então você pode usá-lo:
Este snippet cria uma barra de progresso de 10 etapas e a cada 100ms uma etapa é 
concluída. Quando a barra termina, limpamos o intervalo:
Machine Translated by Google
https://github.com/chalk/chalk
https://www.npmjs.com/package/progress
Quando você atribui um objeto ou uma função como uma nova propriedade de exportação , isso é o 
que está sendo exposto e, como tal, pode ser importado em outras partes do seu aplicativo ou em 
outros aplicativos também.
Quando você quer importar algo que você usa
Um arquivo Node.js pode importar funcionalidades expostas por outros arquivos Node.js.
Qualquer outro objeto ou variável definido no arquivo por padrão é privado e não exposto ao mundo 
exterior.
O Node.js tem um sistema de módulos integrado.
para importar a funcionalidade exposta no arquivo library.js que reside na pasta de arquivo atual.
Nesse arquivo, a funcionalidade deve ser exposta antes de poder ser importada por outros arquivos.
Você pode fazê-lo de 2 maneiras.
14. Aceite a entrada da linha de 
comando no Node
44
const ProgressBar = require('progresso')
bar.tick() if 
(bar.completo) {
const bar = new ProgressBar(':bar', { total: 10 }) const timer = 
setInterval(() => {
clearInterval(temporizador)
biblioteca const = require('./library')
}
}, 100)
Isto é o que a API module.exports oferece pelo sistema de módulos nos permite fazer.
Machine Translated by Google
https://nodejs.org/api/modules.html
https://nodejs.org/api/modules.html
A segunda maneira é adicionar o objeto exportado como propriedade de export . 
Dessa forma, você pode exportar vários objetos, funções ou dados:
A primeira é atribuir um objeto a module.exports que é um objeto fornecido de 
fábrica pelo sistema de módulos, e isso fará com que seu arquivo exporte apenas 
esse objeto:
ou diretamente
E no outro arquivo, você o usará referenciando uma propriedade de sua importação:
,
marca: 'Ford', 
modelo: 'Fiesta',
// index.js 
const car = require('./car')
// carro.js 
const carro = {
}
marca: 'Ford', 
modelo: 'Fiesta',
const itens = require('./car')
export.car = carro
export.car = 
{ marca: 'Ford', 
modelo: 'Fiesta',
}
const carro = {
const { carro } = itens
module.exports = carro
}
45
Machine Translated by Google
46
15. Uma introdução ao 
gerenciador de pacotes npm
}
marca: 'Ford', 
modelo: 'Fiesta',
const { carro } = require('./car')
// app.js 
const tesla = require('./car') const 
ford = require('./car').car
}
console.log(tesla, ford)
module.exports = 
{ marca: 'Tesla', 
modelo: 'Modelo S',
// car.js 
export.car = {
15.1. Introdução ao npm
require sempre retornará o objeto para o qual module.exports aponta.
ou você pode usar uma atribuição de desestruturação:
O primeiro expõe o objeto para o qual aponta. Este último expõe as propriedades 
do objeto para o qual aponta.
Isto irá imprimir { brand: 'Tesla', model: 'Model S' } undefined já que o valor de 
retorno da função require foi atualizado para o objeto que module.exports 
aponta, então a propriedade que exporta adicionada não pode ser acessada.
Qual é a diferença entre module.exports e export ?
Machine Translated by Google
15.2. Transferências
15.2.1. Instalando todas as dependências
15.2.2. Instalando um único pacote
Se um projeto tiver um arquivo package.json , executando
Começou como uma forma de baixar e gerenciar dependências de pacotes Node.js, mas 
desde então se tornou uma ferramenta usada também em JavaScript front-end.
Além disso, desde o npm 5, este comando adiciona às dependências do 
arquivo package.json . Antes da versão 5, você precisava adicionar o sinalizador
Em janeiro de 2017, mais de 350.000 pacotes foram listados no registro npm, tornando-o 
o maior repositório de código de idioma único na Terra, e você pode ter certeza de que 
existe um pacote para (quase!) tudo.
Há muitas coisas que o npm faz.
ele instalará tudo o que o projeto precisa, na pasta node_modules , criando-o caso ainda 
não exista.
Você também pode instalar um pacote específico executando
Fio e pnpm são alternativas ao npm cli. Você pode verificá-los como
Nós vamos.
47
O npm gerencia os downloads das dependências do seu projeto.
npm é o gerenciador de pacotes padrão para Node.js.
npm install 
--salvar .
npm instalar
Machine Translated by Google
https://yarnpkg.com/en/
https://pnpm.io/
15.2.3. Atualizando pacotes
npm update 
atualização npm
48
--save-opcional instala e adiciona a entrada ao arquivo package.json
-D: --save-dev
Muitas vezes você verá mais sinalizadores adicionados a este comando:
-D ou --save-dev instala e adiciona a entrada ao arquivo package.json devDependencies --
no-save instala mas não adiciona a entrada às dependências do arquivo package.jsonoptionalDependencies --no-
optional impedirá que as dependências opcionais sejam instaladas
Quanto às Dependências opcionais , a diferença é que a falha de compilação da dependência não 
causará falha na instalação. Mas é responsabilidade do seu programa lidar com a falta de 
dependência. Leia mais sobre dependências opcionais.
-O: --save-opcional
A atualização também é facilitada, executando
O npm verificará todos os pacotes para uma versão mais recente que satisfaça seu controle de versão
Abreviações das bandeiras também podem ser usadas:
A diferença entre devDependencies e dependências é que o primeiro contém ferramentas de 
desenvolvimento, como uma biblioteca de teste, enquanto o último é empacotado com o 
aplicativo em produção.
Você também pode especificar um único pacote para atualizar:
-S: --salvar
restrições.
Machine Translated by Google
https://docs.npmjs.com/cli/v7/configuring-npm/package-json#optionaldependencies
"scripts": 
{ "start-dev": "node lib/server-development", "start": 
"node lib/server-production"
}
}
{
npm run 
Muitas vezes você descobrirá que uma biblioteca é compatível apenas com uma versão principal de 
outra biblioteca.
Por exemplo:
Além dos downloads simples, o npm também gerencia o controle de versão, para que você possa 
especificar qualquer versão específica de um pacote ou exigir uma versão superior ou inferior à 
necessária.
Ou um bug na versão mais recente de uma lib, ainda não corrigida, está causando um problema.
O arquivo package.json oferece suporte a um formato para especificar tarefas de linha de comando 
que podem ser executadas usando
Especificar uma versão explícita de uma biblioteca também ajuda a manter todos na mesma versão 
exata de um pacote, para que toda a equipe execute a mesma versão até que o arquivo package.json 
seja atualizado.
Em todos esses casos, o versionamento ajuda muito, e o npm segue o padrão de versionamento 
semântico (semver).
É muito comum usar esse recurso para executar o Webpack:
49
15.3. Controle de versão
15.4. Tarefas em execução
Machine Translated by Google
16. Onde o npm instala os 
pacotes?
uma instalação global
Por padrão, quando você digita um comando npm install , como:
o pacote é instalado na árvore de arquivos atual, na subpasta node_modules .
Ao instalar um pacote usando o npm , você pode realizar 2 tipos de instalação:
Quando isso acontece, o npm também adiciona a entrada lodash na propriedade 
dependencies do arquivo package.json presente na pasta atual.
Então, em vez de digitar esses comandos longos, que são fáceis de esquecer ou 
digitar errado, você pode executar
uma instalação local
Uma instalação global é realizada usando o sinalizador -g :
50
}
{
npm instala lodash
"scripts": 
{ "watch": "webpack --watch --progress --colors --config webpack.conf.js "dev": 
"webpack --progress --colors --config webpack.conf.js", "prod": "NODE_ENV=produção 
webpack -p --config webpack.conf.js"
}
$ npm executar 
assistir $ npm 
executar dev $ npm executar prod
Machine Translated by Google
instalado usando npm
17. Como usar ou executar um pacote
Onde exatamente?
, então pacotes
ou
em vez disso, ele usará um local global.
Quando isso acontecer, o npm não instalará o pacote na pasta local, mas
Por exemplo, se seu nome de usuário for 'joe' e você usar a 
localização nvm
Quando você instala um pacote em sua pasta node_modules usando npm 
também globalmente, como você o usa em seu código Node.js?
diferem.
Para usá-lo em seu código, você só precisa importá-lo para seu programa usando
Isso vai instalar o pacote na pasta node_modules local.
No entanto, se você usar nvm para gerenciar versões do Node.js, esse local
Como
No macOS ou Linux, esse local pode ser /usr/local/lib/node_modules . Sobre
,
máquina.
mostrar
a popular biblioteca de utilitários JavaScript, usando
O comando npm root -g lhe dirá onde essa localização exata está no seu
vai
,
51
npm install -g lodash
/Users/joe/.nvm/versions/node/v8.9.0/lib/node_modules .
Digamos que você instale o lodash
exigir :
npm instala lodash
Windows pode ser C:\Users\YOU\AppData\Roaming\npm\node_modules
Machine Translated by Google
_ = exigir('lodash')
Nesse caso, ele colocará o arquivo executável em node_modules/.bin/
const
Uma maneira fácil de demonstrar isso é cowsay.
pasta.
ele vai se instalar sozinho
O pacote cowsay fornece um programa de linha de comando que pode ser executado
,
E se o seu pacote for um executável?
Há uma pasta .bin oculta , que contém links simbólicos para o cowsay
fazer uma vaca dizer algo (e outros animais também).
binários:
Ao instalar o pacote usando npm, instale cowsay e 
algumas dependências na pasta node_modules :
52
Machine Translated by Google
https://www.npmjs.com/package/cowsay
18. O guia package.json
npx cowsay me tire daqui
53
Como você executa aqueles?
,
e o npx encontrará o local do executável.
É claro que você pode digitar ./node_modules/.bin/cowsay para executá-lo e 
funciona, mas npxincluído nas versões recentes do npm (desde 5.2), é uma opção muito 
melhor. Você apenas executa:
Machine Translated by Google
18.1. A estrutura do arquivo
{
}
"name": "projeto-teste"
{}
54
Aqui está um arquivo package.json de exemplo:
Se você está construindo um pacote Node.js que deseja distribuir pelo npm , as 
coisas mudam radicalmente, e você deve ter um conjunto de propriedades que 
ajudarão outras pessoas a usá-lo. Veremos mais sobre isso mais adiante.
Ele define uma propriedade name , que informa o nome do aplicativo, ou pacote, 
contido na mesma pasta em que esse arquivo reside.
Para que é isso? O que você deve saber sobre isso e quais são algumas das coisas 
legais que você pode fazer com ele?
O arquivo package.json é uma espécie de manifesto para seu projeto. Ele pode fazer 
um monte de coisas, completamente não relacionadas. É um repositório central de 
configuração de ferramentas, por exemplo. É também onde npm e yarn armazenam 
os nomes e versões de todos os pacotes instalados.
Está vazio! Não há requisitos fixos do que deve estar em um arquivo package.json , 
para um aplicativo. O único requisito é que respeite o formato JSON, caso contrário 
não poderá ser lido por programas que tentem acessar suas propriedades 
programaticamente.
Se você trabalha com JavaScript, ou já interagiu com um projeto JavaScript, Node.js 
ou um projeto frontend, com certeza conheceu o arquivo package.json .
Este é outro pacote.json:
Aqui está um exemplo muito mais complexo, que foi extraído de um aplicativo 
Vue.js de amostra:
Machine Translated by Google
"description": "Um projeto Vue.js", 
"main": "src/main.js", "private": true, 
"scripts": { "dev": "webpack-dev-server --
inline -- progress --config build/webpack. 
"start": "npm run dev", "unit": "jest --config test/unit/jest.conf.js --coverage", "test": 
"npm run unit" , "lint": "eslint --ext .js,.vue src test/unit", "build": "node build/build.js" }, 
"dependencies": { "vue": "^2.5.2"
"name": "projeto de teste", 
"versão": "1.0.0",
}, 
"devDependencies": 
{ "autoprefixer":