Introducción al curso
¡Alto! Tenemos una nueva versión de este curso para ti
Bienvenidos al Curso de Fundamentos de JavaScript
Repositorio de este curso de fundamentos de JS
Primeros pasos en JavaScript
Variables
Variables: Strings
Variables: Números
Funciones
El alcance de las funciones
Objetos
Desestructurar objetos
Parámetros como referencia o como valor
Comparaciones en JavaScript
Estructuras de Control y Funciones
Condicionales
Funciones que retornan valores
Arrow functions
Estructuras repetitivas: for
Estructuras repetitivas: while
Estructuras repetitivas: do-while
Condicional múltiple: switch
Arrays
Introducción a arrays
Filtrar un array
Transformar un array
Reducir un array a un valor
Programación Orientada a Objetos en JavaScript
Cómo funcionan las clases en JavaScript
Modificando un prototipo
El contexto de las funciones: quién es this
La verdad oculta sobre las clases en JavaScript
Clases en JavaScript
Asincronismo
Funciones como parámetros
Cómo funciona el asincronismo en JavaScript
Cómo funciona el tiempo en JavaScript
¿Qué pasó con swapi.co?
Callbacks
Haciendo múltiples requests
Manejando el Orden y el Asincronismo en JavaScript
Manejo de errores con callbacks
Promesas
Promesas Encadenadas
Múltiples promesas en paralelo
Async-await: lo último en asincronismo
Juego de HTML
Comenzando el juego
Generando una secuencia de números
Iluminando la secuencia de colores
Obteniendo el input del usuario
Agregando la verificación del color elegido
Agregando los estados finales del juego
Conclusiones del curso
Complementos
Diferencias entre var, let y const
Memoización: ahorrando cómputo
¿Hace cuántos días naciste?
Funciones recursivas
Entiende los closures de JavaScript
Estructuras de datos inmutables
Cambiando de contexto al llamar a una función
¿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
En esta clase aprenderemos como filtrar los arrays. Para filtrar siempre necesitamos establecer una condición. En este ejemplo nuestra condición es que la estatura de las personas sea mayor de 1.80mts.
El método filter ( ) crea una nueva matriz con todos los elementos que pasan la prueba implementada por la función proporcionada.
Recuerda que si no hay elementos que pasen la prueba, filter devuelve un array vacío.
Reto: escribe el filtrado de personas bajas.
Aportes 1190
Preguntas 46
personas = [sacha, alan, martin, dario, vicky, paula];
for (var i = 0; i < personas.length; i++) {
console.log(i);
console.log(`El peso de ${personas[i].nombre} es ${personas[i].altura}`);
}
var filtrar = personas.filter(function (parámetro) {
parámetro.altura > 1.80 ? console.log(`${parámetro.nombre} es mayor a 1.80 mts`) : console.log(`${parámetro.nombre} es menor a 1.80 mts`);
}
);
FILTRAR UN ARRAY
Para filtrar un array usaremos el ejemplo anterior pero sin el ciclo for, por lo que ahora filtraremos a las personas altas, para ello necesitamos dos cosas, el array y una condición,
Pa ello crearemos una variable
var personasAltas = personas.filter(condicion)
donde utilizamos el array personas y le colocamos la palabra “filter” y en el paréntesis va la condición que debe ser una función
const esAlta = (persona) => {
return persona.altura > 1.8
}
var personasAltas = personas.filter(esAlta)
De manera que al hacer el console.log deberían aparecer las personas altas, ahora en internet lo mas probables es que te consigas con el filtro de esta manera;
var personasAltas = personas.filter(function (persona){
return persona.altura >= 1.8
})
Es equivalente, pero leerlo de la primera manera es más sencillo y entendible.
Hay que tener en cuenta que esto nos devuelve un array nuevo no modificamos el original.
¿Cuál es la función del return{}? No entiendo como funciona ni a quien afecta.
var vicky = {
nombre:'Vicky',
apellido:'Zapata',
altura:1.56
}
var luis = {
nombre:'Luis',
apellido:'Camarena',
altura:1.94
}
var carlos = {
nombre:'Carlos',
apellido:'Ortega',
altura:1.79
}
var carlos = {
nombre:'Carlos',
apellido:'Ortega',
altura:1.79
}
var cristian = {
nombre:'Cristian',
apellido:'Ortega',
altura:1.89
}
var emanuel = {
nombre:'Emanuel',
apellido:'Camarena',
altura:1.82
}
var personas = [vicky,luis,carlos,cristian,emanuel];
const esAlta = ({altura}) => altura >= 1.8
const esBaja = ({altura}) => altura < 1.80
var personasAltas = personas.filter(esAlta);
var personasBajas = personas.filter(esBaja);
// TAMBIEN PUEDE SER:
//var personasAltas = personas.filter(function (persona){ return persona.altura >= 1.80});
console.log(personasAltas);
console.log(personasBajas);
<var persona1 = {
nombre: 'Leidy',
apellido: 'Daza',
altura: 1.82
}
var persona2 = {
nombre: 'Jula',
apellido: 'medina',
altura: 1.60
}
var persona3 = {
nombre : 'lucy',
apellido:'Caicedo',
altura: 1.89
}
//const esAlta=(personas)=>{
// return personas.altura > 1.8
//}
const esAlta = ({altura}) => altura > 1.8
const esbaja = ({altura}) => altura < 1.8
//const esAlta = personas => personas.altura > 1.8
//ce¡reamos el arreglo
var personas = [persona1, persona2, persona3]
var personasAltas= personas.filter(esAlta)
var personasbajas= personas.filter(esbaja)
//var personasAltas = personas.filter(function(persona){
// return personas.altura > 1.8
//})
console.log(personasAltas)
console.log(personasbajas)
>
Filtrar un array
Digamos que soy un entrenador de baloncesto que le gusta sorprender al mundo y que quiere formar un nuevo equipo con jugadores menores de 16 años y 1.7 mts para ganar el campeonato
Para ello tengo que crear primero mis dos condiciones ganadoras !
Luego crear un array con todos los jugadores inscritos en mi escuela, luego creo una función que reciba como parametro dicho array
=> Para filtrar siempre necesitamos un array y una condicion
=> para filtrar un array llamamos al metodo array.filter(condicion)
=> Cuando filtramos estamos retornando un nuevo array a menos que reescribamos
ejemplo: personas = personas.filter(viveEnChile)
//No me funcionaba la funcion es baja porque no le habia agregado parametro a la funcion flecha esAlta
------------------------------*/
/* //array
colección de datos
crearemos una colección
e iteraremos por cada uno de los elementos en la coleccion
*/
//Imprimiendo algo en la consola
console.log("inicializando archivo");
/*Declaración de objetos
=========================================*/
//estoy creando personas
var daniel = {
nombre: "Daniel",
apellido: "Páez",
estatura: 1.73,
ubicacion: "chile"
}
var amanda = {
nombre: "Amanda",
apellido: "Páez",
estatura: 1.60,
ubicacion: "chile"
}
var jonathan = {
nombre: "Jonathan",
apellido: "Páez",
estatura: 1.70,
ubicacion: "venezuela"
}
var betsabet = {
nombre: "Betsabet",
apellido: "Soto",
estatura: 1.64,
ubicacion: "chile"
}
/*Declaración de variables
=========================================*/
//pueden ser variables, textos, numeros, objetos, mezclas, funciones
var personas = [ daniel, amanda, jonathan, betsabet ]
/*Declaración de funciones
=========================================*/
/*CONDICIONES QUE FILTRARAN LOS ARRAYS*/
//retornar la condicion de si es alta
const esAlta = ( {estatura} ) => estatura > 1.7
/*RETO escribe el filtado de personas bajas*/
const esBaja = ( {estatura}) => !esAlta( {estatura} );
const viveEnChile = ( {ubicacion} ) => ubicacion == "chile";
/*ARRAYS FILTRADOS*/
var personasAltas = personas.filter(esAlta)
//tambien puedo escribir la funcion dentro de personas.filter
var personasBajas = personas.filter(esBaja)
var personasEnChile = personas.filter(viveEnChile);
/*Consola y consultas
=========================================*/
console.log(personasAltas)
console.log(personasBajas)
console.log(`Soy ${ personas[0]["nombre"] }`)
Pensé que esto era posible
var personasNoAltas = personas.filer(!esAlta)
… 😦
const PERSONA_ALTA = 1.75
const esAlta = (personas)=>{
return personas.altura > PERSONA_ALTA
}
const esBaja = (personas)=>{
return personas.altura < PERSONA_ALTA
}
let personasAltas = personas.filter(esAlta);
let personasBajas = personas.filter(esBaja);
console.log(personasAltas);
console.log(personasBajas);
Filtrar Elementos de un Array
Para filtrar necesitamos dos cosas: una función y una condición.
Usamos la función nativa de javascript ‘filter()’ que recibe una condición como parámetro.
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
var personas = [sacha, alan, martin, dario, vicky, paula]
const esAlta = ({ altura }) => altura > 1.8
var personasAltas = personas.filter(esAlta)
console.log(personasAltas)
Yo para mi ejemplo utilicé un filter sobre un array de videojuegos para obtener los juegos con mejor calificación.
var juego1 = {
nombre: 'Grand Theft Auto V',
desarrollador: 'Rockstar Games',
genero: 'Acción',
calificacion: 7.7
}
var juego2 = {
nombre: 'Mortal Kombat 11',
desarrollador: 'NetherRealm Studios',
genero: 'Pelea',
calificacion: 6.4
}
var juego3 = {
nombre: 'The Witcher: Wild Hunt',
desarrollador: 'CD Projeckt Red',
genero: 'RPG',
calificacion: 9.3
}
var juego4 = {
nombre: 'Cuphead',
desarrolador: 'Studio MDHR',
genero: 'Plataformas',
calificacion: 9.6
}
const esExcelente = juego => juego.calificacion > 9;
var juegos = [juego1, juego2, juego3, juego4];
var juegosExcelentes = juegos.filter(esExcelente);
console.log(juegosExcelentes);```
/-----Filter Array------/
const esPetit = ({ altura }) => altura <= 1.70
var personas = [fernanda, richard, negro, emilia]
var personaPetit = personas.filter(esPetit)
console.log(personaPetit)
La solución del reto sería así:
const esBaja = ({ altura }) => altura <= 1.8
var personas = [gil, bere, nico, cony, miguel, jackie]
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)
listo
const esAlta = ({ altura }) => altura > 1.7
const esBaja = ({ altura }) => altura < 1.7
var personas = [andy, luis, david, moncho, jorge]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)
var andres= {
nombre:"Andres",
Edad: 19,
estatura:1.81
}
var laur={
nombre:"laura",
Edad: 13,
estatura:1.50
}
var Array_personas=[laur,andres];
var es_bajo=({estatura})=> estatura<=1.60
var es_Alto=({estatura})=> estatura>=1.80
var personas_bajas=Array_personas.filter(es_bajo)
var persona_altas=Array_personas.filter(es_Alto)```
😃
const esBaja = ({ altura }) => altura < 1.6
var personas = [sacha, alan, martin, dario, vicky, paula]
var personasBajas = personas.filter(esBaja)
Pura programación funcional.
const esBaja = ({ altura }) => altura < 1.8
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Pérez',
altura: 1.86
}
var martin = {
nombre: 'Martín',
apellido: 'Gómez',
altura: 1.85
}
var dario = {
nombre: 'Darío',
apellido: 'Juárez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
const esAlta = ({altura}) => altura > 1.8
const esBaja = ({altura}) => !esAlta({altura})
var personas = [sacha, alan, martin, dario, vicky, paula]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
Reto
const isHigh = ({height}) => height > 1.8
const itIsLow = ({height}) => height < 1.6
var tallPerson = people.filter(isHigh);
var lowPerson = people.filter(itIsLow);
Aquí está el desafio
const esBaja = ({altura}) => altura < 1.80
var personasBajas = personas.filter(esBaja)
Y con la función anónima
var personasBajas = personas.filter(({altura}) => altura < 1.80)
var lista = [jose, maria, juan, carlos, pedro];
const mayor = ({ age }) => {
return age >= 18;
};
var mayorDeEdad = lista.filter(mayor);
console.log(mayorDeEdad);
const menor = ({ age }) => {
return age < 18;
}
var menorDeEdad = lista.filter(menor);
console.log(menorDeEdad);```
const esAlta = ({ altura }) => altura > 1.8;
const esBaja = ({ altura }) => !esAlta({ altura });
var personas = [bojack, todd, michelle, jaume, ana];
var personasAltas = personas.filter(esAlta);
var personasBajas = personas.filter(esBaja);
console.log(personasAltas);
console.log(personasBajas);
var marcela = {
nombre: 'Marcela',
apellido: 'Dusan',
edad: 25,
estatura:1.76
}
var geraldin = {
nombre: 'Geraldin',
apellido: 'Perafan',
edad: 35,
estatura:1.72
}
var nubia = {
nombre: 'Nubia',
apellido: 'Gonzalez',
edad: 42,
estatura:1.66
}
var marino = {
nombre: 'Marino',
apellido: 'Osorio',
edad: 48,
estatura:1.85
}
var constanzo = {
nombre: 'constanso',
apellido: 'Cárdenas',
edad: 56,
estatura: 1.90
}
var personas = [marcela, geraldin,nubia, marino, constanzo];
console.log(`Tiene registradas ${personas.length} personas`);
var masBajas = persona => persona.estatura < 1.75
for (var i=0; i < personas.length; i++){
persona = personas[i]
console.log(`${persona.nombre} ${persona.apellido} mide ${persona.estatura}`)
}
const filtro = personas.filter(masBajas)
console.log(filtro)
//Aplicacion que recibe N cantidad de personas y valida cuales son altas y cuales son bajas
let persona = {
nombre:'',
estatura:0
}
let arrayPersonas= [];
let cantidadPersonas = Number(prompt('Ingresa la cantidad de persona a validar'));
let nombreBajas, nombreAltas;
for(i=1; i<=cantidadPersonas; i++){
let nuevaPersona = {
...persona,
nombre: prompt(`Ingresa el nombre de la persona ${i}`),
estatura: Number(prompt(`Ingresa la estatura de la persona ${i} en METROS`))
}
arrayPersonas.push(nuevaPersona);
}
let esBaja = ({estatura}) => estatura <= 1.6;
let esAlta = ({estatura}) => estatura >= 1.8;
//filtro
let personasBajas = arrayPersonas.filter(esBaja);
let personaAltas = arrayPersonas.filter(esAlta);
function validaBajas(){
//valido tamaño de los array de resultado
if(personasBajas.length !== 0){
for(i=0; i<personasBajas.length; i++){
if(i === 0){
nombreBajas = personasBajas[0].nombre;
}else{
nombreBajas = nombreBajas + ',' + personasBajas[0].nombre;
}
}
return nombreBajas;
}else{
nombreBajas = '-';
return nombreBajas;
}
}
function validaAltas(){
//valido tamaño de los array de resultado
if(personaAltas.length !== 0){
for(i=0; i<personaAltas.length; i++){
if(i === 0){
nombreAltas = personaAltas[0].nombre;
}else{
nombreAltas = nombreAltas + ',' + personaAltas[0].nombre;
}
}
return nombreAltas;
}else{
nombreAltas = '-';
return nombreAltas;
}
}
//valido si alguno no tiene personas
let nombrePersonasAltas = validaAltas();
let nombrePersonasBajas = validaBajas();
if(nombrePersonasBajas === '-' && nombrePersonasAltas === '-'){
alert(`Todas las personas ingresadas tienen una estatura promedio`);
}else if(nombrePersonasAltas === '-'){
alert(`Las personas bajas son: ${nombrePersonasBajas} y las demas tienen una estatura promedio`);
}else if(nombrePersonasBajas === '-'){
alert(`Las personas altas son: ${nombrePersonasAltas} y las demas tienen una estatura promedio`);
}else{
alert(`Las personas bajas son: ${nombrePersonasBajas} y las personas altas son: ${nombrePersonasAltas}, las demas tienen una estatura promedio`);
}
var personasBajas = personas.filter( function (persona) {
return persona.altura < 1.8
})```
Una pregunta, ¿por qué si “esAlta” es una función, no se le ponen ()?
let personasAltas = personas.filter(esAlta)```
const esBaja = (persona) => !esAlta(persona)
var jhonatan = {
nombre:'Jhonatan',
altura :1.85
}
var Alexander = {
nombre: 'Alexander',
altura :1.80
}
var Javier = {
nombre: 'Javier',
altura :1.65
}
var Alberto = {
nombre: 'Alberto',
altura :1.75
}
const ALTO = 1.85
var personas = [jhonatan,Alexander,Javier,Alberto]
const esAlta= ({ altura}) => altura >= ALTO
const esBaja = ({altura})=> altura < ALTO
var PersonasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log('Las personas altas fueron: ')
for(var i = 0; i<PersonasAltas.length; i++){
console.log(` ${PersonasAltas[i].nombre} con una altura de ${PersonasAltas[i].altura}`)
}
console.log('Las personas bajas fueron:')
for(var i = 0; i<personasBajas.length; i++){
console.log(` ${personasBajas[i].nombre} con una altura de ${personasBajas[i].altura}`)
}
El reto lo hice de esta manera:
const esBaja = ({altura}) => altura < 1.8;
var personasBajas = personas.filter(esBaja);
console.log(personasBajas);
var anthony = {nombre: "Anthony", apellido: "Moronta", altura: 1.90};
var cesar = {nombre: "César", apellido: "Moronta", altura: 1.83};
var domingo = {nombre: "Domingo", apellido: "Moronta", altura: 1.85};
var rafael = {nombre: "Rafael", apellido: "Pérez", altura: 2.10};
const esBaja = persona => persona.altura < 1.9
var personas = [anthony, cesar, domingo, rafael];
var personasBajas = personas.filter(esBaja);
console.log(personasBajas);
onst esAlta = ({ altura }) => altura > 1.8;
const esBaja = ({ altura }) => altura <= 1.8;
var personas = [luis, pedro, andres];
var personasAltas = personas.filter(esAlta);
var personasBajas = personas.filter(esBaja);
console.log(personasAltas);
console.log(personasBajas);
var esBaja = ({ altura }) => altura < 1.6;
var personasBajas = familia.filter(esBaja);
for(var i = 0; i < personasBajas.length; i++){
var baja = personasBajas[i];
console.log(`${baja.nombre} mide: ${baja.altura}m. Es una persona baja.`)
};```
Por acá dejo mi código
var jocy = {
name: "Clara",
lastName: "Gomez",
height: 1.62
};
var cory = {
name: "Cory",
lastName: "White",
height: 1.85
};
var carol = {
name: "Carol",
lastName: "Díaz",
height: 1.65
};
var thiago = {
name: "Thiago",
lastName: "Silva",
height: 1.83
};
var lucy = {
name: "Lucy",
lastName: "James",
height: 1.69
};
var kevin = {
name: "Kevin",
lastName: "Daws",
height: 1.78
};
var people = [jocy, cory, carol, thiago, lucy, kevin];
const tallLimit = 1.8;
const isTall = ({height}) => { return tallLimit < height };
const isSmall = ({height}) => { return height < tallLimit };
console.log(`Tall people:`, people.filter(isTall));
console.log(`Small people:`, people.filter(isSmall));
var jose = {
nombre: 'Jose',
apellido: 'Almanza',
altura: 1.83
}
var jacque = {
nombre: 'Jacque',
apellido: 'Franco',
altura: 1.65
}
var luis = {
nombre: 'Luis',
apellido: 'Almanza',
altura: 1.75
}
var personas = [jose,jacque,luis]
const esAlta = ({ altura }) => altura > 1.8
const esBaja = personas => !esAlta(personas)
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log('Personas bajas: ')
console.log(personasBajas)
console.log('Personas altas: ')
console.log(personasAltas)
Reto:
const esAlta = ({altura}) => altura >= 1.8
const esBaja = ({altura}) => altura < 1.8
var personas = [david, yaja, snow]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)
const esBaja = ({altura}) => altura < 1.8
var personasBajas = personas.filter(esBaja)
//Tarea: Hacer función que devuelva personas bajas
const esBaja = ({altura}) => altura < 1.8
var personasBajas = personas.filter(esBaja)
console.log(personasBajas);```
Esta seria una forma mas simple de filtrar muy utilizada.
var personasAltas = personas.filter(x=> x.altura >= 1.80);
Esto es lo mas sencillo que se me ocurrió…
const medirAltos = personas => personas.altura >= 1.80
const medirBajos = personas => personas.altura < 1.80
var personasAltas = personas.filter(medirAltos)
var personasBajas = personas.filter(medirBajos)
console.log('Personas altas:')
for (var i = 0; i < personasAltas.length; i++) {
console.log(personasAltas[i])
}
console.log('Personas bajas o medianas:')
for (var i = 0; i < personasBajas.length; i++) {
console.log(personasBajas[i])
}```
Lo hice con 1.6… 😄
const esAlta = ({ altura }) => altura > 1.6 // arrow function
const esBaja = ({ altura }) => altura <= 1.6 // arrow function
var personas = [emanuel, alan, martin, dario, vicky, paula]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
// var personasAltas = personas.filter(function (persona) {
// return persona.altura > 1.6
// })
console.log('Altas:')
console.log(personasAltas)
console.log('Bajas:')
console.log(personasBajas)
Esta es mi solución al reto:
var personas = [aldo, alan, martin, dario, vicky, paula]
const esAlta = ({ altura }) => altura >= 1.8
const esBaja = ({ altura }) => altura < 1.8
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log('Personas altas:')
for (var i = 0; i < personasAltas.length; i++) {
console.log(personasAltas[i].nombre)
}
console.log('Personas bajas:')
for (var i = 0; i < personasBajas.length; i++) {
console.log(personasBajas[i].nombre)
}
Consola:
Personas altas:
Aldo
Alan
Martin
Personas bajas:
Dario
Vicky
Paula
Reto 1 Clase Filter Array
var jos ={
nombre:'Josadec',
apellido: 'Pedraza',
altura: 1.57
}
var edw ={
nombre: 'Edwin',
apellido: 'Pedraza',
altura: 1.20
}
var iva ={
nombre:'Ivan',
apellido:'Pedraza',
altura: 1.60
}
var mis = {
nombre:'Misael',
apellido:'Pedraza',
altura: 1.62
}
var cob = {
nombre:'Christian',
apellido:'Cobian',
altura:1.82
}
const esAlta = ({altura}) => altura > 1.8
const esBaja = ({altura}) => altura < 1.60
var personas =[jos,edw,iva,mis,cob]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)
Tengo una pregunta que me ronda desde hace unas clases. ¿Como es que cuando indicamos el objeto persona como parámetro de la función se recoge correctamente si en ningún momento lo hemos declarado por tal nombre? Si lo hemos hecho con personas. ¿JS entiende de singulares y plurales ? Es decir, como el array de objetos lo declaramos como personas, se entiende que persona puede ser cada uno de los elementos de dentro. No se si me explico… Gracias!
Mi reto!
const esAlta = ({altura}) => altura > 1.75
const esBaja = ({altura}) => altura <= 1.75
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
// var personasAltas = personas.filter(function (persona){
// return persona.altura > 1.75
// })
console.log(personasAltas)
console.log(personasBajas)
const esBaja = personas => personas.altura <= 1.80
var personas = [bajo, medio, alto]
var altos = personas.filter(esBaja)
console.log (Personas bajas del array
)
for (var i = 0; i<altos.length; i++) {
console.log (${altos[i].nombre}
)
}
`<code>
var adriana = {
nombre:'adriana',
apellido: 'ardila',
altura: '1.50'
}
var ximena = {
nombre:'ximena',
apellido: 'lopez',
altura: '1.60'
}
var minki = {
nombre:'minki',
apellido: 'choi',
altura: '1.78'
}
var aron = {
nombre:'aron',
apellido: 'hwang',
altura: '1.76'
}
var jerson = {
nombre:'jerson',
apellido: 'moreno',
altura: '1.70'
}
var tianyu = {
nombre:'tianyu',
apellido: 'ma',
altura: '1.80'
}
var sacha = {
nombre:'sacha',
apellido: 'lifszyc',
altura: '1.72'
}
const esAlta = ({ altura }) => altura >= 1.7
const esBaja = ({ altura }) => altura < 1.7
var personas = [adriana, ximena, minki,aron, jerson, tianyu, sacha]
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)```
var sebas = {
nombre: 'Sebas',
apellido: 'García',
edad: 7,
estatura: 1.12
}
var mafe = {
nombre: 'Mafe',
apellido: 'García',
edad: 13,
estatura: 1.6
}
var wilson = {
nombre: 'Wilson',
apellido: 'García',
edad: 33,
estatura: 1.72
}
var maria = {
nombre: 'María',
apellido: 'Borda',
edad: 50,
estatura: 1.62
}
const esBaja = ({ estatura }) => estatura < 1.7
var personas = [sebas, maria, mafe, wilson]
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)```
Dos ejemplos distintos…
//Un método como el explicado en clase :
const esBaja = ({ altura }) => altura < 1.8
const esAlta = ({ altura }) => altura >= 1.8
var personasBajas = personas.filter(esBaja)
var personasAltas = personas.filter(esAlta)
console.log(personasBajas)
console.log(personasAltas)
--------------------------------------------------------------------
//otro método con condicional:
const ESTANDARD = 1.8
for (var i = 0; i < personas.length; i++){
var persona = personas[i]
if (persona.altura > ESTANDARD){
console.log(`${persona.nombre} es de estatura alta`)}
else {console.log(`${persona.nombre} es de estatura baja`)}
}
Vergaaaaa que dolor de cabeza el no entender nada… realmente Javascript tiene sus curiosidades. Que frustración!!!
Les comparto el Reto y un desafío que me propuse agregando el Sexo de la persona y filtrándola, funciona correctamente y creo que hay otros métodos de implementarlo, pero lo logré de esa manera ❤️
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
sexo: 'Masculino',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
sexo: 'Masculino',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
sexo: 'Masculino',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
sexo: 'Masculino',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
sexo: 'Femenino',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
sexo: 'Femenino',
altura: 1.76
}
// Declaración del Array
let personas = [sacha, alan, martin, dario, vicky, paula];
const esAlta = personas => personas.altura > 1.8;
// RETO: Escribir el filtrado de personas bajas.
const esBaja = personas => personas.altura < 1.8;
//MI PROPIO DESAFIO
const sexoM = personas => personas.sexo == 'Masculino';
const sexoF = personas => personas.sexo == 'Femenino';
//metodo para filtrar arreglos (recibe un array como parametro)
let personasAltas = personas.filter(esAlta);//Filter nos va devolver un nuevo Array
let personasBajas = personas.filter(esBaja);
let personasSexoF = personas.filter(sexoF);
let personasSexoM = personas.filter(sexoM);
console.log(personasAltas);
console.log(personasBajas);
console.log(personasSexoF);
console.log(personasSexoM);
Se puede reusar la constante de esAlta para el reto
var personasNoAltas = personas.filter(!esAlta)
Mi Solución
//Personas bajas
const esBaja = ({ altura }) => altura <= 1.8;
var personasBajas = personas.filter(esBaja);
console.log(personasBajas);
Mi version del reto:
var sacha =
{
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan =
{
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin =
{
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario =
{
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky =
{
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula =
{
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
var people = [sacha, alan, martin, dario, vicky, paula]
const ifTall = ( {altura} ) => altura > 1.80
const ifSmall = ( {altura} ) => altura < 1.80
var tallPeople = people.filter(ifTall)
var smallPeople = people.filter(ifSmall)
const esBaja = ({ estatura }) => estatura < 1.7
var personas =[daniel,emerson,isaac,isai,leonel]
var personasAltas = personas.filter(esBaja)
console.log(personasAltas)```
No ocupe el metodo filter, pero funciona jsjs
var array = [
{
nombre: "Jean",
apellido: "Aldea",
estatura: 1.74
},
{
nombre: "Sofia",
apellido: "Silupu",
estatura: 1.55
},
{
nombre: "Javier",
apellido: "Llanquileo",
estatura: 1.80
}
];
const imprimir = (array) => {
for(var i = 0; i<array.length; i++) {
var objeto = array[i];
if (objeto.estatura > 1.60) {
console.log(`Hola, ${objeto.nombre} mide más de 1.60 y exactamente mide ${objeto.estatura}`);
}else{
console.log(`Hola, ${objeto.nombre} mido menos de 1.60 y exactamente mide ${objeto.estatura}`);
}
}
}
var sergio={
nombre:"sergio",
edad:14,
altura:1.70
}
var james={
nombre:"sergiopro",
edad:40,
altura:1.70
}
var martha ={
nombre:"martha",
edad:44,
altura:1.68
}
var jhon ={
nombre:"jhon",
edad:38,
altura:1.90
}
//funcion para altos
const esAlta = ({altura}) => altura > 1.8 //estatura promedio
//funcion para bajos
const esBaja = ({altura}) => altura < 1.8//estatura promedio
var personas = [sergio,martha,james,jhon]//las personas del grupo
var personasAltas= personas.filter(esAlta)//grandes
var personasBajas= personas.filter(esBaja)//bajos
console.log(personasAltas)//consola
console.log(personasBajas)//consola```
//---------------------------------
// Filtrar elementos en los Arrays
//definir varias variables
var claudia = {
nombre: ‘Claudia’,
apellido: ‘Aparicio’,
altura: 1.70
}
var alan = {
nombre: ‘Alan’,
apellido: ‘Perez’,
altura: 1.86
}
var martin = {
nombre: ‘Martin’,
apellido: ‘Gomez’,
altura: 1.85
}
var fernando = {
nombre: ‘Fernando’,
apellido: ‘Mendoza’,
altura: 1.80
}
//definir la funcion personas altas y bajas
//para llamarla en el filter
const esAlta = ({altura}) => altura > 1.8
const esBaja = ({altura}) => !esAlta({altura})
//agrupar a estas personas en una coleccion:
//corchetes para indicar que es un array
var personas = [claudia, alan, martin, fernando]
//filtrar a las personas altas:
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)
Reto
const esAlta = ({ altura }) => altura > 1.8
const esBaja = persona => persona.altura <= 1.8
var personas = [sacha, alan, martin, dario, vicky, paula]
//for (let i = 0; i < personas.length; i++) {
// var persona = personas[i]
// console.log(`${persona.nombre} mide ${persona.altura} metros`)
//}
//var personasAltas = personas.filter(function (persona) {
// return persona.altura > 1.8
//})
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas, personasBajas)```
var personasBajas = personas.filter(function ({estatura}){
return estatura < 1.75
});
// console.log(personasAltas);
for(var i = 0; i< personasBajas.length;i++){
var persona = personasBajas[i];
console.log(${persona.nombre} es baja porque mide ${persona.estatura.toFixed(2)} Mts
);
}
No es filter pero itera y dice si es baja o alta jejeje XD
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
//const esAlta = (persona) => return persona.altura > 1.8
//const esBaja = (persona) => return persona.altura <= 1.8
const personaAltaOBaja = (persona) => {
persona.altura > 1.8 ? console.log(persona.nombre + " es alta") : console.log(persona.nombre + " es baja");
}
var personas = [sacha, alan, martin, dario, vicky, paula]
//var personasAltas = personas.filter(esAlta)
//var personasBajas = personas.filter(esBaja)
personas.forEach(personaAltaOBaja)
Hola, aqui mi codigo:
var jose = {
nombre: 'Jose',
apellido: 'Espinosa',
altura: 1.70
}
var mateo = {
nombre: 'Mateo',
apellido: 'Espinosa',
altura: 0.60
}
var david = {
nombre: 'David',
apellido: 'Salamanca',
altura: 1.30
}
var andrea = {
nombre: 'Andrea',
apellido: 'Malagon',
altura: 1.55
}
var paula = {
nombre: 'Paula',
apellido: 'Maldonado',
altura: 1.50
}
var tatiana = {
nombre: 'Tatiana',
apellido: 'Urbina',
altura: 1.50
}
const esAlta = ({ altura }) => altura > 1.54
const esBaja = ({ altura }) => altura < 1.40
var personas = [jose, mateo, david, andrea, paula, tatiana]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasBajas);```
Mini Tutorial
// El reto para esta clase es realizar un filtrado de de la gente menor a 1.60m
// Vamos a importar el codigo ya existente
var andres = {
nombre: "Andrés",
apellido: "Bautista",
altura: 1.8,
};
var mario = {
nombre: "Mario",
apellido: "Gonzalez",
altura: 1.77,
};
var jose = {
nombre: "José",
apellido: "Fernandez",
altura: 1.66,
};
var ana = {
nombre: "Ana",
apellido: "Blanco",
altura: 1.71,
};
var dora = {
nombre: "Dora",
apellido: "Blanco",
altura: 1.69,
};
var carolina = {
nombre: "Carolina",
apellido: "Posada",
altura: 1.69,
};
const esAlta = (personas) => personas.altura > 1.7;
var personas = [andres, mario, jose, ana, dora, carolina];
var personasAltas = personas.filter(esAlta);
console.log(personasAltas);
// Vamos a crear una funcion tipo arrow para definir las personas que clasifican como Pequeñas
const esPequena = (personas) => personas.altura <= 1.7;
var personasPequenas = personas.filter(esPequena); // Creamos una variable
console.log(personasPequenas);// La llamamos en la consola
//Listo!!!!
¿cómo quedó?
const esBaja = persona => persona.altura <= 1.8
var personas = [alfredo, ixchel, amelia, zachi]
var personasAltas = personas.filter(esAlta);
var personasBajas = personas.filter(esBaja);
console.log(personasAltas);
console.log(personasBajas);
let andres = {
nombre: ‘andres’,
edad: 35,
altura: 1.78,
}
let camilo = {
nombre: ‘camilo’,
edad: 30,
altura: 1.57,
}
let maria = {
nombre: ‘maria’,
edad: 27,
altura: 1.28,
}
let camila = {
nombre: ‘camila’,
edad: 15,
altura: 1.20,
}
let teresa = {
nombre: ‘teresa’,
edad: 30,
altura: 1.54,
}
let frank = {
nombre: ‘frank’,
edad: 20,
altura: 1.85,
}
const personas = [andres, camilo, maria, frank, teresa, camila, ];
let personaBaja = ({ altura }) => {
return altura < 1.75
}
let persBaja = personas.filter(personaBaja);
console.log(persBaja)
Hola!! les comparto mi reto. Yo lo que hice fue modificar el arreglo original agregando la clasificación “Alta” o “Baja” según corresponda, en lugar de hacer dos arrays.
Pero al hacer mi ejercicio me quedé con una duda, entiendo que la función Object.assign() modifica el objeto que estoy iterando, también entiendo que la función filter itera y devuelve un arreglo copia. ¿Cómo puedo entonces usando filter agregar al nuevo arreglo la clasificación sin modificar el original?
Según yo, debería usar algún otro método para iterar en lugar de filter pero si alguien sabe si se puede se los agradezco.
const esAltaSi = 1.8;
const clasificaEstatura = persona => {
persona.altura >= esAltaSi
? Object.assign(persona, { clasificacion: "Alta" })
: Object.assign(persona, { clasificacion: "Baja" });
};
personas.filter(clasificaEstatura);
Resultado:
Array(6)
0: {nombre: "Sacha", apellido: "Lifszyc", altura: 1.72, clasificacion: "Baja"}
1: {nombre: "Martin", apellido: "Gomez", altura: 1.85, clasificacion: "Alta"}
2: {nombre: "Dario", apellido: "Juarez", altura: 1.71, clasificacion: "Baja"}
3: {nombre: "Vicky", apellido: "Zapata", altura: 1.56, clasificacion: "Baja"}
4: {nombre: "Paula", apellido: "Barros", altura: 1.76, clasificacion: "Baja"}
5: {nombre: "Alan", apellido: "Perez", altura: 1.86, clasificacion: "Alta"}
Recordemos que para javascript todos los diccionarios son arrays internamente atados al objeto window.
Considero que:
const esBaja = ({altura}) => !esAlta({altura}) //RETO
Es la mejor solución al reto porque:
1 Si no eres alto, eres bajo, es un estado “booleano” blanco, negro
2 A nivel de codigo es más eficiente porque si nuestros criterio para considerar a alguien alto (y por lo tanto a otra persona baja), cambia , será simplemente cambiar una variable en una sola función
Reto…
const ALTURA_PERSONA = 1.8
const esAlta = ({ altura }) => altura > ALTURA_PERSONA
const esBaja = ({ altura }) => altura <= ALTURA_PERSONA
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log('Personas Altas');
console.log(personasAltas);
console.log('Personas Bajas')
console.log(personasBajas);
Reto! Importante: Genero distintos objetos a los de la clase, pero se logra lo mismo
var pablo = {
nombre: 'Pablo',
edad: 23,
profesion: 'Traductor'
}
var pedro = {
nombre: 'Pedro',
edad: 25,
profesion: 'Ing. proyectos'
}
var angelo = {
nombre: 'Angelo',
edad: 24,
profesion: 'Gamer'
}
var valeria = {
nombre: 'Valeria❤️',
edad: 22,
profesion: 'Ilustracion'
}
var christian = {
nombre: 'Christian',
edad: 21,
profesion: 'Ilustracion'
}
var alejandro = {
nombre: 'Alejandro',
edad: 27,
profesion: 'Ilustracion'
}
const esIlustrador = ({profesion}) => profesion == 'Ilustracion'
const noIlustrador = ({profesion}) => profesion != 'Ilustracion'
// var ilustradores = personas.filter( function (persona){
// return persona.profesion == 'Ilustracion'
// })
var amigos = [pablo, pedro, angelo, valeria, christian, alejandro]
var ilustradores = amigos.filter(esIlustrador)
var noIlustradores = amigos.filter(noIlustrador)
console.log(ilustradores)
console.log('')
console.log(noIlustradores)
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.82
}
var enzo = {
nombre: 'Enzo',
apellido: 'Campetella',
altura: 1.73
}
var eri = {
nombre: 'Erica',
apellido: 'Sanchez',
altura: 1.70
}
var cholo = {
nombre: 'Cholo',
apellido: 'Rasquetti',
altura: 1.40
}
var isabel = {
nombre: 'Isabel',
apellido: 'Sanchez',
altura: 1.85
}
const esAlta = persona => persona.altura > 1.8
const esBaja = persona => persona.altura < 1.70
var personas = [sacha, enzo, eri, cholo, isabel]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)```
Mi codigo donde filtro a las personas por peso y por altura
var carlos = {
nombre: 'Carlos',
apellido: 'Guedez',
altura: 1.54,
peso: 75,
}
var jose = {
nombre: 'Jose',
apellido: 'Suarez',
altura: 1.60,
peso: 90,
}
var maria = {
nombre: 'Maria',
apellido: 'Rodriguez',
altura: 1.75,
peso: 65,
}
var marlon = {
nombre: 'Marlon',
apellido: 'Becerra',
altura: 1.80,
peso: 85,
}
var alfonso = {
nombre: 'Alfonso',
apellido: 'Perez',
altura: 1.60,
peso: 78,
}
//constantes de altura y peso maximo
const PESO_IDEAL = 70;
const ALTURA_IDEAL = 1.65;
var personas = [carlos, jose, maria, marlon, alfonso];
const PERSONAS_FITNESS = ({ altura, peso }) => {
if(altura > ALTURA_IDEAL && peso >= PESO_IDEAL){
return true;
} else{
return false
}
}
//funcion filter sirve para filtrar un array y recibe una condicion como parametro
var personasAltas = personas.filter(PERSONAS_FITNESS);
console.log(`array que contiene a las personas con la altura y el peso idoneo`);
console.log(personasAltas);
Mi aporte
var nestor = {
nombre:‘Nestor’,
apellido:‘Martinez’,
altura:1.75
}
var carlos = {
nombre:‘Carlos’,
apellido:‘Martinez’,
altura:1.62
}
var fredy = {
nombre:‘Fredy’,
apellido:‘Marquez’,
altura:1.50
}
var armando = {
nombre:‘Armando’,
apellido:‘Ruiz’,
altura:1.90
}
const ALTURA_MAX = 1.80;
const esAlta = persona => persona.altura >= ALTURA_MAX;
const esBaja = persona => persona.altura < ALTURA_MAX;
var personas =[nestor, carlos, fredy, armando];
var personasAltas = personas.filter(esAlta);
var personasBajas = personas.filter(esBaja);
console.log(Estas son las personas mas altas ${personasAltas}
);
console.log(Estas son las personas mas bajas ${personasBajas}
);
Aquí esta mi reto:
var persona = [alejandro, jose, abraham, jason]
// las arrow function de una linea retornan automaticamente los valores
const esAlta = persona => persona.altura < 1.80
var personaBaja = persona.filter(esAlta)
console.log(personaBaja)
Excelente clase. Muy útil las maneras de escribir las arrow functions. 🙂
var juan = {
nombre: "Juan",
apellido: "Ortega",
altura: "1.8"
}
var miguel = {
nombre: "Miguel",
apellido: "Lobo",
altura: "1.7"
}
var andrea = {
nombre: "Andrea",
apellido: "Arteaga",
altura: "1.6"
}
var dairlys = {
nombre: "Dairlys",
apellido: "Castañeda",
altura: "1.65"
}
var juana = {
nombre: "Juana",
apellido: "Ortiz",
altura: "1.85"
}
var personas = [ juan, miguel, andrea, dairlys, juana];
const esAlta = ({altura}) => altura >= 1.8;
var personasAltas = personas.filter( esAlta );
var esBaja = ({altura}) => altura <= 1.7;
var personasBajas = personas.filter(esBaja);
console.log(personasAltas);
console.log(personasBajas);
var pedro = {
nombre: 'pedro',
apellido: 'perez',
altura: 1.68
}
var vicky = {
nombre: 'vicky',
apellido: 'Lopez',
altura: 1.57
}
var Josefa = {
nombre: 'Josefa',
apellido: 'pelaez',
altura: 1.41
}
var Proculo = {
nombre: 'Proculo',
apellido: 'Esperolo',
altura: 1.78
}
const esAlta = persona => persona.altura > 1.7
const esBaja = ({altura}) => altura <= 1.7
var personas = [pedro, vicky, Josefa, Proculo]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)```
Reto: 😃
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
const esAlta = ({altura}) => altura > 1.8
const esBaja = ({altura}) => altura <= 1.8
var personas = [sacha, alan, martin, dario, vicky,paula]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)
Dos opciones mostrando en consola:
const esBaja = ({ altura }) => altura < 1.6;
var personasBajas = personas.filter(esBaja);
console.log(personasBajas);
console.log(personas.filter(function ({altura}) {
return altura < 1.6;
}));
Mi aporte al reto es:
var sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
const PERSONA_ALTURA_ALTA = 1.8;
const esAlta = persona => persona.altura > PERSONA_ALTURA_ALTA;
//const esAlta = ({ altura }) => altura > PERSONA_ALTURA_ALTA;
const esBaja = persona => persona.altura < PERSONA_ALTURA_ALTA;
//const esBaja = ({ altura }) => altura > PERSONA_ALTURA_ALTA;
var personas = [sacha,alan,martin,dario,vicky,paula];
var personasAltas = personas.filter(esAlta);
//var personasAltas = personas.filter(function (persona){
// return persona.altura > PERSONA_ALTURA_ALTA;
//});
var personasBajas = personas.filter(esBaja);
//var personasBajas = personas.filter(function (persona){
// return persona.altura < PERSONA_ALTURA_ALTA;
//});
console.log(personasAltas);
console.log(personasBajas);
Hola, disculpe me puede ayudar a identificar por que no me deja filtrar el objeto? gracias.
Mi reto!!!
var personas = [sacha, alan, martin, dario, vicky, paula]
const esBaja = ({altura}) => altura < 1.6
var personasBajas = personas.filter(esBaja)
console.log(personasBajas);
let sacha = {
nombre: 'Sacha',
apellido: 'Lifszyc',
altura: 1.72
}
let alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
let martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
let dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
let vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
let paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
let personas = [sacha, alan, martin, dario, vicky, paula];
let filtroUno = personas.filter(x => x.altura > 1.75);
console.log(filtroUno);
let filtroDos = personas.filter(x => {
if (x.altura > 1.75) {
return x;
}
});
console.log(filtroDos);
const onFiltrePersonasAltas = ({ altura }) => altura > 1.75;
let filtroTres = personas.filter(onFiltrePersonasAltas);
console.log(filtroTres);
Cuando se hace el desglose de datos que se usan en una función arrow, ¿Eso solo funciona cuando los objetos que existen tienen siempre la misma estructura(los mismos atributos)?
Osea en el minuto 5:08, Sacha hace un desglose en la función y pone como parámetro “altura”, que es un atributo común en todos los objetos, ¿Solo en esos casos funciona el desglose?
El cógigo del desafío quedaría algo así:
const esBaja = persona => persona.altura <= 1.8
Con que combinación de teclas puedes comentar las lineas de código ?
const esBaja = ({altura}) => altura < 1.58
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)
Aquí dejo el reto:
const esBaja = altura => altura <= 1.6
var personasBajas = personas.filter(esBaja)
console.log(personasBajas)
Buenas, se me ocurrió una forma para imprimir los nombres junto a si una persona es alta o baja, acepto sugerencias para mejorar el código ya que se que se puede mejorar pero no se como. Gracias
var yoel = {
nombre: 'Yoel',
apellido: 'Ribero',
altura: 1.75
}
var alan = {
nombre: 'Alan',
apellido: 'Perez',
altura: 1.86
}
var martin = {
nombre: 'Martin',
apellido: 'Gomez',
altura: 1.85
}
var dario = {
nombre: 'Dario',
apellido: 'Juarez',
altura: 1.71
}
var vicky = {
nombre: 'Vicky',
apellido: 'Zapata',
altura: 1.56
}
var paula = {
nombre: 'Paula',
apellido: 'Barros',
altura: 1.76
}
const esAlta = (persona) => {
return persona.altura > 1.8
}
const esBaja = (persona) => {
return persona.altura <= 1.8
}
const imprimirPersonas = (persona, altura) => {
for(var i = 0; i < persona.length; i++) {
console.log(`${persona[i].nombre} es ${altura}`)
}
}
var personas = [yoel, alan, martin, dario, vicky, paula]
var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)
imprimirPersonas(personasAltas, 'alta')
imprimirPersonas(personasBajas, 'baja')
var saha={
nombre: 'Saha',
apellido: 'Lifzyc',
edad:28,
altura: 1.85
}
var dario={
nombre: 'Dario',
apellido: 'Susnisky',
edad:27,
altura:1.92
}
var eduardo={
nombre:'Eduardo',
apellido:'Rodriguez',
edad:30,
altura:1.70
}
var adriana={
nombre:'Adriana',
apellido: 'Perez',
edad:21,
altura:1.64
}
var alejandro={
nombre:'Alejandro',
apellido:'Suarez',
edad: 12,
altura: 1.55
}
var maria={
nombre:'Maria',
apellido:'Martinez',
edad: 23,
altura: 1.65
}
var juan={
nombre:'Alejandro',
apellido:'Gomez',
edad:36,
altura: 1.85
}
//defino mi array
var personas=[saha, dario, eduardo, adriana, alejandro, maria, juan];
//defino la condicion
var esBaja= ({altura})=>altura<1.8;
//defino el filtrado
var personasBajas=personas.filter(esBaja);
//muestro mi array
console.log(personasBajas);```
Al aplicar "filter" tenemos un nuevo Array! Sin perder el original.
const esAlta = ({altura}) => altura >= 1.8
const esBaja = ({altura}) => altura < 1.8
personasAltas = personas.filter(esAlta)
personasBajas = personas.filter(esBaja)
console.log(personasAltas)
console.log(personasBajas)```
Ejercicio personas bajas:
var marisol = {
name: 'Marisol',
height: 1.60
}
var carlos = {
name: 'Carlos',
height: 1.82
}
var luz = {
name: 'Luz',
height: 1.65
}
var memo = {
name: 'Guillermo',
height: 1.85
}
var people = [marisol, carlos, luz, memo]
const isTall = ({ height }) => height > 1.8
const isSmall = ({ height }) => height < 1.8
var tallPeople = people.filter(isTall)
var smallPeople = people.filter(isSmall)
console.log(tallPeople)
console.log(smallPeople)
for (let j = 0; j < tallPeople.length; j++) {
console.log(`Personas altas: ${ tallPeople[j].name }`)
}
for (let k = 0; k < smallPeople.length; k++) {
console.log(`Personas bajas: ${ smallPeople[k].name }`)
}
var fredy = {
nombre: 'Fredy',
apellido: 'Janeta',
altura: 1.5
}
var juan = {
nombre: 'Juan',
apellido: 'Rios',
altura: 1.7
}
var esteban = {
nombre: 'Esteban',
apellido: 'lopez',
altura: 1.4
}
var maria = {
nombre: 'Maria',
apellido: 'Paz',
altura: 1.9
}
ALTURA_ALTO=1.7
var personas = [fredy, juan, esteban, maria]
var esBajo = persona => persona.altura<ALTURA_ALTO
var personasBajas = personas.filter(esBajo)
console.log(personasBajas)
const esBaja = ({altura}) => altura < 1.8;
var personasBajas = personas.filter(esBaja)
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?