Para los que usan Windows y no les funciona el script cuando lo tienen de esta forma:
"dev": "DEBUG=app:* nodemon index"
De esta forma sí funciona:
"dev": "set DEBUG=app:*&& nodemon index"
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?
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 160
Preguntas 21
Para los que usan Windows y no les funciona el script cuando lo tienen de esta forma:
"dev": "DEBUG=app:* nodemon index"
De esta forma sí funciona:
"dev": "set DEBUG=app:*&& nodemon index"
Configuracion .eslintrc.json
{
"parserOptions": {
"ecmaVersion": 2018
},
"extends": [
"eslint:recommended",
"prettier"
],
"env": {
"es6": true,
"node": true,
"mocha": true
},
"rules": {
"no-console": "warn"
}
} ```
Para los que le de error DEBUG o NODE_ENV en el package.json en Windows.
SOLUCION:
"scripts": {
"dev": "SET DEBUG=app:* & nodemon index",
"start": "SET NODE_ENV=production & node index"
},
npx mrm@2 lint-staged
Instala la versión 2 de mrm porque la actual, la versión 3, es incompatible con lint-staged
dotenv
Es un módulo independiente que carga variables de entorno de un archivo .env en process.env.
npm i express dotenv
Nodemon
Nodemon es una utilidad que supervisará cualquier cambio en los recursos y reiniciará automáticamente su servidor.
npm i -D nodemon eslint eslint-config-prettier eslint-plugin-prettier prettier
Husky hooks
Es un módulo que puede prevenir realizar git commit o git push sin formato u otros conflictos no deseados.
npx mrm lint-staged
const express = require('express');
const app = express();
const { config } = require('./config/index');
const divider = (year, divisor) => {
return year % divisor === 0 ? true : false;
};
app.get('/', (request, response) => {
response.send(`Place a year after the url and find out if it is leap year:
http://localhost:${config.port}/1994`);
});
/**
* The year is leap year if
* first - it is divisible by 4
* second - it is not divisible by 100
* third - or it is divisible by 400
*/
app.get('/:year', (request, response) => {
const { year } = request.params;
if ((divider(year, 4) && !divider(year, 100)) || divider(year, 400)) {
response.send(`The year
${year} is leap year :D`);
}
response.send(`The year
${year} is NOT leap year :C`);
});
app.listen(config.port, () => {
console.log(`listening address http://localhost:${config.port}`);
});
SOLUCIÓN al error que no reconoce el DEBUG:
En el package.json pongan “dev”: “set DEBUG=app:* & nodemon index”.
Mucha suerte!! 😄
Mi solución:
Les dejo mis apuntes en caso de que les sirva
Adicional los que usen windows puede que el run dev no les sirva, pueden poner npx antes de nodemon y listo
npm init -y
Modificar scripts iniciales:
"scripts": {
"start": "DEBUG=app:* nodemon index.js",
"build": "NODE_ENV=production node index.js"
}
Configuración de .eslint.json
Crea el archivo con las siguientes configuraciones
{
"parserOptions": {
"ecmaVersion": 2018 /** indica la versión de EcmaScript que se va a usar
},
"extends": ["eslint:recommended", "prettier"], /** Indica que extienda la versión recomendada y que utilice prettier
"env": { /** Configura las variables de entorno indicando que se usarán es6, node, mocha
"es6": true,
"node": true,
"mocha": true
},
"rules": { /** regla de no poner la consola es unicamente un warning, no un error
"no-console": "warn"
}
}
Se configura prettier
Crear archivo .prettierrc.json
{
"tabWidth": 2, /** numero de espacios en los taps
"semi": true, /** que se utilice ;
"singleQuote": true /** comillas simples no dobles
}
instalar express y dotenv /** prodccion
npm i express dotenv
instalar dependencias de desarrollo:
/* -D abreviatura de --save-dev
npm i -D nodemon eslint eslint-config-prettier eslint-plugin-prettier prettier
/* installar hook para que cuando se haga commit se formatee con eslint y prettier
npx mrm lint-staged
/* Se crea archivo config/index.js de configuracion de variables de entorno ENV
require('dotenv').config();
const config = {
dev: process.env.NODE_ENV !== 'procdution', /** cuando no esté en prodccion */
port: process.env.PORT || 3000 /** buena practica tener una variable global para el puerto */
}
module.exports = { config };
si estan en windows y la consola le salta error ‘porque no reconoce a DEBUG=app:*’, coloquen ‘**set **DEBUG=app…’ y de paso tambien tienen que usar & antes de nodemon index
En package.json en el script de desarrollo se puede incluir en nodemon más tipos de archivos para que se refresquen automáticamente cuando sean modificados:
parámentro -e
Linux Mac:
“dev”: “DEBUG=app:* nodemon index -e js,hbs,html,css”,
Windows:
“dev”: “set DEBUG=app:* &nodemon index -e js,hbs,html,css”
Si no les funciona npx mrm lint-staged
es por que ahora es: npx mrm@2 lint-staged
en la documentación cambio
En Windows es diferente la parte de los Scripts de package.json
"dev": "set DEBUG=app:*&& nodemon index"
"start": "set NODE_ENV=production&& node index"
npx mrm lint-staged
me lanza el siguiente error
Cannot add lint-staged: only eslint, stylelint, prettier or custom rules are supported.
Para crear los scripts del package.json en windows se deben separar los comandos con &
"scripts": {
"dev": "DEBUG=app:* & nodemon index",
"start": "NODE_ENV=production & node index.js"
},
Que onda gente aquí les dejo el comando que me funciono para instalar lint-staged, ya que me daba un error:
npm config set cache "C:\Users\Firstname~1\AppData\Roaming\npm-cache" --global
El error es ocasionado por que tu nombre de usuario contiene un espacio en blanco. Cambien Firstname por su nombre sin espacio en blanco.
Ejemplo:
npm config set cache "C:\Users\OscarBarajas~1\AppData\Roaming\npm-cache" --global
Después ya pueden correr el comando npx mrm lint-staged
Para aquellos que están en Windows y no les de bien el npm run dev
o el npm start
pueden hacer 2 cosas:
"dev": "set DEBUG=app:* && nodemon index",
"start": "set NODE_ENV=production && node index"
Con esto ya les funcionará en windows, aunque no se si les siga funcionando en los otros sistemas operativos.
npm i cross-env
y usar estos scripts:"dev": "cross-env DEBUG=app:* nodemon index",
"start": "cross-env NODE_ENV=production node index"
Con esto ya les funcionará en todos los sistemas (incluyendo windows). Esto lo aprendí en el curso de Electron.
Reto:
app.get('/bisiesto/:anio', function (req, res) {
let anio = req.params.anio;
if ((anio % 4 === 0 && anio % 100 !== 0) || anio % 400 === 0)
res.send(`El año ${anio} es bisiesto.`);
else res.send(`El año ${anio} no es bisiesto.`);
});
Resultado:
Respuesta al reto
const express = require('express')
const app = express()
const { config } = require('./config')
app.use(express.urlencoded({extended:false}))
app.use(express.json())
app.get('/', (req, res) => {
const { year } = req.body
const divisibleFour = !(year % 4)
const divisibleHundred = !(year % 100)
const divisibleFourHundred = !(year % 400)
if(divisibleFour && (!divisibleHundred || divisibleFourHundred)){
res.status(200).json({message: 'Es un año bisiesto'})
}else{
res.status(200).json({message: 'No es un año bisiesto'})
}
})
app.listen(config.port, () => {
console.log(`Server listen on http://localhost:${config.port}`)
})
Mi configuracion preferida de prettier:
{
"semi": false,
"singleQuote": true,
"tabWidth": 2,
"useTabs": false,
"bracketSpacing": true,
"arrowParens": "avoid"
}
Para mi solución al reto, utilicé un módulo de npm llamado leap-year que me dice si es o no es bisiesto. Y para la respuesta apliqué un if ternario:
npm install -D leap-year
const leapYear = require('leap-year');
app.get('/leap-year/:year', (req, res) => {
leapYear(parseInt(req.params.year)) ? result = 'Si es bisiesto' : result = 'No es bisiesto';
res.send(result);
});
😎
const express = require('express')
const app = express()
const { config } = require('./config/index')
app.use(express.urlencoded({extended:false}))
app.use(express.json())
app.get('/leap-year/:year', (req, res) => {
const year = Number(req.params.year);
if(year % 4 === 0) return res.send(`${year} es año bisiesto`);
res.send(`${year} es un año normie`)
})
app.listen(config.port, () => {
console.log(`Server listen on http://localhost:${config.port}`)
})
Repositorio de la clase:
https://github.com/glrodasz/platzi-backend-node/tree/creando-tu-primer-servidor-con-expressjs
Codigo del pretierrc
{
"tabWidth": 2,
"semi": true,
"singleQuote": true
}
Codigo del .eslintrc.json
{
"parserOptions": {
"ecmaVersion": 2018
},
"extends": ["eslint:recommended", "prettier"],
"env": {
"es6": true,
"node": true,
"mocha": true
},
"rules": {
"no-console": "warn"
}
}
yo buscando la lectura en el material de la clase.
plug-in relative path
Mi solucion al reto :3
app.get("/year/:year", function(req, res) {
res.send(leapYear(req.params.year) ? "Bisiesto" : "No bisiesto");
});
function leapYear(year) {
if (parseInt(year) % 4 === 0){
return true;
}
return false;
}
<code>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', (req, res)=>{
let year = req.params.year;
if ( year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
res.send("el "+ req.params.year + " es biciesto")}
else{
res.send("el "+ req.params.year + " no es biciesto")}
}
)
app.listen(config.port, function() {
console.log(`Listening http://localhost:${config.port}`);
});
<code>
Servidor de express al mínimo:
const express = require('express')
const app = express()
const { config } = require('./config/index')
app.get('/', (req, res) => {res.send('Hello world')})
app.get('/', (req, res) => {res.json({ hello: 'world'})})
app.listen(config.port, () => console.log(`Listening http://localhost:3000${config.port}`))
Reto.
const express = require('express')
const app = express()
app.get('/:year', (req, res) => {
const year = req.params.year
if (year % 4 === 0 && year % 100 != 0) {
res.send(`${year} is a leap year`)
} else {
res.send(`${year} is not a leap year`)
}
})
app.get('/year/:year', function (req, res) {
const { year } = req.params
const leap = year % 4 === 0 && year % 1000 !== 0
res.send(`${year} is ${leap ? 'a' : 'not a'} leap year`)
})
app.listen(port, function () {
console.log(`Listening http://localhost:${port}`)
})
const express = require('express');
const app = express();
const {config} = require('./config/index.js')
app.get("/:year", (req,res)=>{
var year = req.params.year
if(year % 100 == 0){
if(year % 400 == 0){
res.send(`el año ${year} <b>es biciesto</b>`)
}else{
res.send(`el año ${year} <b>no es biciesto</b>`)
}
}
else if(year % 4 == 0)
{
res.send(`el año ${year} <b>es biciesto</b>`)
}
else
{
res.send(`el año ${year} <b>no es biciesto</b>`)
}
})
app.get("/json", (req,res)=>{
res.json({hello: "word"})
})
app.listen(config.port, ()=>{
console.log(`escuchando en http://localhost:${config.port}`)
})```
aqui les comparto mi solucion
app.get('/is_leap_year', function(req, res) {
const year=req.query.year;
const date=new Date()
date.setFullYear(year)
date.setMonth(1)
date.setDate(29)
if(date.getMonth()===1){
res.send(`el años ${year} es bifiesto`)
}else{
res.send(`el años ${year} no es bifiesto`)
}
});```
app.get('/biciesto/:year', function(req, res) {
constyear = req.params.year;
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
res.send(`El año ${year} que ingresó como parámetro es biciesto`);
} else {
res.send(`El año ${year} no es biciesto`);
}
});
En caso de usar typescript como deberia configurar las variables de entorno dentro del package.json en “scripts”? tengo claro para produccion: “start”: “set NODE_ENV=production && tsc -b && node dist/index.js”,
deberia ser algo asi pero no se… =/
“dev”: “set DEBUG=app:* && set NODE_ENV=development && tsc -b nodemon index.ts”
El momento mas esperado
Paso 1: Iniciar un proyecto de git y npm
git init
npm init -y
Paso 2: Instalar las dependencias de express y dotenv
npm i express dotenv
Paso 3: Instalar dependencias de desarrollo
npm i -D nodemon eslint eslint-config-prettier eslint-plugin-prettier prettier
Paso 4: Instalar el hook
npx mrm lint-staged
Paso 5: Configuración del hook en package.json
"husky": {
"hooks": {
"pre-commit": "lint-staged"
}
},
"lint-staged": {
"*.js": [
"eslint --cache --fix",
"git add"
]
}
Paso 6: Crear scrips de desarrollo y producción en package.json
"dev": "DEBUG=app:* nodemon index",
"start": "NODE_ENV=production node index",
Paso 7: Crear .prettierrc.json
y .eslintsrc.json
:
.prettierrc.json:
{
"tabWidth": 2,
"semi": true,
"singleQuote": true
}
.eslintsrc.json:
{
"parserOptions": {
"ecmaVersion": 2018
},
"extends": [
"eslint:recommended",
"prettier"
],
"env": {
"es6": true,
"node": true,
"mocha": true
},
"rules": {
"no-console": "warn"
}
}
Paso 8: Crear archivo de configuración
En este paso es donde se hace uso de la dependencia dotenv.
require('dotenv').config();
const config = {
dev: process.env.NODE_ENV !== 'production',
port: process.env.PORT || 3000,
}
module.exports = { config };
Paso 9: Crear archivo index del servidor
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.listen(config.port, () => {
console.log(`Listening`);
});
Express configuration
hook installation -> npx mrm lint-staged
npm dependency installation -> express and dotenv
Eslint configuration -> Begins the configuration for eslint
Platzi video back-end
Archivo .eslintrc.json:
{
"parserOptions": {
"ecmaVersion": 2018
},
"extends": ["eslint:recommended", "prettier"],
"env": {
"es6": true,
"node": true,
"mocha": true
},
"rules": {
"no-console": "warn"
}
}
Archivo .prettierrc.json:
{
"tabWidth": 2,
"semi": true,
"singleQuote": true
}
Hay un detalle importante que no se explica aquí e imagino que más adelante saldrá y es que si haces un POST a tu api el body llegará vacio. Para que el body no llegue vacío deber utilizar el middleware json() que viene con Express.
app.use(express.json());
Este fue el endPoint que cree para el challengue, problamente se pueda optimizar pero es funcional 😃
app.post('/bisiesto', (req,res) => {
if(req.body.year !== undefined || isNaN(req.body.year)){
const yearReq = req.body.year;
const year = parseInt(yearReq)
let secular = yearReq.endsWith('00');
console.log(secular);
if(secular){
if(year % 400 === 0 && year % 4 === 0){
return res.status(200).send('El año es bisiesto');
} else {
return res.status(400).send('El año no es bisiesto');
}
} else if(year % 4 === 0){
return res.status(200).send('El año es bisiesto');
}
return res.status(400).send('El año no es bisiesto');
}
return res.status(400).send('El Campor year está vacío o no es válido');
});
Hola chicos! les paso una pagina que nos ayuda a actualizar node de una manera sencillisima! https://phoenixnap.com/kb/update-node-js-version#ftoc-heading-1
Solución para el challenge de año bisiesto(leap-year), que detecta también cuando lo que se ingresa no es número
Velocidad 1.25 😄
Reto cumplido:
app.get('/fecha/:anio', function(req, res) {
const anio = req.params.anio;
if (((anio % 4 == 0) && (anio % 100 != 0 )) || (anio % 400 == 0)){
res.send('Es bisciesto');
}else{
res.send('No es bisciesto');
}
});
Completado con validación si es un número
CHallenge con Moment.JS
const express = require('express');
const app = express();
const moment = require('moment');
app.get('/', function (req, res) {
res.send("Hello world");
});
app.post('/anno', function (req, res) {
if (req.method === 'POST') {
let body = [];
req
.on("data", chunk => {
body.push(chunk);
})
.on("end", () => {
body = Buffer.concat(body).toString();
console.log(body);
let anno = body;
let fecha1 = moment(`${anno}-01-01`);
let fecha2 = moment(`${anno}-12-31`);
let diasAnno = fecha2.diff(fecha1, 'days');
if (diasAnno == 365) {
res.send("Es año bisiesto");
} else {
res.send("No es año bisiesto");
}
});
} else {
res.statusCode = 404;
res.end();
}
})
app.get('/json', function (req, res) {
res.json({ hello: 'world' });
});
Mi solución al reto
const express = require('express');
const app = express();
app.use(express.json());
app.get('/', (req,res)=>{
const data = req.body;
const isLeap = data.Year % 4;
if(isLeap === 0){
res.send('Es año bisiesto');
}else{
res.send('No es año bisiesto');
}
});
app.listen(3002, ()=>{
console.log('listening at port 3002');
});
const express = require('express');
const app = express();
const { config } = require('./config/index');
app.get('/', (req, res) => {
res.send('hello world');
});
app.get('/:year', (req, res) => {
const { year } = req.params;
console.log(year);
if (year % 4 === 0 && year % 400 === 0 && !year % 100 === 0) {
res.send('yes, its a leap-year');
} else {
res.send('no, is not a lap-year');
}
});
app.listen(config.port, () => {
console.log(`Express server Listening in http://localhost:${config.port} `);
});
Express es un framework para crear web apps, web APIs o cualquier tipo de web Service, es libre bajo la licencia de MIT.
Validar si es bisiesto o no
app.get('/:year', (req,res)=>{
anio = req.params.year
res.send(`El año ${anio} es bisiesto `+((anio % 4 == 0) && (anio % 100 != 0)) || (anio % 400 == 0))
})```
Express es un framework de NodeJs para crear servidores de una manera rápida.
Una gran ventaja de Express frente a otros frameworks es su minimalismo, debido a que la creación de servidores con Express es demasiado sencilla, nos ofrece en un modo de producción una aplicación muy ligera.
Aca mi solución
Excelente clase, gracias por los datos de configuracion inicial de express.
Solución al reto
app.get('/biciesto/:year', function(req, res) {
const year = req.params.year;
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
res.send(`El año ${year} que ingresó como parámetro es biciesto`);
} else {
res.send(`El año ${year} no es biciesto`);
}
});
Reto:
const express = require('express');
const app = express();
const {config} = require('./config/index');
app.get('/:year', (req, res) => {
let year = req.params.year;
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
res.send('Es bisiesto')
}else {
res.send('No es bisiesto')
}
})
app.get('/json', (req, res) => {
res.json('hello people')
})
app.listen(config.port, () => {
console.log(`Listening http://localhost:${config.port}`)
})```
Reto:
const express = require("express");
const app = express();
const { config } = require("./config/index");
app.use(express.json());
app.get('/year/:year', (req, res) => {
var year = req.params.year;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
res.json({
message: `El año ${year} es bisiesto`
})
} else {
res.json({
message: `El año ${year} no es bisiesto`
})
}
});
app.listen(config.port, () => {
console.log(`Listening http://localhost:${config.port}`);
});```
npx mrm lint-staged
npm i -D nodemon eslint eslint-config-prettier eslint-plugin-prettier prettier
Aquí el reto:
const express = require('express');
const app = express();
const isLeap = (year) => {
return (year % 4 == 0) ?'El año es bisiesto':'El año no es bisiesto'
}
app.get('/isLeap/:year', function(req, res) {
let message = isLeap(req.params.year);
res.send(message);
});```
Installer express y dotenv
Dependencias de desarrollo npm i -D nodemon eslint eslint-config-prettier eslint-plugin-prettier prettier
instalar npx mrm lint-staged
// challenge
const express = require('express');
const app = express();
const { config } = require('./config/index.js');
app.get('/year/:year', (req, res) => {
let year = new Date(req.params.year).getUTCFullYear();
let leapYear = year % 4 == 0 ? res.send(`el año ${year} es bisiesto`) : res.send(`el año ${year} no es bisiesto`);
res.end()
})
app.listen(config.port, () => {
console.log(`Listening http://localhost:${config.port}`);
});
Challenge:
app.get('/bisiesto/:year', (req, res) => {
res.send(
leapYear(req.params.year)
? req.params.year + ' es bisiesto'
: req.params.year + ' no es bisiesto'
);
});
function leapYear(year) {
return (year % 4 === 0 && year % 100 != 0) || year % 400 === 0 ? true : false;
}
const express = require('express');
const app = express();
app.get('/:year', (req, res) => {
const { year } = req.params;
if(year % 4 === 0) {
res.status(200).send(`The year ${ year } is leap-year`);
} else {
res.status(500).send(`Not leap-year found.`);
}
});
app.listen(3000, () => console.log('Server online');
Mi reto:
const express = require('express');
const app = express();
const { config } = require('./config/index');
app.get('/:year', function(req, res) {
let year = req.params.year;
if (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) {
res.send(`The year ${year} is leap-year`);
} else {
res.send(`The year ${year} isn´t leap-year`);
}
});
app.listen(config.port, function() {
console.log(`Listening http://localhost:${config.port}`);
});
Mi reto 😄
const express = require('express');
const app = express();
// Cuando hagamos un request de tipo GET
app.get('/', (req, res) => {
// Lo que vamos a enviar a pantalla
res.send("Envianos el año en la url escribiendo '/año'");
})
app.get('/:year', (req, res) => {
const year = req.params.year;
if (year % 4 === 0 && year % 100 !== 0) {
res.send(`El ${year} Es bisiesto`);
} else {
res.send(`Lo siento el año ${year} no es bisiesto :(`);
}
})
app.listen(2000, function () {
console.log('Litening http://localhost:2000');
})
app.get('/:year', function(req, res){
const year = req.params.year;
let isLeapYear=`El año ${year} no es bisiesto`;
if((year % 4 === 0)&&((year % 100 !== 0)||(year % 400 === 0))){
isLeapYear = `El año ${year} es bisiesto`;
}
res.send(isLeapYear);
});```
Aquí una forma mas corta de hacer el reto
app.get('/year/:year2', (req, res) => {
const leapyear = year => {
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
};
res.send(leapyear(req.params.year2)?'El año es bisiesto':'El año no es bisiesto');
});```
Anexo mi solución
app.get('/year/:year', (req, res) => {
const { year } = req.params;
const isFourDivisible = !(year % 4);
const isHundredDivisible = !(year % 100);
const isFourHundredDivisible = !(year % 400);
if (isFourDivisible && !isHundredDivisible || isFourHundredDivisible) {
res.send(`El año ${year} es bisiesto`);
} else {
res.send(`El año ${year} no es bisiesto`);
}
});
Reto:
const express = require('express');
const app = express();
const { config } = require('./config/index');
const bisiesto = (year) => {
aux=0;
if (year%4 ===0){
aux=-1;
if(year%100 ===0){
aux=0;
if (year%400 === 0){
aux=-1;
}
}else{
aux=-1;
}
}else{
aux=0;
}
if (aux===0){
year=0;
}if (aux===-1) {
year=-1
}
return (year === -1) ?'El año es bisiesto':'El año no es bisiesto';
}
app.get('/bisiesto/:year', function(req, res) {
let message = bisiesto(req.params.year);
res.send(message);
});
app.get('/json', (req, res) => {
res.json({hello: 'world'});
});
app.listen(config.port, function (){
console.log(`Listening http://localhost:${config.port}`);
});```
Aqui mi solucion al reto:
const bisiesto = year => {
if (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {
return `El año ${year} es Bisiesto`;
} else {
return `NO ES UN AÑO BISIESTO`;
}
};
app.get('/bisiesto/:year', function(req, res) {
let year = req.params.year;
let msg = bisiesto(year);
res.send(msg);
});
Mi solución al reto:
const leapYear = year => {
return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0
? `El año ${year} es bisiesto.`
: `El año ${year} NO es bisiesto.`;
};
app.get('/bisiesto/:year', function(req, res) {
const { year } = req.params;
res.send(leapYear(year));
});
function isLeapYear(year) {
if (Number(year) % 4 === 0) return true;
return false;
}
app.get('/:year', function(req, res, next) {
const { year } = req.params;
try {
const isLeapYear_ = isLeapYear(year) ? `El año ${year} es bisiesto` : `El año ${year} no es bisiesto`;
res.status(200).json({
response: isLeapYear_
})
} catch(e) {
next(e)
}
})
Reto:
const express = require('express');
const app = express();
const HOST = 'localhost'
const PORT = 8000;
function isValidYear (year) {
if (typeof(year) !== "number")
return false;
return true;
};
function isLeapYear (year) {
return year % 400 === 0 || (year % 100 !== 0 && year % 4 === 0);
}
app.get('/', (req, res) => {
const year = Number(req.query.year) || null;
if (!isValidYear(year))
return res.send(`El año: ${year}, no es valido`);
if (isLeapYear(year))
return res.send('Año Bisiesto');
return res.send('Año no Bisiesto');
});
app.listen(PORT, HOST, () => {
console.log(`listen in: http://${HOST}:${PORT}`);
});
Mi solución al reto, una variante mas larga era usar date (antes de tomar café)
const express = require('express');
const app = express();
const { config } = require('./config/index');
const bodyParser = require("body-parser")
app.use(bodyParser.text({ type: 'text/plain' }));
const isLeap = (year) => (
year % 4 === 0 ?
`${year} es año bisesto` :
`${year} no es año bisesto`
);
app.post('/yearchallenge', function (req, res) {
let message = isLeap(req.body)
res.send(message)
});
app.listen(config.port, function () {
console.log(`Listening http://localhost:${config.port}`)
});
Reto:
Mi solución al reto
const express = require('express');
const app = express();
const { config } = require('./config/index');
const anoBisiesto = fechaRequest => {
const fecha = {
dia: fechaRequest.getDate(),
mes: fechaRequest.getMonth(),
año: fechaRequest.getFullYear()
};
return (fechaRequest.año % 4 == 0 && fechaRequest.año % 100 != 0) ||
fechaRequest.año % 400 == 0
? 'Bisiesto'
: 'No es bisiesto';
};
app.post('/bisiesto', (req, res) => {
try {
let body = [];
req
.on('data', chunk => {
body.push(chunk);
})
.on('end', () => {
res.writeHead(200, { 'Content-type': 'text/plain' });
body = anoBisiesto(new Date(body));
res.end(body);
});
} catch (error) {
console.log('Error: ', error);
}
});
app.listen(config.port, function() {
console.log(`El servidor esta corriendo en el puerto: ${config.port}`);
});```
La configuracion del eslint
{
"parserOptions": {
"ecmaVersion": 2018
},
"extends": ["eslint:recommended", "prettier"],
"env": {
"es6": true,
"node": true,
"mocha": true
},
"rules": {
"no-console": "warn"
}
}
app.get("/:year",(req, res)=>{
const year = req.params.year;
if (year % 4 == 0 && year % 100 !== 0 && year % 400 !==0){
res.send(`El año ${year} es biciesto`);
} else {
res.send(`El año ${year} NO es biciesto`);
}
});
app.post("/:year", function(req, res){
let year = req.params.year
let status = ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0))
res.status(200).json({"bisiesto" : status})
})
app.get('/anio/:anio', function(req, res) {
let anio = req.params.anio;
let mod = anio % 4;
if (mod === 0) {
res.json({ bisiesto: true });
} else {
res.json({ bisiesto: false });
}
});```
Quisas otra forma…
app.get('/year/:year', (req, res) => {
const date = new Date(req.params.year, 1, 29);
res.send(`Es bisiesto?: ${date.getMonth() === 1}`);
});```
¿Cómo se llama el módulo para encontrar la ruta relativa? es una extensión de visual studio code no?
Me quedo una duda, cuando en el package.json se configura el entorno de produccion “NODE_ENV” = production node index,.
cuando se refiere a NODE_ENV esta es una variable de entorno que se creara en el despliegue?
Mi reto:
app.get('/year/:year', (req, res) => {
var yr = req.params.year;
if(Bisiesto(yr)){
res.send("Es bisiesto");
}else{
res.send("No es bisiesto);
}
});
function Bisiesto(year){
return (year % 4 === 0 && year % 100 != 0 || year % 400 === 0)
}
__
____ / /_
/ __ \/ __ \
/ /_/ / / / /
\____/_/ /_/
app.get('/bisiesto/:year', function (req, res) {
const year = Number(req.params.year);
let bisiesto = 'bisiesto';
if (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) {
bisiesto = `<h1>El año ${year} es bisiesto</h1>`
} else {
bisiesto = `<h1>El año ${year} no es bisiesto</h1>`
}
res.send(bisiesto);
})
antes de ver las respuestas elegantes, lo hice así
app.get('/year/:year', function(req, res) {
const date = new Date();
const anio = req.params.year;
const ultimoDia = new Date(anio, date.getMonth() + 1, 0).getDate();
let estadoAnio = '';
ultimoDia === 29 ? (estadoAnio = 'Es ') : (estadoAnio = 'No es');
res.send(`${anio} ${estadoAnio} bisiesto, pues febrero tiene: ${ultimoDia} días.`);
});
Mi reto:
app.get('/year/:year', function (req, res) {
const message = isBisiesto(req.params.year) ? 'The year is bisiesto' : "The year not is bisiesto";
res.send(message);
});
function isBisiesto(year) {
return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) ? true : false;
}```
app.get('/leap-year/:year', function(req, res) {
const year = req.params.year
const message = (year % 4 == 0) ? `El año ${year} es un año bisiesto` : `El año ${year} NO es un año bisiesto`
res.send(message)
})```
Reto:
const express = require('express');
const app = express();
const { config } = require('./config/index');
app.get('/bisiesto', function(req, res){
const anio = req.query.anio;
const isBisiestoText = isBisiesto(anio) ? "si": "no";
res.send(`El anio ${anio} ${isBisiestoText} bisiesto!`)
});
app.listen(config.port, function(){
console.log(`Listening in http://localhost:${config.port}`);
});
const isBisiesto = (anio) => {
return (anio % 4 == 0 && anio % 100 != 0)
};
Mi solución al reto:
const express = require("express");
const app = express();
const { config } = require("./config/index");
app.get("/", function(req, res) {
res.send("Hello world! creando un servidor con Express");
});
app.get("/json", function(req, res) {
res.json({hello: "Hello world! creando un servidor con Express"});
});
app.get("/isLeapYear/:year", function(req, res) {
let year = Number(req.params.year);
let answer="";
let isLeapYear = year%4;
!isLeapYear?answer = "Sí es año bisiesto": answer = "No es año bisiesto";
res.json({isLeapYear: answer});
});
app.listen(config.port, function() {
console.log(`Listening http//localhost:${config.port}`);
});
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?