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.
Tu primera experiencia con Node.js
¿Dónde aprender backend con Node.js actualizado?
Todo lo que aprenderás sobre backend con Node.js
¿Qué es Node.js?
¿Qué es Node.js y para qué sirve?
Diferencias entre Node.js y JavaScript
Resumen: Diferencias Nodejs y Javascript
Instalación de Node.js
Arquitectura orientada a eventos
Node.js para la web
Manejo y uso de Streams con Node.js
Introducción a streams
Readable y Writable streams
Duplex y Transforms streams
Uso de utilidades de Node.js
Sistema operativo y sistema de archivos
Administrar directorios y archivos
Consola, utilidades y debugging
Clusters y procesos hijos
Crea tu primer proyecto en Express.js
¿Qué es Express.js y para qué sirve?
Creando tu primer servidor con Express.js
Request y Response Objects
Aprende a crear un API con REST
Anatomía de una API Restful
Estructura de una película con Moockaru
Implementando un CRUD en Express.js
Métodos idempotentes del CRUD
Implementando una capa de servicios
Cómo conectarse con librerías externas en Express.js
Creación de una BD en MongoAtlas
Conexión a MongoAtlas una instancia de MongoDB
Conexión con Robot3T y MongoDB Compass a una BD
Implementación de las acciones de MongoDB
Conexión de nuestros servicios con MongoDB
Conoce como funcionan los Middleware en Express.js
¿Qué es un middleware? Capa de manejo de errores usando un middleware
Manejo de errores asíncronos y síncronos en Express
Capa de validación de datos usando un middleware
¿Qué es Joi y Boom?
Implementando Boom
Implementando Joi
Probar la validación de nuestros endpoints
Middlewares populares en Express.js
Implementa tests en Node.js
Creación de tests para nuestros endpoints
Creación de tests para nuestros servicios
Creación de tests para nuestras utilidades
Agregando un comando para coverage
Debugging e inspect
Despliega tu primera aplicación en Express.js
Considerando las mejores prácticas para el despliegue
Variables de entorno, CORS y HTTPS
¿Cómo implementar una capa de manejo de caché?
¿Cómo contener tu aplicación en Docker?
Despliegue en Now
Conclusiones
¿Qué aprendiste en este curso?
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
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, 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.
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}`);
});```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?