Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

No tienes acceso a esta clase

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

Arrow functions

15/55
Recursos

En esta clase aprenderemos a utilizar Arrow Functions que permiten una nomenclatura más corta para escribir expresiones de funciones. Este tipo de funciones deben definirse antes de ser utilizadas.

Al escribir las Arrow Functions no es necesario escribir la palabra function, la palabra return, ni las llaves.

Aportes 1516

Preguntas 68

Ordenar por:

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

Arrow Functions

JS permite asignar una función a una variable. Se llama función anónima. Y se puede escribir de varias maneras:

const MAYORIA_DE_EDAD = 18

var esMayorDeEdad =function (persona) {   	
	return persona.edad >= MAYORIA_DE_EDAD
}

Sacha prefiere declararla como ‘const’ y no como ‘var’ para definir que es una función y no una variable:

const esMayorDeEdad =function (persona) {   	
	return persona.edad >= MAYORIA_DE_EDAD
}

La palabra clave ‘function’ puede reemplazarse por un ‘=>’ después de persona y se convierte en un arrow function:

const esMayorDeEdad = (persona) => {   	
	return persona.edad >= MAYORIA_DE_EDAD
}

Se pueden seguir quitando caracteres.

  • Cuando hay un sólo parámetro se pueden quitar los paréntesis
    Si una función sólo retorna un valor se puede quitar el keyword ‘return’ y las llaves {}
const esMayorDeEdad = persona => persona.edad >= MAYORIA_DE_EDAD

También se puede desestructurar el parámetro ya que sólo nos interesa la edad. Hay que agregar paréntesis:

const esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD

¿Cual es el beneficio de usar arrows functions?

¿Ahorrar gigas de texto?

¿Complicar la lectura para lo menos experimentados?

Bueno realice lo siguiente.

// torneo saga majin buu

var goku = {
  nombre: 'Goku',
  edad: 38,
  raza: 'Sayayin'
}

var vegeta = {
  nombre: 'vegeta',
  edad: 44,
  raza: 'Sayayin'
}

var gohan = {
  nombre: 'Gohan',
  edad: 18,
  raza: 'Mestizo'
}
var goten = {
  nombre: 'Goten',
  edad: 7,
  raza: 'Mestizo'
}
var trunks = {
  nombre: 'Trunks',
  edad: 8,
  raza: 'Mestizo'
}

var MAYORIA_EDAD = 18;

const esMayorEdad = ({edad}) => edad >= MAYORIA_EDAD
const esMenorEdad = ({edad}) => edad < MAYORIA_EDAD


function ingresoAltoneoAdultos (persona) {
  if (!esMenorEdad(persona)){
    console.log(`${persona.nombre} usted puede participar en el torneo de adultos, es mayor de edad`)
  }else {
    console.log(`${persona.nombre} usted no puede participar en el torneo de adultos, es menor de edad`)
  }
 }
 
 ingresoAltoneoAdultos(goku)
 ingresoAltoneoAdultos(gohan)
 ingresoAltoneoAdultos(goten)
 ingresoAltoneoAdultos(trunks)
 ingresoAltoneoAdultos(vegeta)

fue divertido mientras duro 😃

Mi reto:

const esMenorDeEdad = persona => !esMayorDeEdad(persona);

Cabe aclarar que, a diferencia de las funciones normales, las arrow function deben ser declaradas antes de ser invocadas ya que su scope no es global como el de las funciones normales.

