Conocer y comprender c贸mo se realizan las conexiones hacia los servidores a trav茅s de internet y sus implicaciones en el desarrollo de servidores

1

Bienvenida y presentaci贸n del curso

2

Qu茅 es Node y c贸mo instalarlo

3

驴Qu茅 son y c贸mo se usan las peticiones HTTP?

4

M茅todos, cabeceras y estados

5

Cuerpo y query de la petici贸n

Crear un servidor HTTP en Javascript, y comenzar a escuchar y responder peticiones desde un cliente .

6

Crear un servidor HTTP desde NodeJS

7

驴C贸mo pueden venir las peticiones?

8

Recibir informaci贸n desde el cliente: Body y Query

9

Informaci贸n contextual: Leer las cabeceras

10

Tipos de respuesta: Vac铆a, plana, con datos y estructurada

11

Respuestas coherentes

12

Servir archivos est谩ticos

13

Errores: C贸mo presentarlos e implicaciones en la seguridad

Comprender y desarrollar la arquitectura b谩sica de un backend en NodeJS, y comunicarse entre m贸dulos

14

Conceptualmente: Rutas, controladores y bases de datos

15

Rutas y capa de red: Responsabilidades y l铆mites

16

Controladores: Definiendo la l贸gica de negocio

17

Almacenando la informaci贸n en una base de datos

Utilizar una base de datos para definir, modelar, almacenar y recuperar la informaci贸n de nuestra aplicaci贸n

18

Tipos de Bases de Datos: Relacionales y No Relacionales

19

Crear y Configurar tu Base de Datos con MongoDB

20

MongoDB: Almacenar y leer datos

21

MongoDB: Actualizar datos

22

MongoDB: Consultar datos

23

MongoDB: Eliminar Datos

24

Gestionar conexiones a la base de datos desde la API

Uso de entidades para crear aplicaciones escalables

25

Escalando la arquitectura: M煤ltiples entidades

26

Relacionando nuestras entidades

27

C贸mo recibir ficheros desde NodeJS

28

Guardar el fichero en el servidor

Conocer el protocolo de websockets, e implementar comunicaci贸n cliente/servidor con SocketIO.

29

WebSockets: Qu茅 son, por qu茅 son interesantes y c贸mo usarlos

30

Manejo de Websockets con NodeJS

31

Conectar la API al servidor de WebSockets

Revisi贸n de lo aprendido, y pr贸ximos pasos

32

Revisi贸n y pr贸ximos pasos

33

Tips para escalar nuestro proyecto

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Respuestas coherentes

11/33
Recursos

Aportes 59

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渟tatus鈥 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 鈥渟uccess鈥 y 鈥渆rror鈥 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 鈥渘etwork/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 鈥渞esponse.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.

鈥淵a 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, 鈥楳ensaje 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 鈥渆standar鈥 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 });
};