O que o analisador de corpo faz com o express?

Não entendo por que precisamos body-parserem um aplicativo Express, pois podemos obter dados sem usar body-parser. E o que faz realmente e como?

Para manipular a HTTP POSTsolicitação no Express.js versão 4 e superior, você precisa instalar o módulo middleware chamado body-parser.

body-parserextrair toda a parte do corpo de um fluxo de solicitação de entrada e expô-la req.body.

O middleware fazia parte do Express.js anteriormente, mas agora você deve instalá-lo separadamente.

Este body-parsermódulo analisa os dados codificados em JSON, buffer, string e URL enviados usando HTTP POSTsolicitação. Instale body-parserusando o NPM, como mostrado abaixo.

npm install body-parser --save

edite em 2019-abril-2: em [email protected], o middleware body-parser empacotado com express. para mais detalhes veja isto

Sim, podemos trabalhar sem body-parser. Quando você não usa, você recebe a solicitação bruta e seu corpo e cabeçalhos não estão no objeto raiz do parâmetro request. Você terá que manipular individualmente todos os campos.

Ou você pode usar body-parser, como a equipe expressa está mantendo.

O que o analisador de corpo pode fazer por você: simplifica a solicitação.
Como usar: Aqui está um exemplo:

Instalar npm install body-parser --save

Veja como usar o analisador de corpo no express:

const express = require('express'),
      app = express(),
      bodyParser = require('body-parser');

// support parsing of application/json type post data
app.use(bodyParser.json());

//support parsing of application/x-www-form-urlencoded post data
app.use(bodyParser.urlencoded({ extended: true }));

Ligação.

https://github.com/expressjs/body-parser .

E então você pode obter corpo e cabeçalhos no objeto de solicitação raiz. Exemplo

app.post("/posturl",function(req,res,next){
    console.log(req.body);
    res.send("response");
})

A resposta aqui explica muito detalhadamente e brilhantemente, a resposta contém:

Em resumo; O analisador de corpo extrai toda a parte do corpo de um fluxo de solicitação de entrada e o expõe req.bodycomo algo mais fácil de interface. Você não precisa por si só, porque pode fazer tudo isso sozinho. No entanto, provavelmente fará o que você quer e poupará o problema.

---

Para aprofundar um pouco mais; body-parser fornece um middleware que usa nodejs / zlib para descompactar os dados de solicitação recebidos, se estiverem compactados, e stream-utils / raw-body para aguardar todo o conteúdo bruto do corpo da solicitação antes de "analisá-lo" (isso significa que, se você não usaria o corpo da solicitação, apenas perdeu algum tempo).

Depois de ter o conteúdo bruto, o analisador de corpo o analisará usando uma das quatro estratégias, dependendo do middleware específico que você decidiu usar:

• bodyParser.raw () : na verdade não analisar o corpo, mas apenas expõe o conteúdo em buffer até de antes em um tampão no req.body.

• bodyParser.text () : lê o buffer como texto sem formatação e expõe a sequência resultante em req.body.

• bodyParser.urlencoded () : analisa o texto como dados codificados em URL (que é como os navegadores tendem a enviar dados de formulário a partir de formulários regulares definidos como POST) e expõe o objeto resultante (contendo as chaves e os valores) req.body. Para comparação; no PHP, tudo isso é feito automaticamente e exposto $_POST.

• bodyParser.json () : analisa o texto como JSON e expõe o objeto resultante req.body.

Somente depois de definir o req.bodyconteúdo desejável é que ele chamará o próximo middleware na pilha, que poderá acessar os dados da solicitação sem precisar pensar em como descompactá-lo e analisá-lo.

Você pode consultar o github body-parser para ler sua documentação; ele contém informações sobre seu funcionamento.

Vamos tentar manter isso menos técnico.

Digamos que você esteja enviando dados de formulário html para o servidor node-js, ou seja, você fez uma solicitação ao servidor. O arquivo do servidor receberia sua solicitação em um objeto de solicitação. Agora, por lógica, se você console registrar esse objeto de solicitação no arquivo do servidor, deverá ver os dados do formulário em algum lugar, que poderão ser extraídos, mas whoa! você realmente não!

Então, onde estão nossos dados? Como vamos extraí-lo se não estiver presente apenas no meu pedido.

Uma explicação simples para isso é que o http envia os dados do formulário em partes que se destinam a serem montadas quando chegam ao destino. Então, como você extrairia seus dados.

