Olá a todos! Muito em breve, o curso de desenvolvedor do Node.js. começará , em conexão com a qual realizamos uma lição aberta tradicional . O webinar examinou os pontos fortes e fracos do Node e também discutiu quais tarefas essa plataforma de software é mais adequada e para quais outros idiomas e estruturas devem ser escolhidos. E, claro, não sem prática. Para executar os exemplos e software necessários para instalar Node.js .Professor - Alexander Korzhikov , engenheiro de TI Dev do ING Group (Holanda).
Algumas palavras sobre o Node.js
O Node.js é um tempo de execução JavaScript assíncrono, baseado em conceitos como Loop de Eventos e arquitetura orientada a eventos. A plataforma Node.js e o gerenciador de pacotes NPM padrão permitem criar aplicativos eficazes para várias áreas de assunto - da Web ao Machine Learning.O exemplo mais simples de servidor da web ( node server.js):const http = require('http')
const hostname = '127.0.0.1'
const port = 3000
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`)
})
Observando o código acima, os seguintes recursos do Node.js podem ser observados:- Podemos executar o código JavaScript diretamente no servidor, ou seja, é possível executar arquivos JavaScript usando o comando node.
- O formato CommonJS de módulos para carregar dependências e Módulos ES é suportado e ambos os formatos podem ser usados.
- Uma biblioteca de módulos padrão é suportada, da qual o HTTP faz parte.
- A API é baseada no padrão de retorno de chamada assíncrono, mas o Promise também é suportado.
- A sintaxe do ES2015 é suportada. A propósito, aqui está um link útil com o qual você sempre pode ver em qual versão do Node quais recursos JS são suportados . Se algo der errado, você poderá comparar e entender qual é o problema.
Também não perca a pequena demonstração (VSCode + Chrome Debug).Uma breve excursão pela história
A plataforma Node.js apareceu em 2009, o principal desenvolvedor e criador do projeto foi Ryan Dahl. Sua idéia principal era criar uma E / S sem bloqueio (entrada / saída) para o servidor, além disso, usando JavaScript. Naquela época, essas abordagens não eram muito comuns e o JavaScript era uma das melhores soluções.O Node.js usa o mecanismo Chromium dentro de si, ou melhor, a parte dele que interpreta o JavaScript - V8 . Devido ao fato de o intérprete ter se separado em um projeto V8 separado, tornou-se possível simplesmente criar um ecossistema em torno dele. A rigor, foi exatamente isso que o criador do Node.js Ryan Dahl fez. A propósito, hoje existe a Fundação Node.js., uma organização que apóia o projeto.
Estrutura
Em primeiro lugar, a biblioteca é escrita em C ++ e JavaScript. O projeto em si reside no GitHub ; portanto, se você estiver curioso, poderá se familiarizar com o código-fonte. Você pode se aprofundar no estudo por muito tempo)).Em segundo lugar, como já mencionado, ele inclui a V8 (a plataforma de execução JavaScript do Google) e a libuv como parte do loop de eventos (loop de eventos assíncronos).Bem, é claro, existem vários módulos para trabalhar com o sistema operacional que permitem executar as tarefas comerciais necessárias.Também vale a pena mencionar os principais padrões de design comumente usados no Node.js:- Retorno de chamada (já foi mencionado);
- Observador (padrão de evento mais simples);
- Módulo (embora agora esteja organizado na própria linguagem JavaScript, no Node.js ainda é relevante);
- Reator (padrão de interação assíncrona com alguns recursos quando você não bloqueia o fluxo principal de código). Esse padrão é familiar para os desenvolvedores de JS. Por exemplo, se trabalhamos em um navegador e escrevemos um front-end, não bloqueamos todo o trabalho do navegador, apenas assinamos os eventos do usuário e, quando o evento ocorre (depois de um "clique", "entrar" etc.), executamos nosso código.
A propósito, aqui está uma pequena competição que tivemos no webinar)). E seguir em frente.Módulos de distribuição padrão do nó
Você sabe quais módulos estão incluídos na distribuição padrão do nó? Ou seja, estamos falando de módulos que já estão embutidos, portanto, eles não podem ser instalados. Em geral, existem cerca de 50 deles, vamos listar os principais. Para facilitar a percepção, nós os dividimos convencionalmente em 5 pontos:1. Principal (para operações comuns):- fs;
- temporizadores;
- fluxos (para trabalhar com fluxos).
2. Utilitários:- caminho (para trabalhar com caminhos);
- util;
- zlib (arquivamento e descompactação);
- criptografia (para funções criptográficas).
3. Processos (tudo relacionado a multiprocessamento e paralelismo):- child_process (o módulo principal para o lançamento de módulos menores, oferece grandes oportunidades para iniciar e monitorar processos);
- cluster (semelhante ao primeiro, mas permite paralelizar tarefas nos núcleos do seu processador);
- worker_threads (implementação de threads ou threads, mas não é completamente seguro para threads, mas por que é melhor ler na documentação).
4. Protocolos (todos os tipos de protocolos):5. Sistema (respectivamente, módulos do sistema, incluindo depuração):- os
- v8;
- async_hooks;
- perf_hooks;
- trace_events
O que mais a acrescentar:- objeto global - análogo da janela;- todos os objetos JavaScript disponíveis no navegador também estão disponíveis no Node.js.- timeouts - quase como em um navegador;- processo - representação do processo atual;- console está disponível.Retornos de chamada
Retorno de chamada - uma função passada como argumento para o código, que envolve executá-lo em algum momento. A propósito, as pessoas raramente pensam que sua execução pode ser síncrona ou assíncrona.const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`)
})
No Nó, por padrão, o retorno de chamada é executado com um "erro" e o resultado é assíncrono:fs.readFile('/etc/passwd', (err, data) => {
if (err) throw err
console.log(data)
})
E aqui está a aparência do antipadrão - um bom exemplo de como usar retornos de chamada incorretamente. Como se costuma dizer, o clássico inferno de retorno de chamada :fs.readdir(source, function (err, files) {
if (err) {
console.log('Error finding files: ' + err)
} else {
files.forEach(function (filename, fileIndex) {
console.log(filename)
gm(source + filename).size(function (err, values) {
if (err) {
console.log('Error identifying file size: ' + err)
} else {
console.log(filename + ' : ' + values)
aspect = (values.width / values.height)
widths.forEach(function (width, widthIndex) {
height = Math.round(width / aspect)
console.log('resizing ' + filename + 'to ' + height + 'x' + height)
this.resize(width, height).write(dest + 'w' + width + '_' + filename, function(err) {
if (err) console.log('Error writing file: ' + err)
})
}.bind(this))
}
})
})
}
})
Agora vamos ver como criar um servidor Web simples e renderizar o índice HTML como uma resposta do cliente:const http = require('http')
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
Para ler o arquivo html local:const fs = require('fs')
fs.readFile('./index.html', (err, text) => {
console.log(text)
})
Terminando o tópico de retornos de chamada, gostaria de mencionar tipos de retorno de chamada. Existem retornos de chamada que retornam apenas um erro se houver um erro:fs.access('/etc/passwd', fs.constants.R_OK, (err) => {
console.log(err ? 'no access!' : 'read')
})
Agora também, mais e mais módulos e APIs usam o Promises imediatamente, o que é bom. O nó suporta promessas:util.promisify()
fs.promises.*
Tipo de retorno:http.request('https://example.com', (error, response, body) => {
...
})
Perguntas e Respostas do Nó
Ao escrever servidores da Web, o Express é frequentemente usado, embora existam muitas outras bibliotecas e estruturas que implementam funcionalidades semelhantes. No entanto, o Express é o mais popular e estável. Você poderia dizer que esse é o padrão para escrever servidores.import express from "express";
const app = express();
const port = 3000;
app.get("/", (req, res) => {
res.send("Hello World!");
});
app.listen(port, () => {
console.log(`Example app listening
});
Bem, agora você pode tentar criar um servidor Web com um gerador Express :- usando jade, sessão de cookie;
- fazendo um logout ingênuo de login.
Ou apenas veja como o professor fez isso, que preparou a solução pronta no TypeScript.Isso é tudo. Finalmente - alguns links úteis:E vejo você no curso .