Tu primera experiencia con Node.js

1

¿Dónde aprender backend con Node.js actualizado?

2

Todo lo que aprenderás sobre backend con Node.js

3

¿Qué es Node.js?

4

¿Qué es Node.js y para qué sirve?

5

Diferencias entre Node.js y JavaScript

6

Resumen: Diferencias Nodejs y Javascript

7

Instalación de Node.js

8

Arquitectura orientada a eventos

9

Node.js para la web

Manejo y uso de Streams con Node.js

10

Introducción a streams

11

Readable y Writable streams

12

Duplex y Transforms streams

Uso de utilidades de Node.js

13

Sistema operativo y sistema de archivos

14

Administrar directorios y archivos

15

Consola, utilidades y debugging

16

Clusters y procesos hijos

Crea tu primer proyecto en Express.js

17

¿Qué es Express.js y para qué sirve?

18

Creando tu primer servidor con Express.js

19

Request y Response Objects

Aprende a crear un API con REST

20

Anatomía de una API Restful

21

Estructura de una película con Moockaru

22

Implementando un CRUD en Express.js

23

Métodos idempotentes del CRUD

24

Implementando una capa de servicios

Cómo conectarse con librerías externas en Express.js

25

Creación de una BD en MongoAtlas

26

Conexión a MongoAtlas una instancia de MongoDB

27

Conexión con Robot3T y MongoDB Compass a una BD

28

Implementación de las acciones de MongoDB

29

Conexión de nuestros servicios con MongoDB

Conoce como funcionan los Middleware en Express.js

30

¿Qué es un middleware? Capa de manejo de errores usando un middleware

31

Manejo de errores asíncronos y síncronos en Express

32

Capa de validación de datos usando un middleware

33

¿Qué es Joi y Boom?

34

Implementando Boom

35

Implementando Joi

36

Probar la validación de nuestros endpoints

37

Middlewares populares en Express.js

Implementa tests en Node.js

38

Creación de tests para nuestros endpoints

39

Creación de tests para nuestros servicios

40

Creación de tests para nuestras utilidades

41

Agregando un comando para coverage

42

Debugging e inspect

Despliega tu primera aplicación en Express.js

43

Considerando las mejores prácticas para el despliegue

44

Variables de entorno, CORS y HTTPS

45

¿Cómo implementar una capa de manejo de caché?

46

¿Cómo contener tu aplicación en Docker?

47

Despliegue en Now

Conclusiones

48

¿Qué aprendiste en este curso?

Request y Response Objects

19/48

Lectura

El objeto req (Request) en Express representa el llamado HTTP y tiene diferentes propiedades del llamado, como la cadena de texto query (Query params), los parámetros de la URL (URL params), el cuerpo (Body), los encabezados (HTTP headers), etc.

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 119

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Uy, yo creo que esta sección amerita una explicación mejor. Creo que queda muy técnico y es muy fácil perderse en esta explicación. Además hablan de los middlware como si fuera un tema ya visto.

Esta clase es realmente sencilla:

El request trae todos los datos del cliente hacia el servidor (client => request => server).
El response se usa para cargar la respuesta que se devuelve al cliente (server => response => client)

Aquí mi solución.

básicamente no está nada explicado, habla de cosas que no ha mencionado con anterioridad, como middleware, request.params, req.body, todo explicado muy minimo y sin ejemplos practicos, termino sin entender nada esta seccion.

Tengo la costumbre de que aunque sea un programa sencillo cuyo input controle, le meto validaciones

const express = require('express');

const app = express();

const { config } = require('./config/index');

app.get('/birthday', function (req, res) {
  if (req.query == {}) {
    res.send(`
      <h1> Debes enviar tu fecha de nacimiento por GET con los siguientes parametros</h1>
      <ul>
      <li> day</li>
      <li> month</li>
      <li> year</li>
      </ul>
    `);
  }

  const { year } = req.query;

  if (year == undefined) {
    res.send(`
      <h1> Al menos envia el año ?year=1900</h1>
     
    `);
  } else if (!Number.isInteger(year) && year < 1000) {
    res.send(`
      <h1> El parametro año debe ser un número y debe ser de 4 digitos por ejemplo ?year=1900</h1>
     
    `);
  }

  let result =
    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) ? true : false;

  const anoB = result ? 'Si' : 'NO';

  res.send(`<h1> Tu año de nacimiento ${anoB} es bisiesto</h1>`);
});

app.get('/json', function (req, res) {
  res.json({ hello: 'world' });
});