Mas, por que ter esse trabalho de analisar manualmente seus dados em busca de pedaços e montá-los? Use algo chamado "analisador de corpo" que faria isso por você.

O analisador de corpo analisa sua solicitação e a converte em um formato do qual você pode extrair facilmente as informações relevantes necessárias.

Por exemplo, digamos que você tenha um formulário de inscrição no seu front-end. Você está preenchendo e solicitando ao servidor que salve os detalhes em algum lugar.

Extrair o nome de usuário e a senha da sua solicitação é tão simples quanto abaixo se você usar o analisador de corpo.

var loginDetails = {    
    username : request.body.username,    
    password : request.body.password    
};

Então, basicamente, o analisador de corpo analisou sua solicitação de entrada, reuniu os pedaços que continham os dados do formulário e, em seguida, criou esse objeto de corpo para você e o preencheu com os dados do formulário.

Ele analisa o corpo da solicitação HTTP. Isso geralmente é necessário quando você precisa saber mais do que apenas a URL que você acessa, principalmente no contexto de uma solicitação HTTP POST ou PUT PATCH, onde as informações que você deseja estão no corpo.

Basicamente, é um middleware para analisar JSON, texto sem formatação ou apenas retornar um objeto Buffer bruto para você lidar com a necessidade.

Para ter acesso aos dados da publicação, precisamos usar body-parser. Basicamente, o que body-parseré o que permite expressar o corpo e depois analisá-lo em um Jsonobjeto que possamos entender.

Tudo isso é uma questão de conveniência.

Basicamente, se a pergunta fosse ' Precisamos usar body-parser?' A resposta é não'. Podemos obter as mesmas informações do cliente após a solicitação usando uma rota mais tortuosa que geralmente será menos flexível e aumentará a quantidade de código que precisamos escrever para obter as mesmas informações.

É o mesmo que perguntar ' Precisamos usar expresspara começar?' Mais uma vez, a resposta não existe e, novamente, realmente tudo se resume a economizar o trabalho de escrever mais código para fazer as coisas básicas que expressam com o 'embutido'.

Na superfície - body-parserfacilita a obtenção das informações contidas nas solicitações dos clientes em vários formatos, em vez de capturar os fluxos de dados brutos e descobrir em que formato as informações estão, muito menos analisar manualmente essas informações em dados utilizáveis.

Entendimento das Solicitações

Ao receber uma solicitação POST ou PUT, o corpo da solicitação pode ser importante para o seu aplicativo. Obter dados do corpo é um pouco mais complicado do que acessar cabeçalhos de solicitação. O objeto de solicitação que é passado para um manipulador implementa a interface ReadableStream. Esse fluxo pode ser ouvido ou canalizado em outro lugar, como qualquer outro fluxo. Podemos coletar os dados diretamente do fluxo ouvindo os eventos 'data' e 'end' do fluxo.

O pedaço emitido em cada evento 'data' é um buffer. Se você sabe que serão dados de sequência, a melhor coisa a fazer é coletar os dados em uma matriz e, no final, concatenar e especificar.

let body = [];
request.on('data', (chunk) => {
  body.push(chunk);
}).on('end', () => {
  body = Buffer.concat(body).toString();
  // at this point, `body` has the entire request body stored in it as a string
});

Entendendo o analisador de corpo

Conforme sua documentação

Analise os corpos de solicitação de entrada em um middleware antes de seus manipuladores, disponíveis na propriedade req.body.

Como você viu no primeiro exemplo, tivemos que analisar o fluxo de solicitações recebidas manualmente para extrair o corpo. Isso se torna um pouco tedioso quando existem vários dados de formulário de tipos diferentes. Então, usamos o pacote body-parser, que executa toda essa tarefa sob o capô.

Ele fornece quatro módulos para analisar diferentes tipos de dados

• Analisador de corpo JSON
• Analisador de corpo bruto
• Analisador de corpo de texto
• Analisador de corpo de formulário codificado por URL

Depois de ter o analisador de corpo de conteúdo bruto, usará uma das estratégias acima (dependendo do middleware que você decidiu usar) para analisar os dados. Você pode ler mais sobre eles lendo a documentação deles.

Depois de definir o req.bodypara o corpo analisado, o analisador de corpo next()chamará o próximo middleware da pilha, que poderá acessar os dados da solicitação sem precisar pensar em como descompactá-lo e analisá-lo.