node.js é baseado no mecanismo v8 do Chrome para executar código js , para que possamos nos livrar do ambiente do navegador e executar o código js diretamente no console, como o seguinte hello world código hello world
console.log('hello world'); Você pode executá-lo diretamente usando node no console
O módulo http integrado do node.js fornece recursos básicos de serviço http createServer Com base na http CommonJS , podemos usar require para importar o módulo http para uso. módulo que nos permite criar um http O servidor recebe uma função de retorno de chamada como parâmetro Esta função de retorno de chamada recebe dois parâmetros - request e response .
request inclui todas as informações solicitadas pelo cliente, como url , header da solicitação, método de solicitação e. corpo da solicitação.response é usada principalmente para retornar informações para O cliente encapsula algumas operações relacionadas ao corpo da resposta. Por exemplo, o método response.writeHead nos permite personalizar as informações do cabeçalho e o código de status do corpo de retorno. o corpo da resposta, chamamos response.end() . Você pode enviar o corpo da resposta para o cliente. Usar a função createServer apenas cria um objeto Server para nós, mas não permite que ele escute. método listen do objeto server para escutar. Na verdade, podemos começar a executar
listen como um servidor. O primeiro parâmetro é o número da porta de escuta, o segundo parâmetro é o ip do host vinculado e o terceiro parâmetro é uma função de retorno de chamada que será.exceção
http é obtida do primeiro parâmetro da função de retorno de chamada. Podemos optar por tratar a exceção para tornar nosso servidor mais robusto.usando o módulo http para criar um servidor simples
const { createServer } = require('http' );
const HOST = 'localhost';
const PORTA = '8080';
const servidor = createServer((req, resp) => {
// o primeiro parâmetro é o código de status que ele retorna
// e o segundo parâmetro é a informação do cabeçalho de resposta
resp.writeHead(200, { 'Tipo de conteúdo': 'texto/simples' });
console.log('servidor está funcionando...');
//chama o método end para informar ao servidor que a solicitação foi atendida
resp.end('olá servidor http nodejs');
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log('Algo errado: ', erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); Você pode tentar executá-lo diretamente com node e criar seu próprio servidor! Depois que o servidor estiver em execução, o navegador poderá acessá-lo acessando http://localhost:8080
Você também pode usar nodemon para executá-lo, para que, quando nosso código for alterado, não precisemos encerrar manualmente o programa e executar novamente
o npm i -g nodemon.
É recomendável instalá-lo globalmente para que você possa usá-lo diretamente. sem usar npx nodemon Também é muito simples, basta alterar o comando node para o comando nodemon
nodemon http-server.js.
. Quando usamos objetos createServer e resp anteriormente, não conseguimos ver nenhum prompt de sintaxe. Devemos seguir a documentação oficial node para verificá-lo a qualquer momento. pode usar .d.ts nos ajuda a fornecer a função de prompt de sintaxe. Observe que não estamos usando ts para desenvolvimento, mas apenas usando sua função de prompt de sintaxe
npm init -y@types/node -- pnpm i @types/node -Djsconfig.json no diretório do projeto, exclua node_modules , não há necessidade de verificá-lo{ "compilerOptions": {
"checkJs": verdadeiro
},
"excluir": ["node_modules", "**/node_modules/*"]
} Será que você descobriu que realmente há um erro no código acima? checkJs pode nos ajudar a verificar erros de tipo. Você pode escolher se deseja ativá-lo de acordo com suas necessidades. Depois de ativar a verificação, ele nos avisará imediatamente sobre incompatibilidade de tipo de parâmetro.
Neste momento, passe o mouse sobre o método listen e você poderá ver a assinatura do método.
Como você pode ver, o parâmetro port original precisa ser do tipo number , mas quando o definimos, era do tipo string , portanto, não correspondia ao number 8080 e você poderá visualizar diretamente a documentação relevante api . sem abrir o node oficial. Demorei muito para encontrar o documento e conferir.
. Nosso http server simples retornou apenas uma frase, então é possível retornar várias frases? Isso requer o uso do método write do objeto resp . end só pode retornar o end uma vez. Em vez disso, podemos write o conteúdo no corpo da resposta várias vezes. passe quaisquer parâmetros. Apenas deixe-o completar a função de enviar o corpo da resposta
const { createServer } = require("http");
const HOST = "localhost";
const PORTA = 8080;
const servidor = createServer((req, resp) => {
resp.writeHead(200, { "Tipo de conteúdo": "texto/simples" });
console.log("servidor está funcionando...");
// escreve algumas frases lorem
resp.write("Lorem ipsum dolor sit amet consectetur adipisicing elit.n");
resp.write("Omnis eligendi aperiam delectus?n");
resp.write("Aut, quam quo!n");
resp.end();
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); Desta vez escrevemos três frases e o efeito agora fica assim.
podemos não apenas retornar uma string ao navegador, mas também ler diretamente o conteúdo do arquivo html e devolvê-lo ao navegador como resultado. Isso requer o uso de outro módulo integrado Node.js -. fs , que O módulo fornece a função de operação de arquivo Você pode usar fs.readFile para ler arquivos de forma assíncrona, mas ele não retornará um objeto promise , então precisamos passar um retorno de chamada para lidar com a operação após a leitura do arquivo. também pode usar fs.readFileSync bloqueando de forma síncrona a leitura de arquivos, aqui escolhemos leitura assíncrona
const { createServer } = require("http");
const fs = requer("fs");
const HOST = "localhost";
const PORT = 8080;const server = createServer((req, resp) => {
// altera o tipo MIME de text/plain para text/html
resp.writeHead(200, { "Tipo de conteúdo": "texto/html" });
//lê o conteúdo do arquivo html
fs.readFile("index.html", (erro, dados) => {
se (errar) {
console.error(
"ocorreu um erro ao ler o conteúdo do arquivo html: ",
errar
); lançar errar;
}
console.log("operação bem sucedida!");
resp.write(dados);
resp.end();
});
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); O resultado atual é o seguinte:
Retornar html com sucesso Nota: Aqui você precisa alterar **Content-Type** do cabeçalho de resposta para **text/html** para informar ao navegador que estamos retornando o conteúdo do arquivo **html** . Se você ainda usar **text/plain** for retornado, o navegador não analisará o conteúdo retornado, mesmo que esteja em conformidade com a sintaxe **html** , ele não será analisado, assim como o seguinte:
Quando precisamos escrever um servidor back-end que seja responsável apenas por retornar os dados da interface, precisamos retornar o conteúdo no formato json . Acredito que você seja inteligente e saiba como lidar com isso:
MIME para application/jsonresp.write , a string json é passada. Você pode usar JSON.stringify para processar o objeto e retornarconst { createServer } = require("http");
const HOST = "localhost";
const PORTA = 8080;
const servidor = createServer((req, resp) => {
// altera o tipo MIME para application/json
resp.writeHead(200, { "Tipo de conteúdo": "aplicativo/json" });
//cria dados JSON usando um objeto
const jsonDataObj = {
código: 0,
mensagem: "sucesso",
dados: {
nome: "plasticina",
idade: 20,
hobby: "codificação",
},
};
resp.write(JSON.stringify(jsonDataObj));
resp.end();
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); Os resultados são os seguintes:
A ideia de retornar arquivos PDF é semelhante à de retornar arquivos html antes. Ambos são um processo de configuração do tipo MIME do cabeçalho de resposta, leitura do arquivo e retorno do conteúdo do arquivo. algo diferente. Nossa ideia é fazer isso enquanto o servidor está rodando. Para gerar um arquivo pdf e devolvê-lo, você precisa alterar MIME para application/pdf Para gerar um arquivo pdf , você precisa usar uma biblioteca - pdfkit
pnpm i pdfkit.
Primeiro, escrevemos uma função para criar um arquivo pdf , porque a criação de um arquivo pdf também requer a realização de algumas operações de escrita, não temos certeza de quando será concluída, mas nossa solicitação deve esperar até que pdf seja criado antes de podermos. obter uma resposta, então precisamos torná-la assíncrona e retornar uma promise
/**
* @description Criar arquivo pdf */const createPdf = () => {
retornar nova Promessa((resolver, rejeitar) => {
if (!fs.existsSync("exemplo.pdf")) {
// cria um objeto PDFDocument
const doc = new PDFDocument();
// cria fluxo de gravação canalizando o conteúdo do PDF.
doc.pipe(fs.createWriteStream("exemplo.pdf"));
//adiciona algum conteúdo ao documento pdf
doc.fontSize(16).text("Olá PDF", 100, 100);
//conclui a operação de geração do arquivo PDF.
doc.end();
}
resolver("sucesso");
});
}; A operação de pipeline é usada aqui para transferir o conteúdo PDFDocument para o fluxo de gravação recém-criado por meio do pipeline. Quando a operação for concluída, notificamos o mundo externo por meio resovle de que o arquivo pdf foi criado e, em seguida, chamamos
const. servidor no código do servidor = createServer(async (req, resp) => {
// altera o tipo MIME para application/pdf
resp.writeHead(200, { "Tipo de conteúdo": "aplicativo/pdf" });
//cria arquivo pdf
aguarde createPdf();
//lê o arquivo pdf criado
fs.readFile("exemplo.pdf", (erro, dados) => {
se (errar) {
console.error(
"ocorreu um erro ao ler o conteúdo do arquivo pdf: ",
errar
);
lançar errar;
}
console.log("operação bem sucedida!");
resp.end(dados);
});
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); Agora o navegador pode ler o arquivo pdf criado
ainda é a mesma. Leia um arquivo de áudio, envie-o para o objeto resp por meio de um pipeline e retorne-o
.
const {stat, createReadStream} = require("fs");
const HOST = "localhost";
const PORTA = 8080;
const servidor = createServer((req, resp) => {
//muda o tipo MIME para audio/mpe
resp.writeHead(200, { "Tipo de conteúdo": "áudio/mp3" });
const mp3NomeArquivo = "áudio.mp3";
stat(mp3NomeArquivo, (err, estatísticas) => {
if (stats.isFile()) {
const rs = createReadStream(mp3FileName);
// canaliza o fluxo de leitura para resp
rs.pipe(resp);
} outro {
resp.end("arquivo mp3 não existe");
}
});
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
}); O efeito é o seguinte
Após a abertura, existe uma interface para reprodução de áudio. Esta é a exibição dos arquivos de áudio fornecidos pelo chrome . Ao abrir o console, você descobrirá que há arquivos de áudio retornados.
Nota: Depois de passar o fluxo do arquivo de áudio para **resp** através do pipe , não há necessidade de chamar **resp.end()** , pois isso fechará a resposta inteira e fará com que o arquivo de áudio seja indisponível.
O processamento de arquivos de vídeo e arquivos de áudio é o mesmo, exceto que MIME precisa ser alterado para video/mp4 . Todo o resto é o mesmo
const { createServer } = require("http");
const {stat, createReadStream} = require("fs");
const HOST = "localhost";
const PORTA = 8080;
const servidor = createServer((req, resp) => {
//muda o tipo MIME para audio/mpe
resp.writeHead(200, { "Tipo de conteúdo": "áudio/mp4" });
const mp4FileName = "vídeo.mp4";
stat(mp4NomeArquivo, (err, estatísticas) => {
if (stats.isFile()) {
const rs = createReadStream(mp4FileName);
// canaliza o fluxo de leitura para resp
rs.pipe(resp);
} outro {
resp.end("arquivo mp4 não existe");
}
});
});
server.listen(PORT, HOST, (erro) => {
se (erro) {
console.log("Algo errado: ", erro);
retornar;
}
console.log(`o servidor está escutando em http://${HOST}:${PORT} ...`);
});
aprendemos:
Node para criar um servidor httpJSONpdfjshtmlEmbora o conteúdo seja simples, ainda assim, espero que você possa acompanhar e tentar. não significa que você saiba disso. Você só encontrará seus próprios problemas depois de realmente implementá-los.