app.listen(config.port, function () {
  console.log(`Listening localhost:${config.port}`);
});```

Pequeño resumen y explicación para aquellos que no están familiarizados con las peticiones y respuestas HTTP:
Un servidor/API en general se encarga de 2 cosas: recibir peticiones (req | request) desde el cliente y devolver una respuesta (res | response) al mismo cliente.

  • Un middleware es una herramienta que va a recibir las peticiones en formatos HTML, escritos de forma un poco compleja (incluso encriptados para conexiones HTTPS) y las va a transformar en objetos faciles de manejar (req y res) que recibimos en nuestro código. Además, el middleware también va a tomar nuestra respuesta (ejemplo: res.send(“Hello”)) y la va a transformar en respuestas HTML mas complejas y devolverlas al navegador. En resumen, el middleware hace una tarea de parse para simplificar el manejo de respuestas y peticiones HTML.

  • Peticiones (req | request):
    Principalmente hay 2 tipos de peticiones: GET y POST
    GET es la mas simple y se ejecuta cada vez que intentamos acceder a un URL por ejemplo:
    https://platzi.com/home
    Alli, el navegador hace una petición GET de la ruta /home
    Las peticiones GET también pueden contener variables por ejemplo en localhost/user/?id=1 se va a hacer una petición a la ruta /user/ enviando la variable id = 1.

    POST es mas compleja y permite enviar datos desde el cliente hasta el servidor de diferentes tipos, por ejemplo texto plano, JSON, binarios, etc. Este tipo de petición contiene cabeceras (Headers) que permiten decirle al middleware el tipo de datos que tiene que tratar para hacerlo llegar a nuestra aplicación.

  • Respuestas (res | response):
    Es la respuesta que va a ser enviada desde el servidor hasta el cliente. Esta respuesta puede ser un contenido html, un binario, un JSON, etc. Por ejemplo cuando hacemos el GET de https://platzi.com/home, la respuesta va a contener el html que va a ser cargado en el navegador para visualizar el home de platzi. Al igual que cuando accedemos a un curso, hay respuestas de tipo binario que se hacen para cargar los videos. etc.

Espero este resumen les ayude un poco dado que estos temas son un poco mas profundos.

Yo decidi hacerlo con el metodo post para poder tener un formulario. Aca esta mi solucion:

<const express = require('express');
const bodyParser = require('body-parser');
const app = express();
const { config } = require('./config/index');
app.use(bodyParser.urlencoded({extended:true}));

const formulario =
  '<h1>Ingrese un año</h1>' +
  '<form method="post" action="/bisiesto">' +
  '<input type="text" name="anioIngresado">' +
  '<input type="submit" value="Enviar">' +
  '</form>';

app.get('/', (request, response) => {
  response.send(
    '<html><body>' +
    formulario + 
    '</body></html>'
  );
});

const esBisiesto = (anio) => {
  let verificacionAnio = (((anio % 4 == 0) && (anio % 100 != 0)) || (anio % 400 == 0)) ? 1 : 0;
  if (! verificacionAnio){
    return false;
  }
  else{
    return true;
  }
}

app.post('/bisiesto', (request, response) => {
  let anio = request.body.anioIngresado;
  let resultado = '';
  if(esBisiesto(anio) == true){
    resultado = 'es bisiesto';
  }
  else{
    resultado = 'no es bisiesto';
  }

  response.send(
    '<html><body>' +
    '<p>El año ingresado ' + resultado + '</p>'
  );
});

app.listen(config.port, () => {
  console.log(`Live at http://localhost:${config.port}`);
})>

Mi solución al reto 😄

Aquí mi solución

Bueno, aquí mi solución al reto, pase todo directo a un if

app.get('/year/:year', function(req, res) {
    let y = req.params.year;
    if (y % 4 === 0 && y % 100 !== 0 || y % 400 === 0) {
        res.send('True');
    } else {
        res.send('False');
    }
})

Primera solucion

Mejorando el codigo

Explicacion de bisiesto

Estuve algunos videos adelante, y ahora repitiendo este contenido ya es mas claro todo.

  • home

  • Respuesta

  • Respuesta

  • Respuesta

  • messges.js

  • year.js

  • index.js

  • head all files html

  • body index.html

  • body leap.html

Ey! Tengo un super un resumen con una explicacion y ejercicio resuelto de manera entendible que les encantara!

Resumen: METODOS. GET => se ejecuta cuando el cliente requiere algo de nuestra pagina, basicamente cuando requiere datos. Por lo tanto el metodo GET le dara a el cliente esos mismos datos que el requiere.

POST => nos sirve para guardar/tomar recursos externos(del cliente) y guardarlos en el back-end. ejemplo el cliente nos da su fecha de nacimiento en un form, esto lo guardamos en el back-end y lo trabajamos de la manera que queramos.

continuemos con otro apartado-----------------------

Bien, en mi opinion el req.body es el mas interesante, ya que podemos obtener la data del body y con esto trabajar los datos en nuestro back-end.

bien, y si llevamos esta informacion a un campo real?

const express = require('express');
const bodyParser = require('body-parser');
const app = express();
const { config } = require('./config/index');
app.use(bodyParser.urlencoded({extended:true}));

const formulario = 

    '<h1> Calculadora de edad </h1>' +
    '<p> Ingresera su fecha de nacimiento y nuestro algoritmo le dira cuantos años posee actualmente</p>' +
    '<form method="post" action="/edadActual">' +
    '<input type="number" name="anioIngresado">' +
    '<input type="submit" submit value="Enviar">'+
    '</form>';


app.get('/', (req,res) => {
    res.send(
        '<html><body>' +
        formulario +
        '</body></html>'
    );
});

app.post('/edadActual', (req,res) => {
    let años = req.body.anioIngresado;
    let edadActual = 2021 - años;

    res.send(
        '<html><body>' +
        '<h1>Calculemos Su Edad</h1>'+
        `<p>Entonces si naciste en ${años} y estamos en 2021, por lo tanto tu edad Actual es: </p>`+
        edadActual +
        '</body></html>'
    );
});



app.listen(config.port, () => {
    console.log(`Live at https://localhost:${config.port}`);
  })

Hola como estan!! Encontre un video que aclara un MONTON.
https://youtu.be/0t93qDkGcB0, escribanle el https, ya que se lo saque.

index.js

