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:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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 [email protected]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 鈥渄ev鈥: 鈥渟et 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 鈥榩orque 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:
鈥渄ev鈥: 鈥淒EBUG=app:* nodemon index -e js,hbs,html,css鈥,

Windows:
鈥渄ev鈥: 鈥渟et DEBUG=app:* &nodemon index -e js,hbs,html,css鈥

Si no les funciona npx mrm lint-staged es por que ahora es: npx [email protected] 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 鈥渟cripts鈥? tengo claro para produccion: 鈥渟tart鈥: 鈥渟et NODE_ENV=production && tsc -b && node dist/index.js鈥,

deberia ser algo asi pero no se鈥 =/
鈥渄ev鈥: 鈥渟et 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 鈥淣ODE_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}`);
});