Recibir información desde el cliente: Body y Query

A mi me estuvo pasando el JSON como undefined. En caso de que a alguien le pase es posible que tengan el app.use(router) adelante del app.use(bodyparser.json())

Según lei el enrutador debe de ir al final de todo

Actualmente ya bodyparser viene en express, so
podríamos utilizarlo de la siguiente manera…

const express = require('express');
const app = express();
app.use(express.json());
app.use(express.urlencoded({extended : false}));

Si alguien usa postman, es la opción de BODY > raw y de ahi seleccionan JSON(application/json)

En mi caso para levantar el servidor con nodemon tuve que utilizar npx:

npx nodemon server.js

Me dí cuenta que se debe usar bodyParser.json() antes que el router:

Si se hace viceversa

el body queda como undifined.

¿Por que sucede esto?

Podemos ver el código en cada uno de los lenguajes de como envía insomnia la petición:

Como dato curioso:
No es necesario instalar BODYPARSER para poder recibir mensajes tipo JSON o hacer uso de URLENCODED ya que body-parser viene instalado en express.
Link de explicación aquí

Hola a todos: Tengo el siguente error cuando paso el body por url

[Object: null prototype] { text: 'hola' }

Pero cuando paso el valor del extend en true si aparece normal ¿Alguna idea de porque en false no me funciona?

Paso mi código:

const express = require('express');
const bodyParser = require('body-parser');
const router = express.Router();

var app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(router);

router.get('/message', function(req,res){

    res.send('This message is geted');
})

router.delete('/message', function(req,res){


    console.log(req.body)
    res.send('This message is deleted');


})

app.listen(3000)

Si alguno en Windows 10 no puede ejecutar scritps debe usar :
Set-ExecutionPolicy -Scope CurrentUser Unrestricted

asi te da permisos para usar el comando:

nodemon server

Para aquellos que estén viendo este curso en el 2021, en esta forma forma de pasear la entrada ha cambiado:

usen:

app.use(express.json());
app.use(router);

No usen sudo si estan en windows

npm install -g nodemon

Una manera mas condensada de definir los diferentes métodos HTTP para una misma ruta puede expresarse de la siguiente manera:

router.route("/")
.all((request, response, next) => {
   //Puede funcionar como middleware
    console.log("Accedo a la ruta /")
    next()
})
.get((request, response) => {
    response.send("Hola desde get")
})
.post((request, response) => {
    response.send("Hola desde post")
})
.delete((request, response) => {
    response.send("Hola desde delete")
})

Por que tenemos que hacer parse del body?

• Por que el request es enviado en forma binaria “stream” y hay que pasar este a String => de ahi parser "compilar"
  Usamos el paquete body-parser en 2021?
• No, ahora el propio express con el metodo express.json() te hacer el parser
  SOURCE
  Bodyparser: https://expressjs.com/en/resources/middleware/body-parser.html
  Express.json() : https://www.geeksforgeeks.org/express-js-express-json-function/

Express ya incluye bodyParser en su módulo asi que ya no es necesario instalarlo. recuerden que express.Router funciona como un middleware que tiene las rutas y por eso es necesario que el codigo vaya antes de este middleware.

const express = require('express');
const router = express.Router();

const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: false }))
app.use(router);

router.get('/', (req,res) => {
    res.send('Lista de mensajes (hola desde get)');
});

router.post('/', (req,res) => {
    console.log(req.body);
    console.log(req.query);
    res.send(`Mensaje añadido (${req.body.text} desde post)`);
});

router.put('/', (req,res) => {
    res.send('Mensaje editado (Hola desde put)');
});

router.patch('/', (req,res) => {
    res.send('Mensaje editado (Hola desde patch)');
});

router.delete('/', (req,res) => {
    res.send('Mensaje borrado (Hola desde delete)');
});

