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?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Creando tu primer servidor con Express.js

18/48
Recursos

Aportes 160

Preguntas 21

Ordenar por:

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

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:

  1. Usar estos scripts:
"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.

  1. instalar cross-env: 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}`)
})

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

<h3>Como obtener años bisiestos en javascript.</h3>

Aqui les dejo un pequeño tutorial de como hacerlo. Comunidad platzi

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

Hola a todos. Aquí dejo un resumen de cada uno de los pasos que se hicieron en la clase.

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}`);
});