<code>
const express = require('express');
const app = express();
const { config } = require('./config/index');
const {esBisiesto} = require('./Modulos/bisiesto');

app.post('/:year', (req, res) => {
    res.send(esBisiesto(req.params.year));
});

app.listen(config.port, () => {
  console.log(`Listening http://localhost:${config.port}`);
});
</code>

Módulo

<code>
const esBisiesto = (year) => {
  if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
    return `El ${year} es bisiesto`;
  } else {
    return `El ${year} no es bisiesto`;
  }
};

module.exports = {
  esBisiesto,
};
</code>

Mi versión del reto. Todavía no se bien como manejar el html dentro del res.send(), me gustaria entender como mandar stream al res.send
Seguro más adelante lo aprenderemos o habrá que investigar.

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/', function (req, res) {
  const text = `
	<h1> Verificador de años biciestos </h1>
	<p> Para verificar si un año es bisiesto
	debes accerder a la ruta:</p>
	<p style="text-align:center; font-size:30px">127.0.0.1:${config.port}/bisiesto/:año </p>`;

  res.send(text);
});
app.get('/bisiesto/:year', function (req, res) {
  const year = req.params.year;
  let respuesta = '';
  if (year % 4 === 0) {
    respuesta = 'si';
  } else {
    respuesta = 'no';
  }
  const text = `<h1> Respuesta </h1>
		<p> El año <strong>${req.params.year} </strong> ${respuesta} es año bisiesto </p>
		`;
  res.send(text);
});

app.listen(config.port, function () {
  console.log(`Escuchando el puerto ${config.port}`);
});

Challenge completado 🤠

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/', function (req, res) {
  res.send('Envia un año y comprobaremos si es o no un año bisiesto');
});

app.get('/:year', function (req, res) {
  const year = parseInt(req.params.year);
  console.log(year);
  if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
    res.send(`${year} es un año bisiesto`);
  } else {
    res.send(`${year} no  es un año bisiesto`);
  }
});

app.listen(config.port, function () {
  console.log(`Listening to port https://localhost:${config.port}`);
});

muy interesante como maneja las peticiones Node.js

Mi solución:

function isLeap(anio) {
  return (anio % 4 == 0 && anio % 100 != 0) || anio % 400 == 0 ? 1 : 0;
}

app.get('/bisiesto/:anio', (req, res) => {
  const anio = req.params.anio;
  res.json({
    message: +anio + ' is leap-year? ' + (isLeap(anio) ? 'Yes' : 'No'),
    result: isLeap(anio),
  });
});

Muy mal que esto se ponga como texto y no en un video explicándolo

const express = require('express');

const app = express();

const { config } = require('./config/index');

app.get('/', function(req, res) {
    res.send('hello world');
});

app.get('/json', function(req, res) {
    res.json({ hello: 'world' });
});

app.get('/:year', function(req, res) {
    const year = parseInt(req.params.year);
    if((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0){
        res.send(`${year} es bisiesto`);
    }else{
        res.send(`${year} no es bisiesto`);
    }
});

app.listen(config.port, function() {
    console.log(`Listening http://localhost:${config.port}`);    
});

Lo había resuelto en mi ejercicio anterior, pero vi que se podían usar algunas instrucciones de deconstructuring y ternarios y lo hice un poco más simple:

app.get('/anyo-bisiesto-checker', function (req, res) {
  let anyo = req.query.anyo;
  let anyoBisiesto = (anyo % 4 == 0 && anyo % 100 != 0) || anyo % 400 == 0;
  res.send(`El año ${anyoBisiesto ? 'es bisiesto' : 'no es bisiesto'}.`);
});
app.get('/challenge/:year', function (req, res) {
    let { year } = req.params;
    res.json({ year: `${year}`, result: `${((year % 4 === 0 && year !== 0) || year % 400 === 0) ? 'si es bisiesto' : 'no es bisiesto'}` });
});

Además de body-parser también se puede hacer “nativamente” con Express así:

// Para datos tipo application/json
app.use(express.json());

// Para datos de tipo application/x-www-form-urlencoded
app.use(express.urlencoded({extended: true}));

// Para datos de tipo text/plane
app.use(express.text());

Estuvo sencillo para lo que se pedía, mi solución fue:

const express = require('express');
const app = express();

const { config } = require('./config');
app.set('port', config.port);

app.get('/bisiesto/:id', (req, res) => {
    const { id } = req.params;
    if (id % 4 == 0)
        return res.json({ bisiesto: true, message: "Es año bisiesto" })
    else
        return res.json({ bisiesto: false ,message:"No es año bisiesto"})
})

app.get('/', (req, res) => {
    return res.send('Hello')
})
app.get('/json', (req, res) => {
    return res.json({ hello: "world" })
})
app.listen(app.get('port'), (req, res) => {
    console.log(`Server on  http://localhost:${app.get('port')}`);
})

Reto completado:

const express = require("express");
const app = express();
const { config } = require("./config/index");

app.get("/reto/:year", (request, response) => {
    const year = request.params.year;

    const bisiesto = () => {
        if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
            response.send(`${year} es Bisiesto`);
        } else {
            response.send(`${year} no es Bisiesto`);
        }
    }

    function validate() {
        isNaN(year) === true ? response.send("Introduce una fecha valida") : bisiesto();
    }

    validate();
});

app.listen(config.port, () => {
    console.log(`Escuchando ${config.port}`)
})

Después de ver las respuestas de los demás me siento tramposo al usar “moment” para resolver el problema.