Vimos funciones anónimas (una variable que es una funcion), los arrow function son funciones mas simplificadas donde podemos retornar algun valor de forma simplificada AL MOMENTO DE LLAMARLAS Y PASAR PARAMETROS ES TODO IGUAL.
![](

Aqui mi codigo

//Imprimiendo algo en la consola
console.log("inicializando archivo");

/*Declaración de objetos
=========================================*/

//Creando el objeto persona
var daniel = {
	nombre: "Daniel",
	apellido: "Páez",
	edad: 18,

//Creando el atributo profesion donde contenemos las profesiones que ejerce el objeto persona
	profesion: {

		ingeniero: true,
		abogado: false,
		diseñador: false,
		marketer: false,
		web: true
		//profesion: valor booleano

	}
	
}

//Otro objeto persona, similar al anterior
var javier = {
	nombre: "Javier",
	apellido: "Carrasquero",
	edad: 8,
	//profesión no aplica
}

//esta variable es mas bien una constante
const MAYORIA_DE_EDAD = 18;



/*Declaración de funciones
=========================================*/

 //Colocando dentro de una variable una funcion, version 1.0 mi funcion
var esMayorDeEdad = function (persona) {
//funcion anonima, no tiene un nombre, para invocarla se invoca a la variable
	
	return persona.edad >=  MAYORIA_DE_EDAD;
	//para retornarla tenemos que colocar return
}

/*ARROW FUNCTION version 2.0*/
var esMayorDeEdad = (persona) => {
//arrow function, no tiene un nombre, para invocarla se invoca a la variable donde va la funcion, parametro, cuerpo
	
	return persona.edad >=  MAYORIA_DE_EDAD;
	//para retornarla tenemos que colocar return
}

//EXTREME ARROW FUNCTION version 3.0 de mi funcion
var esMayorDeEdad = ({ edad }) =>  edad >=  MAYORIA_DE_EDAD;


//RETO Funcion esMenorDeEdad
const esMenorDeEdad = (persona)  => !esMayorDeEdad(persona);
/*
mi variable es igual a la funcion donde
contiene el parametro
en este caso el objeto persona
donde ejecutaremos la inversa del resultado
de la funcion es mayor de edad
*/

//funcion para imprimir en consola si el objeto persona es mayor de edad
function imprimirSiEsMayorDeEdad(persona) {

	//Daniel es mayor de edad
	if ( esMayorDeEdad(persona) ) {
		console.log(`${persona.nombre} es mayor de edad`)
	}

	//Daniel es menor dde edad
	else {
		console.log(`${persona.nombre} es menor de edad`)
	}
}

//Esta funcion permite acceso al usuario si es Mayor de edad
function permitirAcceso(persona) {
	if (!esMayorDeEdad(persona) ) {
		//imprimir en consola acceso denegado
		console.log("ACCESO DENEGADO :( ")
	}
	else {
		//imprimir en consola acceso aprobado
		console.log("ACCESO APROBADO");
	}
}


/*Ejecución de funciones
=========================================*/

permitirAcceso(daniel)
permitirAcceso(javier)
imprimirSiEsMayorDeEdad(daniel)


/* 
IDEAS CLAVES
-------------
=> Descomponer tu codigo en mini funciones te permite que:

	1 tu codigo sea mas legible
	2 tu codigo sea mas reutilizable
	3 tu codigo sea mas escalable


=> Podemos asignar a una variable una funcion
  no todos los programas permiten eso 

=> Cada numero suelto deberia ser una variable con 
un nombre que la describa


CONTROL DE ERRORES, FALLOS
=> Simplemente se me habia olvidado pedir el parametro en la linea 81

RETO
escribir la funcion es menor de edad como arrow function
donde retorne la negacion a la llamada es mayor de edad
------------------------------*/

Me podrían explicar por favor cual es el beneficio de usar const en lugar de var.

Pueden omitir las llaves del if si solo hay una línea de código dentro de ellas.
Este ejemplo

function permitirAcceso(persona) {
    if(!esMayorDeEdad(persona)) {
        console.log('ACCESO DENEGADO')
	}
}

es lo mismo que este otro

function permitirAcceso(persona) {
    if(!esMayorDeEdad(persona)) 
        console.log('ACCESO DENEGADO')
}

Así pueden escribir con un poco más de claridad

Reto completado.

var sacha = {
    nombre: 'Sacha',
    apellido: 'Lifszyc',
    edad: 28,
    ingeniero: true,
    cocinero: false,
    cantante: false,
    dj: false,
    guitarrista: false,
    drone: true
  }

  var juan = {
      nombre: 'Juan',
      apellido: 'Gomez',
      edad: 16
    }

  const MAYORIA_EDAD = 18

 //ARROWS FUNCTION
  const esMayor = ({ edad }) => edad >= MAYORIA_EDAD

//RETO

  const esMenorDeEdad = persona => (!esMayor(persona))
<code> const notLegal = ({nombre, edad}) => {
    if (!legalAge({edad})){
        console.log(`${nombre} no puede pasar.`);
    }
    else { 
        console.log(`${nombre} ya tiene pelos, no hay pedo.`);
    }
}

yo lo hice asi espero que les sirva de ayuda

  var carlos = {
    edad:20
  }

  var juan = {
    edad:15
  }

  const MAYORIA_DE_EDAD = 18

  const esMayorDeEdad = ({edad}) => edad > MAYORIA_DE_EDAD

  const esMenorDeEdad = ({edad}) => !esMayorDeEdad({edad})

  function permitirAcceso(persona) {
    if (esMenorDeEdad(persona)) {
      console.log("acceso denegado");
    }

    else {
      console.log('acceso concedido');
    }
  }

  permitirAcceso(carlos)
  permitirAcceso(juan)

Desafio:

const esMenorEdad = (personas) => !esMAyorEdad(personas);

reto:

const permitirAcceso = (persona) => {
    if(!esMayorDeEdad(persona)){
        console.log('Acceso denegado')
    }
}

Mi reto fue convertir todo a arrow functions y ocupar la menor cantidad de lineas posibles

let sacha = {nombre: 'Sacha', edad: 27}
let juan = {nombre: 'Juan', edad: 15}
const MAYORIA_DE_EDAD = 18
const esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD
const imprimirSiEsMayorDeEdad = persona => !esMayorDeEdad(persona) ? console.log(`${persona.nombre} es mayor de edad`) : console.log(`${persona.nombre} es menor de edad`)
const permitirAcceso = persona => !esMayorDeEdad(persona) ? console.log('ACCESO DENEGADO') : console.log('ACCESO PERMITIDO')
imprimirSiEsMayorDeEdad(sacha)
imprimirSiEsMayorDeEdad(juan)

Este es el reto:

<code> 
const esMenorDeEdad = (persona) =>  !esMayorDeEdad(persona)
const esMenorEdad = persona => !esMayorEdad(persona)

En este reto vi muchos que usaban el símbolo de ? pero eso no lo han explicado aun.
Mi reto según entendí el requerimiento si me pueden confirmar si esta bien, ya que no lo entendí muy bien muchas gracias de antemano

var gabriel = {
    nombre: 'Gabriel',
    apellido: 'Castillo',
    edad: 18,  
},
 otraPersona = {
    nombre: 'Camilito',
    edad: 12
}
const esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD
const esMenorDeEdad = ({ edad }) => !esMayorDeEdad({edad})



Resultado

var permitirAcceso = ({edad}) => !esMayorDeEdad ({edad}) ?  console.log('Acceso Negado') : console.log(' Bienvenidoo');

Aqui mi solución al reto

const permitirAcceso = ({ edad }) => !esMayorDeEdad({ edad }) ?  "ACCESO DENEGADO"  :  "ACCESO PERMITIDO" ;
console.log( permitirAcceso( persona ) )

Esto lo conocí hace poco pero lo intento usar siempre que puedo

Espero haber hecho lo que pedía Sasha en el desafío.


var oscar = {
  nombre: 'Oscar',
  edad: 36
}

var andres = {
  nombre: 'Andres',
  edad: 16
}

const MAYORIA_DE_EDAD = 18;

const esMayorDeEdad = persona => persona.edad >= MAYORIA_DE_EDAD;

const esMenoDeEdad = persona => !esMayorDeEdad(persona);

function permitirAcceso(persona)
{
  if (esMenoDeEdad(persona))
  {
    console.log('Acceso Denegado');
  }
}


El codigo de la clase anterior mas esta resumido!

let user = {
  nombre: prompt('Ingresa tu nombre'),
  apellido: prompt('Ingresa tu apellido'),
  edad: parseInt(prompt('Ingresa tu edad'))
}
const MAYORIA_EDAD = 18;

const mayor_edad = ({ edad }) => edad >= MAYORIA_EDAD;

const imprimir_mayor_edad = ({ edad }) => !mayor_edad({ edad }) ? console.log(`${user.nombre} ${user.apellido} es menor de edad no tiene ACCESO`): console.log(`${user.nombre} ${user.apellido} es mayor de edad tiene ACCESO`);

imprimir_mayor_edad(user);

Mi aporte 😃

 const permitirAcceso = (persona) => !esMayorDeEdad(persona) ? console.log('ACCESO DENEGADO') :  console.log('ACCESO CONCEDIDO');
 
 permitirAcceso();
const juan = {
    nombre: 'Juan',
    edad: 17
}

const MAYORIA_DE_EDAD = 18;

const esMayorDeEdad = ({edad}) => edad <= MAYORIA_DE_EDAD; 

const accesoRestringido = ({edad}) => !esMayorDeEdad({edad}) ? console.log(`Ya eres mayor!`) : console.log(`sorry ${juan.nombre} aun no alcanzas la Edad minima`);
// sorry Juan aun no alcanzas la Edad minima

Reto Completado 😃

Aquií le comparto un poco de mi código!


const NoEsMayorDeEdad = ({ edad }) => edad < MAYORIA_DE_EDAD

function permitirAcceso(persona) {
    if (NoEsMayorDeEdad(persona)) {
        console.log('ACCESO DENEGADO')
    }
}```

Muy bien entendido

const esMenorDeEdad= ({edad}) => !(edad>= MAYORIA_DE_EDAD)

Mi respuesta al reto

const responseOfAccess = ({ edad }) => esMayorDeEdad({ edad }) ? 'Acceso permitido' : 'Acceso Denegado'

const access = (persona) => console.log(responseOfAccess(persona))

michael = {

  nombre: 'Michael',
  edad: 18

}

access(michael)

//Reto arrow function

var Countries = [
        {
          name: "venezuela",
          adultAge: 18
        },
        {
          name: "peru",
          adultAge: 19
        },
        {
          name: "colombia",
          adultAge: 22
        },
        {
          name: "argentina",
          adultAge: 30
        }
      ];

      var Pedro = {
        name: "Pedro",
        age: 22,
        email: "[email protected]",
        country: Countries[3].name,
        adultInCountry: Countries[3].adultAge
      };
      var Leonardo = {
        name: "Leonardo",
        age: 20,
        email: "[email protected]",
        country: Countries[0].name,
        adultInCountry: Countries[0].adultAge
      };

      //ARROW FUNCTION
      const IS_ADULT = ({ age, adultInCountry }) => age >= adultInCountry;

      function Adult(person) {
        if (IS_ADULT(person)) {
          console.log(`${person.name} es mayor de edad en ${person.country}`);
        } else {
          console.log(
            `${person.name} no es mayor de edad en ${person.country}`
          );
        }
      }

      //arrow function
      const ACCESS = person => {
        if (!IS_ADULT(person)) {
          console.log(`ACCESO DENEGADO PARA EL USER ${person.email}`);
        } else {
          console.log(`ACCESO PERMITIDO PARA EL USER ${person.email}`);
        }
      };

      Adult(Pedro);
      ACCESS(Pedro);
      Adult(Leonardo);
      ACCESS(Leonardo);

var esMenorDeEdad = (persona) => !esMayorDeEdad(persona)

Aca les dejo mi codigo con la funcion crear personas

var MAYORIA_EDAD = 18
var n_persona = 0
function crear_persona(n,a,e,p){
n_persona =n_persona+1
  return  a = {
    ident : n_persona,
    nombre : n,
    apellido: a,
    edad : e,
    profesion : p
  }
}
const esMayordeEdad = ({edad})=> edad >= MAYORIA_EDAD

function imprimirSiEsMayor(persona){
  if(esMayordeEdad(persona)){
    console.log(`${persona.nombre} es mayor de edad y su id es:${persona.ident}`)
  }else {
    console.log(`${persona.nombre} es menor de edad`)
  }
}

persona1=crear_persona('Antonio','Delgado',31,'ingeniero')
persona2=crear_persona('Genesis','Paredes',15,'estudiante')
const permitirAcceso = ({edad})=> {if(!esMayordeEdad({edad}))console.log('Deny')}```

const IS_MINOR = ({ age }) => !IS_LEGAL({ age })

const MAYORIA_DE_EDAD = 18
const esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD
const esMenorDeEdad = ({ edad }) => !esMayorDeEdad({ edad })```

Muy buena clase, un poco compleja pero muy buena!!

const permitirAcceso = persona => {
	if (!esMayorDeEdad(persona)) {
		console.log("ACCESO DENEGADO");
	} else {
		console.log("ACCESO CONCEDIDO");
	}
};

Uno de los mejores profesores de platzi

reto de la clase:

const  permitirAcceso = (persona)=> !esMayorDeEdad(persona) ?
console.log(`${persona.nombre} NO tiene la edad suficiente (${persona.edad} años), acceso denegado`):
console.log(`${persona.nombre} tiene la edad suficiente (${persona.edad} años) , acceso permitido`)

Haciendo un poco de trampa xD

RETO

const esMayorDeEdad = ({edad}) => edad >= MAYORIA_DE_EDAD
const esMenorDeEdad = ({edad}) => edad < MAYORIA_DE_EDAD

function permitirAcceso(persona){
  if (esMayorDeEdad(persona)) {
    console.log('ACCESO PERMITIDO XD');
  }

  if (esMenorDeEdad(persona)) {
      console.log('ACCESO DENEGADO -.-');
  }
}
var Sacha = {
  nombre: 'Sacha',
  apellido:'Lifszyc',
  edad: 28
}

var Dario = {
  nombre: 'Luis Darío',
  apellido: 'Susnisky',
  edad: 15
}

const MAYORIA_DE_EDAD = 18

const esMayorDeEdad = ({edad}) => edad >= MAYORIA_DE_EDAD
const esMenorDeEdad = ({edad}) => edad < MAYORIA_DE_EDAD

function permitirAcceso(persona){
  if (!esMayorDeEdad(persona)){
    console.log('Acceso denegado. No es mayor de edad.');
  } if(!esMenorDeEdad(persona)) {
    console.log('Acceso autorizado.');
  }
}```

Asignarle a una variable una función se denomina expresión funcional

const esMenorDeEdad = (persona) => !esMayorDeEdad(persona)

Echo!

var menorEdad = sujeto => {
  if(!mayor(sujeto))
  {
    console.log("Vete de aqui!")
  }
}

Variables

var anacleta =
{
  nombre: "Anacleata",
  años: 14
}

var julio =
{
  nombre: "Julio",
  años: 20
}

const MAYOR_EDAD =
{
  colombia: 18
}

function mayor(sujeto)
{
  return sujeto.años >= MAYOR_EDAD.colombia
}

Por fin lo logre.

Las arrow functions nos permiten declarar funciones mas cortas pero con declaraciones un poco difícil de entender .

var alguien = {
  nombre: 'La persona ',
  edad: 20
}

var alguien2 = {
  nombre: 'La persona ',
  edad: 10
}

const MAYORIA_DE_EDAD =18


// function MayoriaDeEdad(persona){
//   return persona.edad >= MAYORIA_DE_EDAD
// }

const MayoriaDeEdad = ({edad})=> edad >= MAYORIA_DE_EDAD

const MenorDeEdad = ({edad}) => edad < MAYORIA_DE_EDAD
 
function Profesiones(persona){
  if(MayoriaDeEdad(persona)){
    console.log(`${persona.nombre} es mayor de edad`)
    permitirAcceso(persona)
  }
  if(MenorDeEdad(persona)){
    console.log(`${persona.nombre} es menor de edad`)
    permitirAcceso(persona)
  }
}


function permitirAcceso(persona){
  if(!MayoriaDeEdad(persona)){
    console.log('Acceso Denegado')
  }
  if(!MenorDeEdad(persona)){
    console.log('Acceso Permitido')
  }
}```
const MAYORIA_DE_EDAD = 18;

esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD;
esMenorDeEdad = ({ edad }) => !esMayorDeEdad({ edad }) 

Resultado de Reto:

const EDAD_BASE=18;
var aby={
    nombre: 'aby',
    apellido:'leyva',
    edad:21,
    ingeniero : true,
    cocinero : false,
    programador: true
}
var alex={
    nombre: 'Alex',
    apellido:'Leyva',
    edad:10,
}

//Arrow Functions
const esMayorDeEdad =  ({edad}) => edad >= EDAD_BASE

const esMenorDeEdad = persona => !esMayorDeEdad(persona)
 

Muestra de la consola de Chrome

esMayorDeEdad(aby)
true
esMayorDeEdad(alex)
false
esMenorDeEdad(aby)
false
esMenorDeEdad(alex)
true

Byegon

Yo entendí que el reto es así

const esMenorDeEdad = ({ edad }) => edad < MAYORIA_DE_EDAD

function imprimirSiesMenorDeEdad(persona) {
  if (!esMayorDeEdad(persona)){
    console.log(`${persona.nombre} es menor de Edad`)
  }

}

Es lo que entendí para resolver el reto.

const MAYORIA_DE_EDAD = 18

const esMayorDeEdad = ({edad}) =>  edad >= MAYORIA_DE_EDAD

const esMenorDeEdad = (persona) =>  !esMayorDeEdad(persona)

function permitirAcceso(persona){
  if(esMenorDeEdad(persona)){
    console.log('ACCESO DENEGADO!!!')
  }
}

Solución al reto

const permitirAcceso = ({ edad }) => {
  !mayoriaEdad({ edad }) 
  console.log('ACCESO DENEGADO')
}
const MAYORIA_DE_EDAD = 18
var esMayorDeEdad = ({edad}) => edad >= MAYORIA_DE_EDAD
var esMenorDeEdad = persona => !esMayorDeEdad(persona)
function imprimirSiEsMenorDeEdad(persona){
    if(esMenorDeEdad){
        console.log('Es menor de edad')
    }else {
        console.log('Es mayor de edad')
    }
}

const MAYORIA_DE_EDAD = 18;

const esmayordeedad = ({edad}) => edad >= MAYORIA_DE_EDAD

const esMenorDeEdad = persona => !esmayordeedad(persona)

const imprimir = persona => {
  if(esmayordeedad(persona)){
    console.log(`bienvenido ${persona.nombre} eres mayor de edad`)
  }else if(esMenorDeEdad(persona)){
    console.log(`Lo siento ${persona.nombre} no eres mayor de edad :c`)
  }
}
const entrada = persona => !esMayorDeEdad(persona) ? 'Acceso Denegado'
 var bryan = {
   nombre: 'Bryan',
   edad: 25
 }

 var manuel = {
   nombre: 'Manuel',
   edad: 15
 }


 const MAYOR_DE_EDAD = 18

   EsMayorDeEdad = (persona) => {
   return persona.edad >= MAYOR_DE_EDAD
 }

    permitirEntrada = (persona) => {
     if (!EsMayorDeEdad(persona)) {
       console.log(`ACCESO PROHIBIDO`)
     }
     else 
     console.log(`ACCESO AUTORIZADO`)
   }

   permitirEntrada(bryan)
   permitirEntrada(manuel)


   /* MI critereio para 
   resolver este reto fue:
   1. Crear dos objetos
   2. crear una constante = 18
   3. Crear una funcion retornando
   la edad del objeto
   4. Crear un funcion usando
   if! (si no es mayor de edad) imprime
   el mensaje acceso prohibido
   5. else si es mayor de edad imprime
   acceso autorizado
   6. Imprimir el mensaje de la funcion
    permitirEntrada(bryan)
    permitirEntrada(manuel)*/```

Aquí les dejo documentación acerca de las Arrow functions me ayudo mucho a entender esta nueva nomenclatura https://desarrolloweb.com/articulos/arrow-functions-es6.html

¿cuál es la ventaja de escribir una función como variable?

Hola, esta fue mi manera de resolverla, hay un condicional que se llama operador ternario y que tiene un muy buen uso en Arrow Functions, se que no lo han explicado. pero valdría la pena leer un poco por su utilidad os dejo aquí.

        var carlos = { nombre: 'Carlos', edad: 37 }
        var denisse = { nombre: 'Denisse', edad: 17 }

        const MAYORIA_DE_EDAD = 18

        const esMayorDeEdad = persona => persona.edad >= MAYORIA_DE_EDAD ?
            `${persona.nombre} es mayor de edad` : `${persona.nombre} es menor de edad`;

        const puedeEntrar = ({ edad }) => !esMayorDeEdad ? 'Acceso Denegado' : 'Acceso Concedido';

Resumen y reto

/* Resumen */
var gustavo = {
  nombre: "Gustavo",
  apellido: "Tiseira",
  edad: 30,
  ingeniero: true,
  concinero: false,
  cantante: false,
  poker: true
};

var juan = {
  nombre: "Juan",
  apellido: "Perez",
  edad: 13
};

const MAYORIA_DE_EDAD = 18;

/* --------------------------Arrow functions-------------------------------------- */

/* var esMayorDeEdad2 = function(persona) {
    return persona.edad >= MAYORIA_DE_EDAD;
  };
  function imprimirSiEsMayorDeEdad2(persona) {
    if (esMayorDeEdad2(persona)) {
      console.log(`Genial ${persona.nombre} eres mayor de edad.`);
    } else {
      console.log(`Ups ${persona.nombre} eres menor de edad.`);
    }
  } */

/* -------------INICIO---------Arrow functions-------------------------------------- */
/* 
  * Elimino la palabra function.
  * Si tiene un solo parametro en la funcion puedo 
    obviar los ( ).
  * El conjunto (parametro = >) ES IGUAL A UNA FUNCION
  * Si una funcion lo unico que hace es retonar algo
    podemos borrar return y borrar { }.
*/

/* var esMayorDeEdad2 = persona => persona.edad >= MAYORIA_DE_EDAD; */

/* Destructurando el parametro */
const esMayorDeEdad2 = ({ edad }) => edad >= MAYORIA_DE_EDAD;
/* La funcion esMayorDeEdad2 le pasamos un objeto que tiene una edad ({ edad })
y nos va a retornar si se cumple edad >= MAYORIA_DE_EDAD*/
/* -------------FIN---------Arrow functions-------------------------------------- */

function imprimirSiEsMayorDeEdad2(persona) {
  if (esMayorDeEdad2(persona)) {
    console.log(`Genial ${persona.nombre} eres mayor de edad.`);
  } else {
    console.log(`Ups ${persona.nombre} eres menor de edad.`);
  }
}

imprimirSiEsMayorDeEdad2(gustavo);

/* ------------------------------------------------------------------------- */
function permitirAcceso(persona) {
  if (!esMayorDeEdad2(persona)) {
    console.log("Acceso denegado");
  }
}

/* ---------------------------------Reto---------------------------------------- */
/* Creo una funcion con nombre esMenorDeEdad tipo arrow functions
le asigno la negacion de la funcion esMayorDeEdad2, en su parametro ({ edad })*/
const esMenorDeEdad = ({ edad }) => !esMayorDeEdad2({ edad });


Reto:

const permitirAcceso = ({edad}) => !esMayorDeEdad({edad}) ? console.log('ACCESO DENEGADO') : console.log('ACCESO PERMITIDO')
const esMenorDeEdad = persona => !esMayorDeEdad(persona);

HOLA CHICOS, ESTA BIEN ASI ?

No se si entendí bien el ejercicio pero aquí esta

const MAYORIA_DE_EDAD = 18;

var sacha = {
    nombre : 'sacha',
    edad : 1
}

var luis = {
    nombre : 'luis',
    edad : 19
}

const esMayorDeEdad = edad => edad >= MAYORIA_DE_EDAD;
const esMenorDeEdad = ({edad}) => !esMayorDeEdad(edad);


function imprimirSiEsMenorDeEdad(persona){
    if (esMenorDeEdad(persona)){
        console.log(`${persona.nombre} es menor de edad`);
    }else{
        console.log(`${persona.nombre} es mayor de edad`);
    }
}

imprimirSiEsMenorDeEdad(sacha);
imprimirSiEsMenorDeEdad(luis);

Aquí va el mío 😃 gracias por esta clase!

var carlos = {
    nombre: "Carlos",
    apellido: "Gonzozky",
    edad: 2
}

const MAYORIA_DE_EDAD = 18


function imprimirSiEsMayorDeEdad(persona) {
    esMayorDeEdad(persona) ? console.log(`${persona.nombre} es mayor de edad`) : console.log(`${persona.nombre} no mayor de edad`)
}

const esMayorDeEdad = ({edad}) => edad >= MAYORIA_DE_EDAD

const esMenorDeEdad = ({edad}) => !esMayorDeEdad(edad)

Ha sido una clase súper interesante, he aprendido demasiado sobre funciones, he aquí mi pequeño aporte.

const MAYORIA_DE_EDAD = 18;
const MINORIA_DE_EDAD = 17;

var datosPersonales = {
    nombre: "Alex",
    apellido: "Rubio",
    edad: 27,
};

var personalData = {
    nombre: "Eliza",
    apellido: "Nureña",
    edad: 17,
};

const ES_MAYOR_DE_EDAD = ({edad}) => edad >= MAYORIA_DE_EDAD;
const ES_MENOR_DE_EDAD = ({edad}) => edad <= MINORIA_DE_EDAD;

function imprimirSiEsMayorDeEdad(persona){
    console.log(persona.nombre + ":")
    if(ES_MAYOR_DE_EDAD(persona)){
        console.log("Es mayor de edad");
    }else{
        console.log("Es menor de edad");
    }
}

function permitirAcceso(persona){
    if(!ES_MAYOR_DE_EDAD(persona)){
        console.log(persona.nombre + " TIENES EL ACCESO DENEGADO");
    }else{
        console.log(persona.nombre + " PUEDES INGRESAR");
    }
}

function permitirAcceso(persona){
    if(ES_MAYOR_DE_EDAD(persona)){
        console.log(persona.nombre + " PUEDES INGRESAR");
    }else{
        console.log(persona.nombre + " TIENES EL ACCESO DENEGADO");
    }
}

function permitirAcceso(persona){
    if(ES_MENOR_DE_EDAD(persona)){
        console.log(persona.nombre + " TIENES EL ACCESO DENEGADO");
    }else{
        console.log(persona.nombre + " PUEDES INGRESAR");
    }
}

permitirAcceso(datosPersonales);
permitirAcceso(personalData);

imprimirSiEsMayorDeEdad(datosPersonales);
imprimirSiEsMayorDeEdad(personalData);

Aqui mis notas y reto juntos:

/*Notas Josué Camacho*/
const MAYORIA_DE_EDAD = 18

var josue = {
    nombre : "josue",
    edad : 33
}

var santiago = {
    nombre : "santiago",
    edad : 12
}

// function esMayorDeEdad(persona){
//     return persona.edad >= MAYORIA_DE_EDAD
// }

//Funcion Anonima
var esMayorFnAnonima = function (persona){
    return persona.edad >= MAYORIA_DE_EDAD
}


//ARROW FUNCTION
var esMayorArrow =  (persona) => {
    return persona.edad >= MAYORIA_DE_EDAD
}

/* simplificacion */
var esMayorArrowSimplificada = persona => persona.edad >= MAYORIA_DE_EDAD

//desestructurar el objeto
var esMayorArrowDesestructurada = ({edad}) => edad >= MAYORIA_DE_EDAD


function imprimeSiEsMayorDeEdad(persona){

    if(esMayorArrowDesestructurada(persona)){
        console.log(`${persona.nombre} es mayor de edad`)
    } else{
        console.log(`${persona.nombre} es menor de edad`)
    }

}

imprimeSiEsMayorDeEdad(josue)

/*RETO*/

//Es menor de edad Arrow 
//que retorne la negacion de la llamada a es mayor de edad
var esMayorDeEdad = persona => persona.edad >= MAYORIA_DE_EDAD
var esMenorEdad = persona => !esMayorDeEdad(persona) 
var juan = {
      nombre : 'Juan',
      apellido : 'Campos',
      edad : 48,
      mecanico : true,
      cocinero : false,
      programador : true,
      guitarrista : false
}
var adrian = {
  nombre : 'Adrian',
  apellido : 'Campos',
  edad : 7,
  estudiante : true,
}
const MAYORIA_DE_EDAD = 18
//var esMayorDeEdad = function(persona) {
//  return persona.edad >= MAYORIA_DE_EDAD
//}
//const esMayorDeEdad = (persona) => persona.edad >= MAYORIA_DE_EDAD
const esMayorDeEdad  = ({edad})=> edad >= MAYORIA_DE_EDAD
function imprimirSiEsMayorDeEdad(persona) {
  if(esMayorDeEdad(persona)){
    console.log(`${persona.nombre} es mayor de edad`)
    }else{
    console.log(`${persona.nombre} es menor de edad`)
    }
}
function permitirAcceso(persona) {
  if (!esMayorDeEdad(persona)) {
    console.log('Acceso Denegado')
  }
}
const esMenordeEdad = persona => !esMayorDeEdad(persona)
function menorDeEdad(persona) {
  if(!esMayorDeEdad(persona))
  console.log(`${persona.nombre} es menor`)

}
  imprimirSiEsMayorDeEdad(juan)
  imprimirSiEsMayorDeEdad(adrian)

Reto lo más optimizado del código que me corrió… Sugerencias

const MAYORIA_DE_EDAD = 18
const MenorEdad = ({edad}) => edad < MAYORIA_DE_EDAD

function permitirAcceso(persona) {
    var tiempo = MAYORIA_DE_EDAD - persona.edad;
    if (MenorEdad(persona)) {
        console.log(`${persona.nombre} eres menor de edad y te faltan ${tiempo} años`)
    } else {
        console.log ('Acceso Permitido')
    }
}

Hola Comunidad!
les comparto este apunte del PROCESO DE METAMORFOSIS entre una función y una función flecha. Yo tuve que escribirlo asi detallado xq como vengo de Dart que es fuertemente tipado, una de las cosas que más me esta costando es la diverisdad en la sintaxis de JS

// Reto: negación de función esMayorDeEdad
const esMenorDeEdad = persona => !esMayorDeEdad(persona)

Reto Cumplido

Las arrow functions nos permite simplificar código

  • Inicialmente debe definirse a una variable
var esMayorDeEdad = function (persona)
{
   return persona.edad>=MAYORIA_DE_EDAD
}

Aquí se la denomina función anónima

Para convertirse en arrow function debemos tomar en cuenta estos detalles

  • Se puede quitar la palabra function
  • Si sólo se tiene un parámetro se puede quitar los paréntesis
const esMayorDeEdad=persona => { 
    return persona.edad>=MAYORIA_DE_EDAD
  
}
  • Si la función retorna un valor también podemos quitar la palabra return y también las llaves que conforma el cuerpo de la función
const esMayorDeEdad=persona => persona.edad>=MAYORIA_DE_EDAD
  • Como buena práctica podemos definir la arrow function con const para así poder diferenciarla de una variable

Creo que asi es correcto, ¿alguien me puede confirmar?

// Ejercicio
const esMenorDeEdad = ({edad}) => edad < MAYORIA_DE_EDAD

function permitirAcceso(persona) {
  if(esMenorDeEdad(persona)){
    console.log('ACCESO DENEGADO')
  }
}

Reto:

var david = {
    nombre: 'David',
    edad: 26
}

var snow = {
    nombre: 'Snow',
    edad: 6
}

const MAYORIA_EDAD = 18

validarMayoriaEdad = ({edad}) => edad >= MAYORIA_EDAD

function esMenorEdad({nombre, edad})
{
    if(validarMayoriaEdad({edad}))
    {
        console.log(`${nombre}, tienes ${edad} años, eres mayor de edad`)
    }
    else
    {
        console.log(`${nombre}, tienes ${edad} años, eres menor de edad`)
    }
    permitirAcceso({edad})
}

const permitirAcceso = ({edad}) => {
    if(!validarMayoriaEdad({edad}))
    {
        console.log('Acceso denegado')
    }
    else 
    {
        console.log('Acceso aprobado')
    }
}

esMenorEdad(david)
esMenorEdad(snow)
const esMenorDeEdad = persona => !esMayordeEdad(persona);

Me gustó mucho esta clase, no había visto el uso de arrow functions. Incorporé respuestas condicionales de true o false que mostrarón en el IG de platzi

const PermitirAcceso = ({edad}) => (edad < MayoriaDeEdad)? 'Acceso denegado':'Tiene Acceso'
PermitirAcceso(camila)

No entendí correctamente el qué pedía el reto, pero lo hice tal cual lo entendí.

const esMayorDeEdad = ({ edad }) => edad >= MAYORIA_DE_EDAD
const esMenorDeEdad = ({ edad }) => edad <= MAYORIA_DE_EDAD

function permitirAcceso(persona) {
    if(!esMayorDeEdad(persona)){
        console.log('Acceso denegado')
    }else{
        console.log('Acceso concedido')
    }
}

imprimirSiEsMayorDeEdad(german)```

Comparto la solución al reto 😃

Ready!!!

function permitirAcceso(persona) {
  if(esMenorDeEdad(persona)) {
    console.log('ACCESO DENEGADO')
  } else {
    console.log('ACCESO CONCEDIDO')
  }
}

//Escribir función esMenorDeEdad como ArrowFunction y que retorne
//la negación de la llamada a es mayor de edad
const esMenorDeEdad = ({edad}) => edad < MAYORIA_DE_EDAD
const esMenorDeEdad = ({edad}) => !esMayorDeEdad({edad});

//Tengo duda porque no permitio solo poner edad en el parametro de mayor de edad asi !esMayorDeEdad(edad), tenia que desestructurar el objeto
//ARROW FUNCTION (retorna un valor en este caso true o false)
const esMayorDeEdad = ({edad}) => edad >= MAYORIA_DE_EDAD;

function imprimirSiEsMayorDeEdad(persona){
    if(esMayorDeEdad(persona)){
        console.log(`${persona.nombre} es mayor de edad.`)
    } else{
        console.log(`${persona.nombre} es menor de edad.`)
    }
};

imprimirSiEsMayorDeEdad(persona);
var sergio = {
    name: 'Sergio',
    last: 'Medina',
    age: 35
}

var juan = {
    name: 'Juan',
    last: 'Lopez',
    age: 16
}

const mayor_edad = 18

const esMayor = ({age}) => age >= mayor_edad

const esMenor = ({age}) => age < mayor_edad

function permitirAcceso (persona) {
    if (!esMenor(persona)){
        console.log(`ACCESO PERMITIDO`)
    }
    else {
        console.log(`ACCESO DENEGADO`)
    }
}```
const itsAdult = ({firstName, lastName, age}) => console.log(age >= 18 ? `${firstName} ${lastName} es mayor de edad` : `${firstName} ${lastName} es menor de edad`) 

Apuntes y reto:

//Arrow functions
var natanael = {
    nombre: 'natanael',
    apellido: 'león',
    edad: 30,
}
var liam = {
    nombre: 'liam',
    apellido: 'león',
    edad: 3,
}

/*si es una constante y no varía podemos indicarlo cambiando var por const en vez de var y escribirlo en mayuscula y separarlo por _*/
const MAYORIA_DE_EDAD = 18

/* Arrow Function
a una variable se le puede asignar una función:
Pequeña función: 
const esMayorDeEdad = function (persona){
    return persona.edad >= MAYORIA_DE_EDAD
}
no todos los lenguajes de programación lo permiten JS sí

y se invoca como una funcion normal aunque este en una variable:
de igual manera el siguente código equivale a lo que tenemos comentado

cuando hay un solo parametro dentro de la función podemo eliminar los parentesis

si una funcion lo que hace es retornar algo podemos borrar el return y las llaves e implicitamente hace lo que debe hacer en este caso una comparación */
const esMayorDeEdad = persona => persona.edad >= MAYORIA_DE_EDAD

/*para desestructurar sería de la siguiente manera: 
const esMayorDeEdad = ({ edad }) => persona.edad >= MAYORIA_DE_EDAD
*/

function imprimirSiEsMayorEdad(persona){
    console.log(`${ persona.nombre } tiene`)
    //pequeña función inbocada
    if (esMayorDeEdad(persona))
    {
        console.log(`${persona.edad} años y es mayor de edad`)
    } else console.log(`${persona.edad} años y es menor de edad`)
}

imprimirSiEsMayorEdad(natanael)
imprimirSiEsMayorEdad(liam)

//!=negación
function permitirAcceso(persona){
if(!esMayorDeEdad(persona)){
    console.log(`ACCESO DENEGADO PARA ${persona.nombre.toUpperCase()} POR SER MENOR DE EDAD`)
}else console.log(`ACCESO CONCEDIDO PARA ${persona.nombre.toUpperCase()} POR SER MAYOR DE EDAD`)
}
permitirAcceso(liam)
permitirAcceso(natanael)

SALIDA EN CONSOLA:
![](

No me quedo claro el concepto de Arrow Functions, así que encontré este tutorial Que lo explica muy bien, lo recomiendo mucho. ( Esta en Inglés)

Ventajas de las “Arrow Functions”:

  • Reduce la cantidad de codigo cuando se escriben “Anonymous functions”
  • Cambia el uso del objeto this ( Recomiendo este link si quieres entender mejor el uso de la palabra
/*  Apuntes de clase */

var usuario1 = { //Se crea un primer objeto 
    nombre:'Jaime',
    edad:54
}

var usuario2 = { //Se crea un segundo objeto 
    nombre:'Pedro',
    edad:12
}

const MAYORIA_DE_EDAD = 18; //Declaramos una constante, su nombre por buenas practicas debe estar en mayusculas y separado por guiones

var esMayorDeEdad = function (persona){ //Esta es una funcion anonima y se almacena en una variable
    return persona.edad >= MAYORIA_DE_EDAD; //La funcion retornara un true o false 
}

//Esta es una arrow fuction
const esMayorDeEdad2 = persona => { //si la funcion tiene un solo parametro se pueden omitir los ( )
    return persona.edad >= MAYORIA_DE_EDAD
}

//podemos simplicar la arrow fuction si queremos retornar de forma directa

const esMayorDeEdad3 = persona => persona.edad >= MAYORIA_DE_EDAD // se eliminan las llaves para indicar que la funcion va a retornar un valor

//En lugar de pasar todo el objeto, podemos solo pasarle por parametro solo un valor

const esMayorDeEdad4 = ({edad}) => edad >= MAYORIA_DE_EDAD // Nuevamente colocamos () y entre {} la clave del objeto para obtener su valor

// function imprimirEstatusDeEdad(persona){
//     if (esMayorDeEdad4(persona)){//Invocamos a la funcion desde la variable esMayorDeEdad
//         console.log(`${persona.nombre} es mayor de edad`);
//     }else {
//         console.log(`${persona.nombre} es menor de edad`);
//     };
// }

const imprimirEstatusDeEdad = usuario => {
    if (esMayorDeEdad4(usuario)){
        console.log(`${usuario.nombre} es mayor de edad`);
    } else {
        console.log(`${usuario.nombre} es menor de edad`);
    }
} 

const permitirAcceso = (usuario) => {
    if(esMayorDeEdad4(usuario)){// Le pasamos a la funcion como parametro todo el objeto 
        console.log('acceso permitido');
    }else{
        console.log('acceso denegado')
    }
}

// function permitirAcceso(persona){
//     if(!esMayorDeEdad4(persona)){
//         console.log("Acceso denegado");
//     }else {
//         console.log("Acceso permitido")
//     }
// }

imprimirEstatusDeEdad(usuario1);
imprimirEstatusDeEdad(usuario2);
permitirAcceso(usuario1);
permitirAcceso(usuario2);```