Respuestas coherentes

La verdad, es uno de los profesores que se le entiende perfectamente. Se disfruta la clase!

Profesor Carlos Hernandez ahora hace parte de mi stack de grandes profesores de Platzi, creo que este curso deja muy claro el potencial y uso de nodeJS con Express.

Estoy amando este curso. Mis anteriores acercamientos a Node no habían salido bien

La verdad que estos son mis primeros pasos con el backend. Y me resulta super desafiante y asimilando los conceptos nuevos, pero sobre todo ayuda mucho el tener un profe tan claro con las ideas y conceptos. 5/5

![](

Creé este modelo para enviar mis respuestas. Realmente es una manera muy buena de enviar una respuesta estandar a nuestro cliente 😄

Otra forma de setear el valor by default de la variable “status” es hacerlo directamente en los parámetros de la función

exports.success = function(req, res, message, status = 200) {
    res
        .status(status)
        .send({ message: message })
}

Código del curso escrito en EcmaScript:
server.js

import express from "express";

import { success, error } from "./network/response.js";

const app = express();

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

app.get('/message',(req,res)=>{
    console.log(req.headers)
    res.header({
        "Custom-header":"Nuevo valor personalizado"
    });
    success(req, res, 'Lista de mensajes');
});

app.post('/message',(req,res)=>{
    console.log(req.query);
    if(req.query.error == 'ok'){
        error(req, res, 'Error simulado', 400);
    } else{
        success(req, res, 'Creado correctamente', 201);
    }
});

app.listen(3000);

console.info('La app esta escuchando en http://localhost:3000');

network/response.js

function success(req, res, message, status = 200) {
    res.status(status).send({
        error:'',
        body: message,
    });
}

function error(req, res, message, status = 500) {
    res.status(status).send({
        error: message,
        body: '',
    });
}


export { success, error }

Esto igual puede ayudar a definir un estándar en su API: Standar JSON:API .

Genial… así tenemos mayor control de las respuestas
Simulé el error de esta manera:

router.post('/', (req,res) => 
    req.body.status 
    ? response.success(req.body,res,false,"Petición POST recibida con éxito")
    : response.error(req.body,res,false,"Error en la respuesta")
)

Le paso un objeto true o false llamado status

Se disfruta muchísimo las clases con este profesor, si alguien en Platzi está leyendo esto: por favor más cursos con Carlos Hernandez!

Como dirían en mi país, este profe se ve que sabe lo que hace !!

Antes odiaba Javascript, ahora quiero utilizarlo en todos lados :v

woo de esta manera daremos mejores respuestas para el cliente

Aqui tienen una liga, para leer acerca de los modulos en node.js

https://www.tutorialsteacher.com/nodejs/nodejs-module-exports

Manejar los errores usando un estándar nos evita tener problemas de coherencia cuando trabajemos muchos endpoints.

Porque se usa exports.function y no module.exports = function

Además de colocar condicionales para validar si hay status, también podemos darle un valor predefinido al status desde su definición en los parametros de la función y así va a agarrar ese valor si no enviamos un status:

exports.success = (req, res, message, status = 201)

Muy buen profesor

Excelente profesor, vale la pena el curso!

exports.success = function(req, res, message, status){
	res.status(status || 200).send({
		error: '',
		message: message
	});
}

exports.error = function(req, res, error, status){
	res.status(status || 500).send({
		error: error,
		message: ''
}

Buenas gente,

Recomiendo usar para las funciones “success” y “error” parámetros nombreados, ya que empeizan a tener mas de dos argumentos y así es más fácil de gestionarlos e incluso inicializarlos por defecto.

export const success = ({ req, res, body = {}, status = 200 }) => {
  res.status(status).send({
    body,
    status,
  });
};

export const error = ({ req, res, body = {}, status = 400 }) => {
  res.status(status).send({
    body,
    status,
  });
};

  const { error } = req.query;
  error === "ok"
    ? error({ req, res, body: { error: "Hubo un error" }, status: 400 })
    : success({ req, res, body: { name: "manuel", age: 33 }, status: 201 });

Respuestas coherentes

Debemos estandarizar las respuestas que se enviaran al cliente.

En el archivo “network/response.js”

exports.success = function (req, res, message, status) {
    res.status(status || 200).send({
        error: '',
        body: message,
    })
}

exports.error = function (req, res, error) {
    res.status(status || 500).send({
        error,
        body: '',
    })
}

Ejemplo de uso del objeto response

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

router.get('/message', function (req, res) {
    response.error(req, res, 'Descripcion del error')
})

"que bien hecho esta esto mijin…!!! "

Ojala hubieran más cursos de Carlos

Me ha encantado!

Este. profesor es super super super super bueno.

Jugando con los queries, body y la funcion de respuesta:

Es clara la forma de explicar y funcional, genial ! 😄

por si se equivocan escribiendo :
http://localhost:3000/message?error=ok

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

var app = express();

const port = 3000;
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(router);

router.get('/message', (req, res) => {
  response.success(req, res, "Respondiendo desde el get")
});


router.post('/message', (req, res) => {
  console.log(req.query);
  console.log(req.body);
  if (req.query.error == "ok") {
    response.error(req, res, "error simulado", 400);
  } else {
    response.success(req, res, "Creado correctamente", 201);
  }
});
app.listen(port, () => console.log(`Se a iniciado el servidor en el puerto${port}`));

¡Hola! Quería comentarles que cuando estamos manejando objetos que hacen referencía a alguno de los atributos que vienen de la función y la llave es igual al valor dentro del objeto, desde cierta versión de ECMA que no recuerdo, el hacer esto:

.send({
    error : error,
    message: ""})
}

Es redundante, pueden dejarlo así:

.send({
    error ,
    message: ""})
}

Con node pueden fácilmente dejarlo de la segunda forma, podrán encontrar programas que estén escritos de la primera forma pero si se cuenta con las últimas versiones de node, funcionará de maravilla si lo dejan de la segunda forma.

En caso de que no pasemos un mensaje a la función succes, podemos dejar uno predeterminado, así tambien podemos prevenir errores al momento de implementar la función y que se nos olvide pasar un message 💡

const success = (req, res, message) => {
  //foo
  res.send(message ? message : "response default message");
};

const success = (req, res, message = "response default message") => {
  //foo
  res.send(message);
};

De las dos formas funciona, a mi me gusta más la primera 😄

creamos una carpeta de nuestro directorio con nombre network para trabajar todo lo que sea conecciones a la api, una vez hecho esto creamos un archivo llamado “response.js” para responder a las peticiones con funciones difinidas

response.js

exports.success =  (_req, res, message) => {
    res.send({
        "error": "",
        "body": message
    });
}

exports.error = (_req, _res) => {
    //
}

ahora importamos esta carpeta y cambiamos las response en nuestro server

server.js

const response = require('./network/response');

router.get('/message', (req, res) => {
    console.log(req.headers);
    res.header({
        "custom-header": "Nuestro valor personalizado",
    });
    response.success(req, res, 'Lista de mensajes');
});

router.post('/message', (req, res) => {
    console.log(req.query);
    console.log(req.body);
    response.success(req, res, 'Creado corretamente');
});

Buenísimo eso de crear funciones para mostrar las respuestas exitosas y erróneas. Es una buena practica para estandarizar las respuestas pues en Node con Express uno tiende a crear diversas respuestas (a veces vacías) en cada una de las peticiones, lo que hace que sea tedioso leer el código y los logs.

Una forma en que me gusta estructuras las respuestas es así:

{
	success: true,
	message: "Movies listed",
	data: { moviesList }
}

{
success: false,
	error: errorMessage
}

Genial!, genial esta el curso

Hasta ahora, todo claro

Muy buena clase

Yo si me las estoy viendo muy dificil, vengo aprendiendo Front End desde cero y este es mi primer contacto con el back, me estoy volviendo loco

Este profesor es la hostia tío

Una observación para la clase, no es buena práctica usar doble igual == en JS debido a los tipados débiles del lenguaje, la buena práctica es usar el triple igual ===

Me gusta como explicas, se te entiende bien todo.

“Ya sabemos como responder a una petición HTTP de todas las formas posibles pero claro si respondemos de todas la formas posibles cada petición será respondida de una forma diferente y eso es super incoherente en nuestra api, en nuestro backend, lo que queremos es que sea fácil de usar y de entender.”

Dinámico!

estandarizar el status de respuesta y tener doble check

server.js

const express = require('express');
const bodyParser = require('body-parser');
const router = express.Router();
const response =  require('./network/response');
var app =  express();

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

app.get('/', (req, res) => {
     res.header({
        'custom-header' : 'Valore personalizado para el cliente'
    })
    response.success(req, res, 'Esto es lista de mensajes');
});
app.post('/pruebas', (req, res) => {
    console.log(req.query);
    console.log(req.body);
    res.send('Datos regresados '+ req.body.text +' correctamente');
});
app.post('/', (req, res) => {
    console.log(req.query);
    if (req.query.error == 'ok')
        response.error(req, res, 'Error simulado',401);
    else
        response.success(req, res, 'Creado correctamente', 201);
});

app.delete('/delete', (req, res) => {
    console.log(req.query);
    console.log(req.body);
    res.status(200).send([{
        'error': null,
        'body': 'Ejecutado correctamente!'
     }]);
});
app.listen(3000);
console.log('La aplicación esta escuchando en pueto:3000');

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

var response = require('./network/response')

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

router.get('/message', function(req, res){
    console.log(req.headers);
    res.header({
        "custom-header": "Nuestro valor personalizado"
    })
    response.success(req, res, 'Lista de mensajes');
});

router.post('/message', function(req, res){
    console.log(req.query);
    if(req.query.error == "ok") {
        response.error(req, res, 'Error simulado', 400)
    } else {
        response.success(req, res, 'Creado correctamente', 201);
    }
});

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


exports.success = function(req, res, message, status) {
    res.status(status || 200).send({
        error: ' ',
        body : message
    });
}

exports.error = function (req, res, message, status) {
    res.status(status || 500).send({
        error: message,
        body : ' '
    });
}

exelente profesor quiero mas cursos de el

router.post('/message', (req, res) => {
    console.log(req.query);
    if (req.query.error =='ok') {
        response.error(req, res, 'Error al crear desde server', 401);
    } else {
        response.success(req, res, 'Creado correctamente desde server', 201);
    }

exports.success = (req, res, message, status) => {
    res.status(status || 200).send({
        error: '',
        body: message});
}

exports.error = (req, res, message, status) => {
    res.status(status || 500).send({
        error: message,
        body: ''});
}

exports.success = function (request, response, message, location, status) {
  console.log(request.query);
  response
    .status(status)
    .header({
        location,
        status: 'true'
    })
    .send(message);
}

exports.MyError = function (request, response, error, status) {
  response
    .status(status)
    .header({
        error
    })
    .send('Oops cometiste un error, revisa tus headers');
  console.log(error)
}

Muy buena clase,
escrito de otra forma =>

const success = (request, response, message, status) => {
  response.status(status || 200).send({
    error: '',
    body: message
  });
}

const error = (request, response, message, status) => {
  response.status(status || 500).send({
    error: '',
    body: ''
  });
}

module.exports = {
  success,
  error
}

Hasta ahora va una tercera parte del curso y ya tengo clara la calificación para Carlos Hernandez… es 5/5.

Espectacular este profe, de lo mejor que vi en la escuela de desarrollo web. Gracias!

Excelente maestro, de la ruta de Javascript es de los profes que mas me ha gustado

Práctica:

Hola, de pronto me pueden ayudar… al momento estoy ejecutando pero no logra llamar al metodo

response.success(req, res, ‘Mensaje predeterminado…’)

Al parecer desde insomnia… tarda demasiado.

Me gusta la forma en que explica. Y es buena forma de implementar las response, de esta forma podemos seguir un “estandar” en todo nuestro backend

me gustaria saber como poder ver todos los cursos que hace el gran Carlos Hernández, para mi el mejor profesor de platzi

/**
 * @param {Response} res - Objeto Response de Express
 * @param {string|string[]} data - Los datos que seran enviado en la respuesta.

 */
exports.success = (res, data) => {
  res.json(data);
};

/**
 * @param {Response} res - Objeto Response de Express
 * @param {number} statusErrorCode - Codigo de error 4XX
 * @param {(string)} [error] - Texto del error

 */
exports.error = (res, statusErrorCode, error) => {
  res.status(statusCode).send({ error });
};