const express = require('express');
const app = express();
const moment = require('moment');

const { config } = require('../config/index');

app.get('/:year', function(req, res) {
    const year = req.params.year;
    if (moment([year]).isLeapYear()) {
        res.send('El año ' + year + ' es bisiesto');
    }

    res.send('El año ' + year + ' no es bisiesto');
});

app.listen(config.port, function() {
    console.log(`Listening https://localhost:${config.port}`)
});

Aquí dejo mi solución al reto:

app.get('/leap/:year', (req, res) => {
    let year = req.params.year;
    
    console.log

    if (year.length == 4) {
        if ( (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) == false ) {
            res.send(`${year} no es un año bisiesto`);
        }
        res.send(`${year} es un año bisiesto`);
    } else {
        res.send('Ingresa un año con 4 digitos.')
    }
})```

No fué la solución mas elegante pero cumplió su cometido.

const express = require("express");
const app = express();

const { config } = require("./config/index");

function evalYear(year) {
  let isLeap = false;

  if (year % 4 == 0) {
    console.log("The year %d is divisible by 4", year);
    if (year % 100 == 0) {
      console.log("The year %d is divisible by 100", year);
      if (year % 400 == 0) {
        console.log("The year %d is divisible by 400", year);
        console.log("The year %d is a Leap year", year);
        return (isLeap = true);
      } else {
        console.log(
          "The year %d is divisible by 4 and 100 but not by 400",
          year
        );
      }
    } else {
      console.log("The year %d is divisible by 4 but not by 100");
      return (isLeap = true);
    }
  } else {
    console.log("The %d is not a Leap Year", year);
    return isLeap;
  }
}


app.get("/", function (req, res) {

  console.log(req.params);
  res.send("Hello world");
});

app.get("/year/:year", function (req, res) {
  let year = Number(req.params.year);

  if (evalYear(year) == true) {
    res.send(`${year} is a Leap year`);
  } else {
    res.send(`${year} is not a Leap year`);
  }
});


app.listen(config.port, function () {
  console.log("listening on port: " + config.port);
});

Espero esta imagen les sirva para entender mejor los query strings.

¿Qué es un middleware?

En pocas palabras, un middleware permite conectar dos aplicaciones para el intercambio de datos. Un ejemplo de esto son las bases de datos. Otro tipo de middleware pueden ser las APIs.

mi codigo, simplificando los codigos de los comentarios:

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/anio:year', (req, res) => {
  let year = req.params.year;

  if (
    (year.length === 4 && year % 4 === 0) ||
    year % 100 === 0 ||
    year % 400 === 0
  ) {
    res.json({
      message: `El año que ingreso fue ${year}`,
      isBicies: `Es año es bisiesto es decir tiene 365 dias`,
    });
  } else {
    res.json({
      message: `El año enviado es ${year} y no es un año valido`,
    });
  }
});

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

Hola como estan? Encontre un video super simple que aclara un MONTON. https://youtu.be/0t93qDkGcB0

Este es el código de mi reto:

const express = require('express')
const app = express()
const moment = require('moment')

const { config } = require('./config/index')

app.get('/', function (req, res) {
  res.send('Hello world')
})

app.get('/json', function (req, res) {
  res.json({Hello: 'world'})
})

app.get('/bisiesto', function (req, res) {
  res.json(isBisiesto(req.query.date))
})

app.listen(config.port, function () {
  console.log(`Listening htttp://localhost:${config.port}`);
})

function isBisiesto(dateString) {
  if (moment(dateString).isValid()) {
    let year = moment(dateString).format('yyyy')
    if (parseInt(year, 10) % 4 == 0) {
      return 'Año bisiesto'
    } else {
      return 'Año normal (NO bisiesto)'
    }
  } else {
    return 'Error en el formato de la fecha'
  }  
  return
}

req (servidor) y res (cliente)

let year; 
let year = year % 4 == 0 ? "El año es Bisiesto" : "El año no es Bisiesto";
year = 2000; // req.body
"El año es Bisiesto" // res.send
year = 2001; // req.body // req.body
"El año no es Bisiesto" // res.send

Comparto mi challenge:
 

const express = require('express');

const app = express();

app.get('/year/:year', (req, res) => {
  const { year } = req.params;

  if (isNaN(year)) {
    res.status('400').json({ error: 'Year must be a number' });
  }

  if (!/^\d{1,4}$/.test(year)) {
    res
      .status('400')
      .json({ error: 'Year size must be between 1 and 4 characters' });
  }

  if (!(year % 4) && year % 100 != 0) {
    res.json({ message: `Year ${year} is bisiesto 💚` });
  }

  if (!(year % 400)) {
    res.json({ message: `Year ${year} is bisiesto 💚` });
  }

  res.json({ message: `Year ${year} is not bisiesto 💔` });
});
app.listen(3000, function () {
  console.log(`Listening on port 3000`);
});

app.get('/:year', function(req, res) {
    const year = parseInt(req.params.year);
    console.log('Año',  year)
    if (isLeapYear(year)) {
        res.send({ year: 'is Leap Year'})
    } else {
        res.send({ year: 'Normal Year'})
    }
});

const isLeapYear = (year) => {
    //Cuando no existe el 29 de febrero automáticamente new Date crea 1 de marzo, si lo comparamos contra 1 de marzo podemos saber si es o no bisiesto
    return (new Date(year+'-02-29')).toDateString() !== (new Date(year+'-03-01')).toDateString()
  };