app.listen(3000, () => {
    console.log('Telegram listening on port 3000')
});```

tengo hecho todo igual hasta el min. 6 aprox. pero en la consola me sale undefined

bodyParser se encuentra deprecado actualmente, ya viene directamente en express

Configuración de Nodemon en Computador Windows sin permiso de administrador
En un blog (https://www.blai.blog/2019/05/habilitar-ejecucion-de-archivos-ps1-en.html), Blai señala una forma sencilla se ejecutar.
Se ha modificado la ruta del servidor local porque se señala que son direcciones peligrosas

1. Instala Nodemon normalmente
En una terminal de usuario ejecutar
npm install -g nodemon
Si pruebas ejecutar nodemon se emite un mensaje que no se puede cargar archivo .ps1 porque la ejecucion de scripts esta deshabilitada en el sistema.
2. Verifica permisos de ejecución de scripts
Ejecutar
Get-ExecutionPolicy -list
Se recibe la lista, donde se observa que no se han definido los permisos de ejecución
Scope ExecutionPolicy
----- ---------------
MachinePolicy Undefined
UserPolicy Undefined
Process Undefined
CurrentUser Undefined
LocalMachine Undefined

3. Cambia los permisos del usuario actual
Ejecuta
Set-ExecutionPolicy -Scope CurrentUser unrestricted
y luego compruebalo ejecutando
Get-ExecutionPolicy -list
La lista muestra ahora que se ha cambiado el permiso de ejecución para el usuario actual
Scope ExecutionPolicy
----- ---------------
MachinePolicy Undefined
UserPolicy Undefined
Process Undefined
CurrentUser Unrestricted
LocalMachine Undefined

4. Verifica Nodemon
Ejecuta nodemon normalmente
nodemon servername
Se verifica su funcionamiento correcto
[nodemon] 2.0.6
[nodemon] to restart at any time, enter 'rs'
[nodemon] watching path(s): *.*
[nodemon] watching extensions: js,mjs,json
[nodemon] starting 'node servername.js'
la aplicacion esta escuchando en host local,puerto 3000
cambio en un archivo
[nodemon] restarting due to changes...
[nodemon] starting 'node servername.js'
la aplicacion esta escuchando en host local, puerto 3000
`
Espero que les sriva de ayuda.
Saludos

ahora me aparece el

bodyparser.json()

como deprecated, en su lugar pueden usar

express.json()

Despues de la version 4.16.0 de express ya no es necesario utilizar body-parser, este ya viene integrado en express.

Debemos usarlo de la siguiente manera:

app.use(express.urlencoded({extended: false})); app.use(express.json());

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

//middleware
// app.use(bodyParser.json());
// app.use(bodyParser.urlencoded({ extended: true }));

//Middleware import Express
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

//routes
app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.post('/signup', (req, res) => {
  console.log(req.body);
  res.send('Thank you for signing up!');
});

app.get('/data',function (req, res) {
  res.json({
    'name': 'John Doe',
    'age': 35,
    'profession' : ['Web Developer', 'Web Designer','Java','Php']
  })
});

//listen Server up
app.listen(3000, () => {
  console.log('Example app listening on port 3000!');
});

Ya no es necesario instalar el módulo body-parser, si estas usando una version de Express 4.16 o mayor.
Sin instalarla puedes usar el middleware que viene ahora incorporado en Express:
app.use(express.json());

¿Es necesario instalar el módulo body-parser?

En vez de usar bodyParser, puedes usar una funcionalidad de express que sirve para lo mismo:

app.use(express.json());

este middleware ponlo encima del middleware de las rutas para que primero haga el parseo antes de llegar a las rutas.

Asì:

app.use(express.json());
app.use(router);

ya no es necesario body-parser actualmente (sale como deprecated)

app.use(express.json()); //alternativa a body-parser antes: bodyParser.json()
app.use(express.urlencoded({extended: false}));

Aclarando dudas clase a clase, GRACIAS!!!

Para no instalar bodyParser, también se puede hacer con express

app.use(express.json());

En version actual de express seria necesario este codigo
app.use(express.json())
y ya no seria necesario el bodyParser

<h2> Recibir información desde el cliente: Body y Query </h2>

Configurar servidor

// Convierte la informacion del body en un objeto json
app.use(express.json()); 

// Extrae los datos de la url
app.use(express.urlencoded({ extended: true }));

localhost:3000/

La informacion se envia a traves del body

router.get('/message', function (req, res) {
    console.log(req.body);
    res.send('Extraer mensajes del body');
})

Resultado

{ edad: '22' }

Endpoint

localhost:3000/message?nombre=Angel&Apellido=Roque Ayala

router.get('/message', function (req, res) {
    console.log(req.query);
    res.send('Extraer informacion de un query');
})

