Obtendo Dados do Cliente - Node.js

Todos os dados da solicitação são passados através do objeto request, que é o primeiro parâmetro da função http.createServer(). No entanto, pode ser desafiador obter os dados enviados pelo cliente a partir deste objeto. Isso ocorre principalmente porque a função de callback em http.createServer() é chamada ao receber todos os cabeçalhos HTTP, mas não o corpo da solicitação. Além disso, o próprio objeto request é um fluxo que recebe dados em pedaços separados. Portanto, para obter os dados da solicitação, precisamos escutar esse fluxo e extrair os pedaços de informação recebidos sequencialmente.

Neste caso, podemos usar diferentes métodos para obter os dados.

Processando os Eventos data e end do Objeto request

O primeiro método consiste em escutar o evento data, onde o manipulador recebe os chunks de informação que chegam. Após a recepção de todos os dados, é acionado o evento end. Por exemplo, podemos definir o seguinte servidor simples:

const http = require("http");
const fs = require("fs");

http.createServer((request, response) => {
    
    if (request.url === "/user") {
        
        let data = "";
        request.on("data", chunk => {
            data += chunk;
        });
        request.on("end", () => {
            console.log(data);
            response.end("Dados recebidos com sucesso");
        });
    } else {
        fs.readFile("index.html", (error, data) => response.end(data));
    }
}).listen(3000, () => console.log("Servidor iniciado em http://localhost:3000"));

Ao acessar o endereço /user, usamos o método request.on para configurar uma função de callback para o evento data. Esta função recebe cada pedaço de dados enviado como o parâmetro chunk. Neste caso, esperamos que o cliente envie texto. Na função de callback, adicionamos os dados recebidos à variável data. Sempre que a aplicação recebe uma nova porção de dados, o manipulador de eventos adiciona esses dados à variável data.

Quando todos os dados são recebidos, o evento end é acionado. Na função de callback deste evento, sabemos que todos os dados foram recebidos e podemos realizar as manipulações necessárias. Neste caso, os dados recebidos são simplesmente exibidos no console, e uma mensagem de notificação é enviada ao cliente.

Para testar, podemos definir o seguinte cliente na página index.html:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>Programício</title>
</head>
<body>
<script>
sendUser();
async function sendUser() {
    const response = await fetch("/user", { method: "POST", body: "Tom Smith" });
    const responseText = await response.text();
    console.log(responseText);
}
</script>
</body>
</html>

Aqui, o cliente envia uma string ao servidor, que, após recebê-la, a exibirá no console:

C:\app>node server.js
Servidor iniciado em http://localhost:3000
Tom Smith

Iterando Sobre o Iterador Assíncrono do request

O segundo método envolve iterar sobre o objeto request, que também fornece um iterador assíncrono para os dados recebidos:

const http = require("http");
const fs = require("fs");

http.createServer(async (request, response) => {
    
    if (request.url === "/user") {
        
        const buffers = []; // buffer para os dados recebidos

        for await (const chunk of request) {
            buffers.push(chunk); // adicionando todos os dados recebidos ao buffer
        }

        const data = Buffer.concat(buffers).toString();
        console.log(data);
        response.end("Dados recebidos com sucesso");
    } else {
        fs.readFile("index.html", (error, data) => response.end(data));
    }
}).listen(3000, () => console.log("Servidor iniciado em http://localhost:3000"));

Aqui, primeiramente definimos um buffer para os dados recebidos:

const buffers = [];

Depois, iteramos sobre o objeto request, recebendo dados e adicionando-os ao buffer buffers:

for await (const chunk of request) {
  buffers.push(chunk);
}

No final, usamos a função Buffer.concat() para unir todos os dados recebidos e convertê-los em uma string usando o método toString():

const data = Buffer.concat(buffers).toString();

Dessa forma, não estamos limitados a receber apenas dados textuais. Por exemplo, podemos receber dados no formato JSON:

const http = require("http");
  const fs = require("fs");
  
  http.createServer(async (request, response) => {
      
      if (request.url === "/user") {
          
          const buffers = []; // buffer para os dados recebidos
  
          for await (const chunk of request) {
              buffers.push(chunk); // adicionando todos os dados recebidos ao buffer
          }
  
          const user = JSON.parse(Buffer.concat(buffers).toString());
          console.log(user.name, "-", user.age);
          response.end("Dados recebidos com sucesso");
      } else {
          fs.readFile("index.html", (error, data) => response.end(data));
      }
  }).listen(3000, () => console.log("Servidor iniciado em http://localhost:3000"));

Aqui, supomos que o cliente está enviando um objeto JSON ao servidor, contendo as propriedades name e age. Usamos a função JSON.parse() para analisar os dados recebidos e convertê-los no formato JSON.

O código do cliente para teste poderia ser assim:

sendUser();

async function sendUser() {
    const response = await fetch("/user", { 
        method: "POST", 
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
            name: "Tom",
            age: 37
        })
    });
    const responseText = await response.text();
    console.log(responseText);
}

Neste caso, a saída do console será semelhante a:

C:\app>node server.js
Servidor iniciado em http://localhost:3000
Tom - 37