Muy buena explicación de res y req

app.get('/bisiesto/', function (req, res) {
    res.send('Ejemplo para saber si el año ingresado es bisiesto, favor ingresar el parametro anio a travez de la URL');
})
app.get('/bisiesto/:anio', function (req, res) {
    try {
        const anio = parseInt(req.params.anio);
        if (!anio || isNaN(anio) || typeof anio !== 'number' || !Number.isInteger(anio) || anio <= 0)
            return res.send(`El año ingresado no cumple con los requisitos para ser evaluado`);
        let mensajeBisiesto = `es`;
        if (anio % 4 !== 0)
            mensajeBisiesto = `no es`;
        return res.send(`El año ${anio} ${mensajeBisiesto} bisiesto`);
    } catch (error) {
        console.log(error);
    }
});

Quizá innecesario utilizar el modulo leap-year, pero aquí está mi aporte 😄.

const express = require('express');
const app = express();

const leap_year = require('leap-year');

const {config} = require('./config/index');

app.get('/isLeap:year', (req,res)=>{
    res.send(leap_year(parseInt(req.params.year.slice(1))));
});

app.listen((config.port), ()=>{
    console.log(`Servidor en el puerto ${config.port}`);
});

No entendi muy bien .end() pensé que por naturaleza se cerraba el proceso sin necesidad de .end()

Les comparto mi solución

const express = require("express");
const APP = express();
const PORT = 3000;
const isLeapYear = (year) => (year % 4 === 0 && year % 100 > 0) || (year % 400 === 0);

APP.get("/year/:year?", (request, response) => {
    let { year = 0 } = request.params;
    let status = 404;
    let msg = "Se tiene que propocionar un año";
    year = parseInt(year, 10);
    const IS_LEAP_YEAR = isLeapYear(year);
    if (IS_LEAP_YEAR && year > 0) {
        status = 200;
        msg = IS_LEAP_YEAR ? "366 es " : "365 no es";
        msg = `El año ${year} tiene ${msg} biciesto`;
    }
    response.status(status).send(msg);
});

APP.listen(PORT, () => {
    console.log(`Estoy corriendo en el puerto ${PORT}`);
});