Resultado en consola

{ nombre: 'Angel', Apellido: 'Roque Ayala' }

Endpoint

localhost:3000/message/789

router.get('/message/:id', function (req, res) {
    console.log(req.params);
    res.send('Extraer parametros');
})

resultado en consola

{ id: '789' }

Muy buen curso, me encanta… 😃
Prácticas:

Siempre que muestro el contenido de la cabecera en el método POST del modo console.log(req.body) me muestra “undefined”. No he podido lograr ver la cabecera del metodo POST.

Archivo Routes 😃

const {Router} = require('express');
const {home,message} = require('./controllers')
const routes = Router();

routes.get('/home',home)
routes.post('/message', message)

module.exports = routes

Archivo Controller 😃

home = (req, res)=>{
    res.send('ok').status(200)
}

message = (req, res)=>{
    const {Hola} = req.query
    const { text } = req.body
    console.log(text);
    res.send(`${text}, ${Hola}`).status(200)
    
}

module.exports = 
{
    home,
    message
}

Archivo Server 😃

const express = require('express');
const routes = require('./routes')
const app = express();
app.set('port', 3000)
app.use(express.urlencoded({extended: false}))
app.use(express.json())
app.use(routes)

app.listen(app.get('port'), ()=>{
    console.log(`port in ${app.get('port')}`);
})

Hola, tambien se puede añadir el mensaje de esta forma

res.send(`Mensaje ${req.body.text} eliminado correctamente`);

Tengo entendido que el body-parser ya viene incluido en express, no es necesario instalarlo.
Se puede usar como:

app.use(express.json());
app.use(express.urlencoded({ extended: false }))

Y siempre debe ponerse antes de usar el middleware de rutas porque los middlewares se usan en orden y si no está parseado el body antes de llegar a las rutas aparecerá como indefinido.

Tambien se puede ocupar los template string para que imprima el mensaje de manera un poco más bonita :

router.delete('/mensajes', function (req, res) {
    console.log(req.query); // Esto permite que la url sea aceptado como body
    console.log(req.body);  // Imprime el valor de body
    res.send(`Mensaje ${req.body.text} Eliminado`);
});

Ocupando ${} y comillas tipo ``

Body-parser: es una extensión que nos permite trabajar con el body de la petición de forma sencilla.

Cuando tengas problemas al cargar las instalaciones de los paquetes

ejecuta en PowerShell
ejecuta->Set-ExecutionPolicy -Scope LocalMachine unrestricted

ejecuta S o O para todo

si no queda despues de la correccion
ejecuta ->Set-ExecutionPolicy -Scope CurrentUser

abrindo el canal con el valor 1

espero les sirva dea yuda

Para los que están viendo en 2022 (espero actualicen este curso) ya no se necesita bodyparse, solo usen el json normal. Ejemplo:

app.use(express.json());

Actualmente para acceder al body podemos hacerlo sin instalar ninguna dependencia, y agregando la siguiente linea:

app.use(
express.urlencoded({
extended: true,
})
);

a día de hoy express ya cuenta con el tema del body y el url encoded en su librería 😁

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

Puedes hace peticiones desde VSC con la extension REST Client:
Sobre las direcciones URL aparecera un opcion para lanzar la peticion.
Lo escribes en un documento de extensión .http:

GET http://localhost:3000/message

###

POST http://localhost:3000/message?name=Max&lastname=Díaz
Content-Type: application/json

{
    "text":"Hola, Max"
}

Desde postman envio por urlencoded y recibo la siguiente información:

la aplicación esta escuchando en http://localhost:3000
[Object: null prototype] { text: 'hola' }```

¿Qué es el [Object: null prototype] ?

Solo para quienes vengan del futuro , Express integra boyd-parser como middleware, por lo que no es necesario instalar body-parser,

por lo que podremos hacer :

	app.use(express.json());
	app.use(express.urlencoded({extended: true } ));

Cree un miniChat con ayuda de las querys: 😄

const mensajes = ['Jhon: Hola, andrea!','Andrea: ¿como estás?']

router.post('/',(req,res)=>{
    let new_mesage = req.query.message
    mensajes.push(new_mesage)
    res.send(mensajes)
    console.log(req.body.message)
})

excelente explicación, gracias!!

const express =  require('express');
const bodyParser = require('body-parser');
const router = express.Router();

var app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(router);

router.get("/", function(req, res){
    res.send("peticion de get");
  });

router.post("/", function(req, res){
    res.send("peticion de post");
  });

router.patch("/",function(req, res){
    res.send("peticion de patch");
  });

router.delete("/",function(req, res){
    res.send("peticion de delete");
  });

app.listen(3000);
console.log(" la aplication esta escuchando en el port http://localhost::3000");

¿Alguien está trabajando con Postman en lugar de con Insomnia? Postman es el que conocía de antes y lo estoy probando pero parece ser que me falta algo a la hora de mandar la info como JSON, si que me salta el console y/o el res.send del router.post, pero tanto req.query como req.body me aparecen vacías, no consigo que se vean los valores que le paso (y los headers están como application/json).

¿Algún consejo?

Esto esta desactualizado. Con

app.use(express.json());

podemos realizar lo mismo, ojo debe ir antes del aplicar el router.

Tomando lo que aprendí en cursos posteriores y este link de StackOverflow, desde la versión 4.16.0 de express en adelante no se usa body-parser sino que ese middleware viene en express y se invoca usando

app.use(express.json())

Para definir el req.body desde curl se debe utilizar -H para definir el tipo de dato y -d para definir el contenido del body

curl -X 'POST' **localhost**  -H "Content-Type: application/json" -d '{"test1":"texto1","test2":"texto2"}'

Leyendo un poco parece que las últimas versiones de express ya traen todo lo que son los middleware de manejo de req

https://stackoverflow.com/questions/55692084/what-is-the-difference-between-nodes-bodyparser-and-expresss-urlencoded-middle

Carlos eres un crack!! un abrazo desde Barcelona, Catalunya, España!

No me gusto que Insomnia sea pago asi que al final termine utilizando Postman. Funciona para casi lo mismo.

Muy buena clase !!

Es utilizado cunado se requiere algún recurso del servidor por ejemplo un CSS, JS etc, en les caso de una API’s es utilizado para listar información. los estatus son

Es utilizado cuando se quiere crear agregar información al servidor por ejemplo el envio de un formulario los estados son

Es utilizado cuando se quiere actualizar información del servidor

Es utilizado cuando se quiere actualizar una sola parte de la información del servidor.

Es utilizado cuando se quiere eliminar información del servidor.

A mi me dio erro, diciendo que el archivo no esta firmado digitalmente, si alguien mas le pasa les dejo estos 2 comandos par resolverlo

get-ExecutionPolicy -list
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

A los que les genera un error de versión antigua o deprecated, les recomiendo ver el ejemplo de: https://github.com/expressjs/body-parser

npm WARN deprecated [email protected]: One of your dependencies needs to upgrade to fsevents v2: 1) Proper nodejs v10+ support 2) No more fetching binaries from AWS, smal
ler package size
/Users/tom/.npm-global/bin/nodemon -> /Users/tom/.npm-global/lib/node_modules/nodemon/bin/nodemon.js

Genial super claro ! !

nodemon se usa en el curso de fundamentos de nodejs

vamos bien

Estupenda clase! la recomiendo

Muy bueno, entonces:

// Instalar
sudo npm install -g nodemon

// Ejecutar
 nodemon archivo.js

Por el momento…excelente!!

router.post('/message', function (req, res){
    console.log(req.query);
    console.log(req.body);
    res.send(`Mensaje ${req.body.text} añadido correctamente`)
})

Hermosa esta clase definitivamente 😄

yo no podía instalar nodemon pero con este comando ya pude

npm install -g nodemon

Excelente Clase

al ejectuar nodeman server , me dice que la ejecucion de scripts esta desabilitada alguien sabe como puedo solucionar eso ?

Genial

const express = require('express');
const router = express.Router();
const bodyParser = require('body-parser')

var app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(router);

router.get('/message', function(req, res){
    res.send('Lista de mensajes');
});

router.delete('/message', function(req, res){
    console.log(req.body);
    console.log(req.query);
    res.send('Mensaje ' + req.body.text + ' eliminado correctamente');
});

app.listen(3000);
console.log('La aplicación esta escuchando en http://localhost:3000')```

😉

router.delete('/message', (req, res) => {
    console.log(req.query);
    console.log(req.body);
    res.send(`Mensaje ${req.body.text} añadido correctamente`);
});