app.post('/leap-year/:year', function(req, res) { const year = req.params.year if(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ){ res.send(Year ${year} is leap-year); } else { res.send(Year ${year} is not leap-year`);
}

})`

Esta es mi solución:

const express = require('express')
const app = express()

const { config } = require('./config/index')

function isLeap(year) {
    return ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0)
}

app.get('/', function(req, res) {
    res.send('hello world')
})

app.get('/json', function(req, res) {
    res.json({ hello: 'world' })
})

app.get('/isleap/:year', function(req, res) {
    const year = req.params.year
    const esBisiesto = isLeap(year)
    if (esBisiesto) {
        res.send(`El año ${year} es bisiesto`)
    } else {
        res.send(`El año ${year} no es bisiesto`)
    }
})


My solution:


const express = require('express');
const app = express();
const { config } = require('./config/index');

const isLeap = (arg) => arg % 100 === 0 ? arg % 400 === 0 : arg % 4 === 0;

app.get('/leap:year', (req, res) => {
  let modifier = '';
  let query = parseInt(req.params.year.slice(1));
  let now = parseInt(new Date().getFullYear());

  if(query < now){
    isLeap(query) ? modifier = `was` : modifier = `wasn't`;
  }else if(query === now){
    isLeap(query) ? modifier = `is` : modifier = `isn't`;
  }else{
    isLeap(query) ? modifier = `will be` : modifier = `won't be`;
  }

  res.send(`${query} ${modifier} leap-year`);
});

app.listen(config.port, () => {
  console.log('====================================');
  console.log(`Listening :${config.port}`);
  console.log('====================================');
});

el código del reto:

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/:year', function(req, res) {
  const anio = parseInt(req.params.year);
  if (isNaN(anio)) {
    res.send('Se necesita un número valido');
  }

  if (anio % 4 === 0 && (anio % 100 !== 0 || anio % 400 === 0)) {
    res.send(`El anio: ${anio}, es bisiesto`);
  } else {
    res.send(`El anio: ${anio}, no es bisiesto`);
  }
});

app.listen(config.port, function() {
  console.log(`Listening http://localhost:${config.port}`);
});

Es recomendable seguir usando ExpressJS o un Framework como Sails.JS

Reto Completado!

En Windows, agregar “set DEBUG=app:* **&**nodemon index” para ejecutar sin problemas npm run dev

const express = require('express');
const app = express();

const moment = require('moment');

const { config } = require('./config/index');

app.get('/', function(req, res){
    res.send("hello word!");
});

app.get('/json', function(req, res){
    res.json({hello : 'word'});
});

app.get('/bisiesto/:anio', function(req, res){
    let anio = req.params.anio;
    res.json({anio:req.params.anio, esBisiesto: moment([anio]).isLeapYear()});
});

app.listen(config.port, function(){
    console.log(`Escucahndo http://localhost:${config.port}`);
});

Este resumen me fue de mucha ayuda, al detallar cada uno de los métodos, que usan tanto el request y el response, hace que todo sea mas entendible, por el proceso que lleva el servidor.

mi version

const express = require("express");
const app = express();

const { config } = require("./config/index");

app.get("/", function(req, res) {
  res.send("hello world");
});

app.get("/json", function(req, res) {
  res.send({ hello: "world" });
});

app.get("/bisiesto/:year", function(req, res) {
  let year = req.params.year;
  if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {
    res.send(`${req.params.year} is bisiesto`);
  } else {
    res.send(`${req.params.year} isn't bisiesto`);
  }
});

app.listen(config.port, function() {
  console.log(`listening http://localhost:${config.port}`);
});

const express = require('express');
const app = express();

const { config } = require('./config/index');

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


app.get('/json', ( req, res ) => {
   res.json({ hello: 'world' });
});

app.get('/bisiesto/:year', ( req, res ) => {
   let year = req.params.year;

   let isBisiesto = ((year % 4 === 0) && (year % 100 !== 0 )) || (year % 400 === 0);

   isBisiesto ? res.send(`${ year } es bisiesto`) : res.send(`${ year } no es bisiesto`);
   
});

app.listen(config.port, () => {
   console.log(`Listening http://localhost:${config.port}`);
});
app.get('/bisiesto/:anio', (req, res) => {
  let anio = req.params.anio;

  if (anio % 4 == 0 && anio % 100 != 0) {
    res.send('El año es bisiesto!');
  } else {
    res.send('El año no es bisiesto :(');
  }
});

Reto terminado:

app.get('/bisiesto/:year', function (req, res) {
  const year = parseInt(req.params.year)
  if (!isNaN(year)) {
    res.json({ 'Bisiesto': year % 4 === 0 })
  } else {
    res.send('Este no es un año')
  }
})
const express = require('express')
const app = express()

const { config } = require('./config/index')

app.get('/', (req, res) => {
  res.send('Hello world')
})

app.get('/json', (req, res) => {
  res.json({hello: 'world'})
})

app.get('/year/:year', (req, res) => {
  const { year } = req.params
  const leapYear =
    (year % 4 === 0 && (year % 100 !== 0 || year % 400 == 0)) ?
      "is leap-year" :
      "is not leap-year"
  res.send(`The ${year} ${leapYear} `)
} )

app.listen(config.port, () => {
  console.log(`listening http://localhost:${config.port}`)
})```
const express = require('express');
const app = express();

function bisiesto(year) {
  const isLeap = !(new Date(year, 1, 29).getMonth() - 1)
  if (isLeap) {
    return 'año bisiesto'
  }
  return 'año no bisiesto'
}

app.get('/params/:name', function (req, res) {
  res.send(`El año ${req.params.name} es un ${bisiesto(req.params.name)}`);
});

app.listen('3001', function () {
  console.log('Listening to port 3001');
});```
app.get('/bisiesto/:year', (req, res) => {
    const year = req.params.year;

    if ((year % 4 === 0  && year % 100 !== 0) || year % 400 === 0) {
        return res.send("Es bisiesto");
    }

    return res.send("No es bisiesto");
});```

Reto:

app.post("/date/:year", (req, res) => {
  console.log(req.params.year);
  let leap = false;
  
  if ( (req.params.year % 4) === 0 ) {
    leap = true;
  }

  res.send({ leap_year: leap.toString() });
});

Reto:

const express = require('express');

const app = express();

const { config } = require('./config/index');

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

app.get('/json', (req, res) => {
    res.json({hello: 'world'});
});

app.get('/leap-year/:year', (req, res) => {
    const year = parseInt(req.params.year);
    const leapYear = (year) => {
        return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
    }

    const isLeapYear = leapYear(year);
    const message = isLeapYear ? 'Yes, it\'s a leap-year' : 'Nop, it\'s not a leap-year';

    res.send({isLeapYear: isLeapYear, year: year, message: message});

})

app.listen(config.port, () => {
    console.log(`Listening in http://localhost:${config.port}`);
});

Solo agregen el codigo al index y ejecutar en el navegado /bisieto/id(el anio)

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/', function (req, res) {
  res.send('Hello Word');
});
app.get('/bisieto/:id', function (req, res) {
  //parametro de calculo bisieto
  const isLeapYear = (year) => {
    year = year instanceof Date ? year.getFullYear() : year;
    return !(new Date(year, 1, 29).getMonth() - 1);
  };
  //Se le pasa id con req.params.id)
  const IsBistiento = isLeapYear(parseInt(req.params.id));
  
  //ternario
  const mensaje = IsBistiento
    ? '<h1>es bisieto</h1>'
    : '<h1>no es bisieto</h1>';
  res.send(mensaje);
});

app.get('/json', function (req, res) {
  res.send({ hello: 'Hola' });
});

app.listen(config.port, function () {
  // eslint-disable-next-line no-console
  console.log('Todo bien');
});

const express = require('express');
const app = express();
const { config } = require('./config/index');

app.get('/:amo', (req, res) => {
    const amo = parseInt(req.params.amo);
    if(amo){
        if ((((amo % 4 == 0)
            && (amo % 100 != 0))
            || (amo % 400 == 0))
        )
            res.send(`El año ${amo} es bisiesto!`)
        else
            res.send(`El año ${req.params.amo} NO es bisiesto`);
    }else{
        res.send(`Dame un año en la url en 4 digitos`);
    }
});

app.listen(config.port, () =>{
    console.log(`Corriendo en http://localhost:${config.port}`)
})```
app.get("/ano/:date" , (req,res)=>{
    const date = req.params.date;
    if(date % 4 === 0){
        return res.send("es biciesto")
    }else{
        res.send("no es biciesto")
    }
})

genial!

Solución al reto

app.get('/:year', (req, res) => {
    const año = parseInt(req.params.year);
    (((año % 4 == 0) && (año % 100 != 0 )) || (año % 400 == 0)) ? res.send(`El año ${año} es bisiesto`) : res.send(`El año ${año} no es bisiesto`) 
});

Mi solución:

app.get("/anio/:year", (req, res) => res.json({ leap: req.params.year % 4 === 0 && true}) );
const express = require('express');

const app = express();

const {config} = require('./config/index.js');


app.get('/anio/:year', function(req, res){
    let year = req.params.year;
    res.send(bisiesto(year)).end();
});

const bisiesto = (year) => {
    if(year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
        return 'el año es bisiesto';
    } else {
        return 'el año no es bisiesto'
    }
}

app.listen(config.port);

console.log(`Escuchando en http://localhost:${config.port}`);```
app.post('/', function (req, res) {
  const body = req.body;
  const year = body.year;

  if (year % 4 == 0) {
    res.json({
      leap_year: true,
    });
  } else {
    res.json({
      leap_year: false,
    });
  }
});

Reto realizado

app.get('/anno/:year', (req,res)=>{
    const year = req.params.year
    const msg = (year % 4 ==0)
        ? `El año ${year} es un año bisiesto`
        : `El año ${year} es un año normal`
    res.send(msg)
})

app.get('/validate/:year', function (req, res) {
    let year = req.params.year

    if (year % 4 === 0 && year % 100 === 0 && year % 400 === 0 || year % 4 === 0 && year % 400 === 0) {
        res.send(`El año ${year} si es bisiesto`)
    } else  {
        res.send(`El año ${year} no es bisiesto`)
    }
})```

Mi solucion al reto:

const express = require('express');
const app = express();
const { config } = require('./config/index.js');

function esBisiesto(year) {

  return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? true : false;

}

app.post('/biciesto/:year', function (request, response) {
  let message;

  if (esBisiesto(parseInt(request.params.year))) {
    message = "Es biciesto";
  } else {
    message = "No es biciesto";
  }

  response.send(message);
});

Tambien podemos agregar expresiones regulares a los parámetros de las rutas en express, en este caso para solo permitir haga el match si el parámetro es numérico:

app.get('/:year(\\d*\\d*)', (req, res) => {
	
});

saludos,

Esta es mi solución al reto

app.get('/year/:year', function(req, res){
    let año = req.params.year;
    let esBiciesto = año % 4 === 0 && (año % 100 !== 0 || año % 400 === 0);
    res.send(`El año ${año} es ${esBiciesto ? 'biciesto' : 'no biciesto'}`);
});

RETO:

const express = require('express')
const app = express()
const { config } = require('./config/index')

app.get('/comprobar/:year', (req, res) => {
    req.params.year % 4 === 0
        ? res.status(200).send(`El año ${req.params.year} es bisiesto`)
        : res.status(200).send(`El año ${req.params.year} no es bisiesto`)
})

app.listen(config.port, () => {
    console.log(`Listening http://localhost:${config.port}`)
})
const express = require('express');
const app = express();

const { config } = require('./config/index');
const { port } = config;

app.post("/profile", function(req, res) {
    let body = [];
    req
    .on('data', (data) => {
        body.push(data);
    })
    .on('end', () => {
        body = Buffer.concat(body).toString();
        let bisiesto = body % 4 == 0 && body % 100 != 0 || body % 400 == 0;
        bisiesto ? res.send('Año Bisiesto') : res.send('No es un año Bisiesto');
        res.end();
    });
});

app.listen(port, function() {
    console.info(`Listening in port: http://localhost:${port}`);
});```
const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/', (req, res) => {
  res.send('Welcome to home');
});

app.get('/calc/:year', (req, res) => {
  let { year } = req.params;

  let isValid = (year % 4 === 0 && year !== 0) || year % 400 === 0;
  res.send(`${year} ${isValid ? 'is prime' : 'no yet'}`);
});
app.get('/user/:name', (req, res) => {
  res.send(`user: ${req.params.name}`);
  res.status(404).end('not found');
});

app.listen(config.port, () => {
  console.log(`listen on http://localhost:${config.port}`);
});

Me faltaron mas comprobaciones, pero quedo

const express = require('express');

app = express();

app.get('/', (req, res) => {
    res.send('Hola mundo')
})

app.get("/year/:number", (req, res) =>{
    const year = req.params.number;

    if (year % 4 === 0) {
        res.send(`El ano ${year} es bisiesto`)
    } else{
        res.send(`El ano ${year} no es bisiesto`)
    }
    
    
})

app.listen(3000, () => {
    console.log('Listening in port 3000')
})```

Desafío usando moment() y req.params

const express = require('express');
const app = express();
const moment = require('moment');

const { config } = require('./config/index.js');

app.get('/', function (req, res) {

  if (req.query.year) {
    if (moment(req.query.year).isLeapYear()){
        res.send('Si, es año bisiesto')
    } else {
      res.send('No, no es año bisiesto')
    }
  }
  res.send('hello world');
});

app.get('/json', function (req, res) {
  res.json({hello: 'world'});
});



app.listen(config.port, function() {
  console.log(`listening to port ${config.port} on localhost`)
});

No se me hizo nada fácil este reto

app.get('/bisiesto/:year', (req, res) => {
  let year = req.params.year;
  res.send(year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)
    ? 'Año bisiesto'
    : 'No es año bisiesto'
  );
})

aquí el reto 👌⚡️

const express = require('express');
const app = express();

const { config } = require('./config/index.js');

function bisiesto(year) {
    if (year % 4 === 0) {
        return `${year} es bisiesto`;
    } else {
        return `${year} no es bisiesto`;
    }
}

app.get('/', function (req, res) {
    res.send('Hello world');
});

app.get('/year/:year', function (req, res) {
    res.send(bisiesto(req.params.year));
});

app.listen(config.port, function () {
    console.log(`Listening in https://localhost:${config.port}`);
});