…age=15 ;v

cool

para los que les paso lo mismo que a mi los servidores de node se paran con
control + c

• Instalamos el body parser, que es un modulo de express que nos permite trabajar con el body de la petición de manera facil

  $ npm i body-parser

• Agregamos el modulo de body parser a nuestro servidor

const express = require("express");
const bodyParser = require("body-parser");
const router = express.Router();

var app = express();
app.use(bodyParser.json());//siempre hay que indicar tipo de información que recibiremos
app.use(router);

El body lo encontraremos siempre en la request, para esto realizamos un:

console.log(req.body);

para asegurarnos que estamos recibiendo el body correctamente.

Estos datos son los que recibimos mediante el url que se está solicitando al servidor por ejemplo

http://localhost:3000?orderBy=id&age=15

En el cual estamos recibiendo que queremos la orden por id y la edad de 15.

Para mostrar estoy en consola lo realizamos también a través de

console.log(req.query);

router.post("/", function (req, res) {
  console.log(req.query);
  console.log(req.body);
  res.send(`Mensaje ${req.body.text} añadido`);
});

Me genera este error al instalar nodemon

PS C:\SpdSolutionApi> nodemon server

nodemon : No se puede cargar el archivo C:\Users\XXXXX\AppData\Roaming\npm\nodemon.ps1 porque la ejecución de scripts está deshabilitada en este sistema.

Para obtener más información, consulta el tema about_Execution_Policies en https:/go.microsoft.com/fwlink/?LinkID=135170.
En línea: 1 Carácter: 1

• nodemon server

•   + CategoryInfo          : SecurityError: (:) [], PSSecurityException
    + FullyQualifiedErrorId : UnauthorizedAccess
  

PS C:\SpdSolutionApi> ``

express.urlencoded([options])
This middleware is available in Express v4.16.0 onwards.

This is a built-in middleware function in Express. It parses incoming requests with urlencoded payloads and is based on body-parser.

Yo recibí 1 objeto y esto:

[Object: null prototype] { text: 'hola' }

Podeis tambien destructurar el req y asignarle el valor que querais: Ejemplo:

app.post('/post', function(req, res){
    const {body:{ Hola: theBody }} = req;
    const {query: {age: theQuery}} = req;

    res.json({
        "METHOD": "POST",
        "use": "It creates a new Object in the server",
        "example":`This is the body: ${theBody} and this is the query: ${theQuery} Post status 👍`
    })
})

Tarde pa, pero se agradece un toque 😎

si usas la terminal de ubuntu en windows, para poder utilizar el comando nodemon deberás instalar nodemon de esta forma tambiñen

npm i nodemon -g

También es posible mandar la respuesta en JSON sin el bodyparser. Usando los métodos de respuesta, que muestra la documentación de express.

router.get('/', function(req, res) {
    res.json('Hola desde get');
});

Este método envía una respuesta (con el tipo de contenido correcto) que es el parámetro convertido a una cadena JSON usando JSON.stringify () .

El parámetro puede ser de cualquier tipo JSON, incluido objeto, matriz, cadena, booleano, número o nulo, y también puede usarlo para convertir otros valores a JSON.

res.json(null)
res.json({ user: 'tobi' })
res.status(500).json({ error: 'message' })

referencia: https://expressjs.com/en/4x/api.html#res.json

Error en la terminal de vsc:

Solución:
1 - Si no lo tengo instalado, instalo node.js del siguiente link https://nodejs.org/.(Le doy siguiente y siguiente hasta que finalice) 2 - Abro Visual studio code y abro la terminal, apretando control + ñ o en el menu superior poniendo ver / terminal 3 - Luego, instalamos SASS con el siguiente comando npm install -g sass 4 - En windows apretamos inicio y buscamos windows powershell, le damos click derecho y lo abrimos como administrador 5 - En la consola escribimos Set-ExecutionPolicy Unrestricted, le damos enter y cuando nos deje escribir de nuevo nos va a pedir que confirmemos, le ponemos una S y le damos enter. De esta manera habilitamos la ejecución de los scripts 6- Una vez terminado todos los pasos anteriores ya podemos cerrar windows powerShell y en visual studio code nos va a dejar ejecutar todos los comandos del curso