Les comparto mi solucion

app.get('/date/:date', (req, res) => {

    if((req.params.date).split('-').length < 3) {
        res.json({"error": "Bad date structure"});
        return
    } 

    if (moment(req.params.date, "DD-MM-YYYY").isLeapYear()) {
        res.json({"data": true});
        res.end();
    } else {
        res.json({"data": false});
        res.end();
    }
});

Aquí mi solución

app.get('/challenge/:year', (req, res) => {
  res.send(isLeap(req.params.year))
})

const isLeap = (year) => (year % 4  === 0 && (year % 100 !== 0 || year % 400 === 0 )) ? 'Es bisiesto' : 'No es bisiesto'
const express = require('express')
const app = express()

app.get( '/:year', ( req, res ) => {
    let BISIESTO = req.params.year%4
    BISIESTO === 0 ? BISIESTO = 'Es bisiesto!' : BISIESTO = 'No es bisiesto :('
    res.send(`Interesante imaginate que ese año... ${ BISIESTO }`)
} )

app.listen(3000, () => {
    console.log(`Listening in the port 3000`)
})

Here we go!!

El challenge

const express = require('express')
const app = express();
const config = require('./config/index')

app.get('/:year',(req,res)=>{
    const year = req.params.year
    res.send(year%4===0 
        ? `el año ${year} es bisiesto` 
        : `el año ${year} no es bisiesto`)
})

app.listen(config.port)```

Esta es mi humilde solución al challenge:

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/:year', (req, res) => {
  const year = req.params.year;
  const leapYear = isLeapYear(year);
  const message = `El año ${ year } ${ leapYear ? 'es' : 'no es' } Bisiesto`;
  res.send(message);
});

app.listen(config.port, () => {
  console.log(`Server on http://localhost:${config.port}`);
});

function isLeapYear(year) {
  return year % 4 == 0 && year % 100 !== 0 || year % 400 === 0;
}

*nota: No sólo es suficiente con dividir entre 4 también hay que evaluar si no es divisible entre 100 o si es divisible entre 400,

Mi solución

Mi código, simple y efectivo.

const express = require("express");

const app = express();
const { config } = require("./config/index");

app.get("/", (req, res) => {


if(req.query.year % 100 ===0 && req.query.year % 4 ===0 ){
    console.log("Es bisiesto");
}else if(req.query.year % 100 !==0 && req.query.year % 4 ===0){
    console.log("Es bisiesto");
}else{
    console.log("No es bisiesto");
}
    res.send();

});


app.listen(config.port, () => {
  console.log(`listen on http://localhost:${config.port}`);
});```


Este es el mio 😀

app.get('/bisiesto?', function (req, res) {
  const { fecha } = req.query;
  let message, status;
  const aux = new Date(fecha);
  if (isNaN(aux.getFullYear())) {
    status = 400;
    message = 'Usa el query para pasar una fecha valida';
  } else {
    status = 200;
    message = aux.getFullYear() % 4 === 0 ? 'es bisiesto' : 'no es bisiesto';
  }
  res.status(status).send({ message });
});

Anexo respuesta al challenger

const express = require('express');

const app = express();

const { config } = require('./config/index');


function bisiesto(ano) {
  if (((ano % 4 === 0) && (ano % 100 !== 0))  || (ano % 400 === 0)){
    return 'es bisiesto.';
  } else {
    return 'no es bisiesto.';
  }
}

app.get('/:ano', function (req, res) {
  res.set('Content-Type', 'text/plain');
  let texto=`El año ${req.params.ano} ${bisiesto(req.params.ano)}`;
  res.end(texto);
});

app.listen(config.port, function () {
  console.log(`Listening en http://localhost:${config.port}/2020`)
});

src/utils/index.js

const isLeapYear = (year) => {
  return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
};

module.exports = {
  isLeapYear,
};

route -> index.js

app.get('/leapyear/:year', (req, res) => {
  const year = req.params.year;
  res.send(`El año ${year} ${isLeapYear(year) ? 'es' : 'no es'} bisiesto`);
});

Mi código con una función ternaria para validar que ingresen un número válido

const express = require('express');
const app = express();

const { config } = require('./config/index');

app.get('/', function (req, res) {
  res.send('Hello World');
});

app.get('/json', function (req, res) {
  res.json({ hello: 'World' });
});

app.get('/:year', function (req, res) {
  const year = req.params.year;

  const leapYear = () => {
    if ((year % 4 == 0 && year % 100 !== 0) || year % 400 == 0) {
      return res.send(`El año ${year} es bisiesto`);
    } else {
      return res.send(`El año ${year} no es bisiesto`);
    }
  };

  function validateYear(){
      isNaN(year) == true ? res.send('Debes ingresar un año'): leapYear();
    };

  validateYear();
});

app.listen(config.port, function () {
  console.log(`Listening http://localhost:${config.port}`);
});```