Playground: Arregla el Bug

si le das ❤️ al meme ayudarás a tapar las respuestas para que los futuros estudiantes no se las coman y puedan resolver el ejercicio sin distracciones.

La solución es simple, basta con cambiar find() por filter(). Recordemos lo último visto:
Find: Retorna solo la primera coincidencia.
Filter: Retorna todas las coincidencias.

Simplifique un poco el código

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter((car) => car.licensePlate);
}

Gracias a que leí los aportes en las clases anteriores, ya tenía el conocimiento de que find solo devuelve la primera coincidencia y filter las devuelve todas. Así que gracias a los compañeras que dejan información valiosa. :cowboy_hat_face:

Cambiar el find() por filter y todo el if no tiene caso

function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate;
  });
}

export function solution(cars) {
  const lista = cars.filter((car)=>
    car.licensePlate);
  return lista;
}

Find devuelve el primer elemento que coincida
Filter devuelve un arreglo con los valores que conincidan

filter por find y para ahorrar codigo quitamos el else

export function solution(cars) {
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    }
  });
}

COmo simple aporte, este blog es super bueno para leer y abundar mas.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat

Aca dejo una solución mas corta

export function solution(cars) {
  return cars.filter(car => car.licensePlate);
}

Después de analizar las clases pasadas y sin mirar la respuesta llegué a la solución, es muy sencillo. Lo más efectivo para resolver cualquier ejercicio es siempre analizar y pensar el paso a paso.

export function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate;
  });
}

es un poco complejo javascript

export function solution(cars) {
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    }
  });   
}

Con diferencia el mas facil jajaja

function solution(cars) {
    return cars.filter(function (car) {
      if (car.licensePlate) {
        return true;
      } else {
        return false;
      }
    });
}

const cars = [
    {
      color: 'red',
      brand: 'Kia',
    },
    {
      color: 'gray',
      brand: 'Chevrolet',
      licensePlate: 'AAA111',
    },
    {
      color: 'white',
      brand: 'Chevrolet',
      licensePlate: 'RGB255',
    },
  ];
  
  solution(cars);

Hola a todos aquí esta mi solución:

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate;
  });
}

Llegar hasta aquí resolviendo todos los playgrounds es algo del cual sentirse orgulloso…un corazón si se sienten igual.

Bueno lo solucione cambiando el find por el filter jaja

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate != null
  });
}

solo modificar por filter para mostrar todo

export function solution(cars) {
// 👇 Este es el código que no funciona
return cars.filter(function (car) {
if (car.licensePlate) {
return true;
} else {
return false;
}
});
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate!=null
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(c => c.licensePlate != null);

}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate ? true : false
  });
} 

export function solution(cars) {
  return cars.filter((car) => car.licensePlate);
}

Si no entiendes lo que hay dentro del filter, es una funcion fecha.
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Functions/Arrow_functions

export function solution(cars) {
  return cars.filter((car) => {return car.licensePlate? true : false;});
}

SOLO ERA CAMBIAR FIND POR FILTER XD

export function solution(cars) {

return cars.filter(function (car) {
if (car.licensePlate) {
return true;
} else {
return false;
}
});
}

Mi aporte, después me di cuenta que aún se puede mejorar.

function solution(cars) {
    let filtroCarros = cars.filter(function (articulo) {
      return articulo.licensePlate;
    });
    return filtroCarros
  }

no pensé que sería así de fácil xd

No entiendo estos ejercicios tan fáciles a comparación de otros jajajaja, simplemente había que cambiar find por filter

export function solution(cars) {
// 👇 Este es el código que no funciona
return cars.filter(function (car) {
if (car.licensePlate) {
return true;
} else {
return false;
}
});
}

export function solution(cars) {
var found = cars.filter(function (car) {
//If the license plate exists then add a car
if (car.licensePlate) {
return car;
}
})
//Returns the found objects list
return found;
}

export function solution(cars) {
  var filtrados = cars.filter(function (e) {
    return e.licensePlate;
  })
  return filtrados;
}

export function solution(cars) {
  return cars.filter(function (car) {
    if ('licensePlate' in car)
      return car;
  });
}

Hola, por aca dejo este aporte, simplifique un poco el codigo.
espero les sirva de ayuda 😃

export function solution(cars) {
return cars.filter(function (car) {
return car.licensePlate
});

mi metodo, me parece mas simple y con solo dos lineas de codigo.

export function solution(cars) {
  return cars.filter(function (car) {
    return car.hasOwnProperty('licensePlate')
  });
}

Este problema al comienzo lo sentí como a trampa porque me pareció muy fácil la solución al problema jajajajaj lo cual a su vez ya que me salió con lo que tenía en mente me puse feliz porque ya que me hizo sentir el progreso de lo que estoy estudiando y espero que siga así!

reto.

Hola comunidad
.
.
.
.
.
Aqui les dejo mi solucion al desafio.

Saludos

export function solution(cars) {
  return cars.filter(function (car) { return car.licensePlate });
}

Mi solución.

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

Esta solución usa el método filter() para crear un nuevo array con los elementos del array cars que pasan un filtro especificado por la función de devolución de llamada proporcionada. La función de devolución de llamada toma un objeto car como argumento, y verifica si ese objeto tiene una propiedad licensePlate. Si el objeto tiene esa propiedad, entonces la función devuelve true, lo que significa que el objeto pasó el filtro y debe incluirse en el nuevo array. Si el objeto no tiene la propiedad licensePlate, entonces la función devuelve false, lo que significa que el objeto no pasó el filtro y no debe incluirse en el nuevo array.

cambia find por filter y no hay mas complicación

Al menos a mi me gusta mas esta forma.

export function solution(cars)
{
// 👇 Este es el código que no funciona
return cars.filter(autoFiltrado);
}

function autoFiltrado(car)
{
if (car.licensePlate)
{
return true;
} else
{
return false;
}
}

export function solution(cars) {
  return cars.filter( car => Boolean(car.licensePlate) === true)
}

export function solution(cars) {
// 👇 Este es el código que no funciona
return cars.filter(function (car) {
if (car.licensePlate) {
return true;
} else {
return false;
}

});

}

mi solucion al reto

export function solution(cars) {
  // 👇 Este es el código que no funciona
  var licensePlateFilter = cars.filter(function (car) {
    return car.licensePlate;
  });
  return licensePlateFilter
}

export function solution(cars) {
  let hasLicense = cars.filter(f => f.licensePlate)
  return hasLicense
}

Arregla el bug

En esta solución cambiamos el método find() por el método filter().

El método find consiste en encontrar el primer elemento de un array que cumpla con la condición especificada en la función (callback). Si ningún elemento cumpla con la condición, retornará undefined
Recorriendo Arrays con .find(), .forEach() y .some()

basándonos en la condición que se nos especifica para el filtrado de los elementos:

 if (car.licensePlate) {
      return true;
    } else {
      return false;
    }

El método find() retorna solo el primer elemento que cumple la condición y deja de iterar en el resto de los objetos por que su trabajo es coincidir.

Al usar el método filter(), este iterara cada objeto del array y retornara un nuevo array haciendo valer la condición especificada: true( tiene placa) false ( no tiene plata).

JavaScript

function solution(cars) {
  // 👇 Este es el código que funciona
  return cars.filter(function(car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

export function solution(cars) {
  return cars.filter(car => car.hasOwnProperty("licensePlate"));
}

Me gusto como quedo, lo mejor que lo pude resolver yo sin que jodieran los locos de los comentarios, disminui lineas de codigo que nunca viene mal

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return Boolean(car.licensePlate)
  });
  
}

esta solucion se podria optimizar de la siguiente forma

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter((car) => car.licensePlate);
}

Nota el => (Arrow function) retorna una funcion, de tal forma que no es requerido especificar ‘function’.
o bien usar el codigo tal cual esta solo cambiar el metodo find por filter

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
} 

export function solution(cars) {
  return cars.filter(e => e.licensePlate)
}

export function solution(cars) {
  return cars.filter(car => car.licensePlate);
}

con Filter , listo

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(({ licensePlate }) => licensePlate);
}

export function solution(cars) {
  // Sin el if funciona perfecto
  return cars.filter(function (car) {
    return car.licensePlate
  });
}

Solo era el filter, en lugar de find😅

return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });

function solution(cars) {
    
    return cars.filter(function (car) {
        return car.licensePlate != undefined;
    });
}

El poder de las anotaciones. Cambiar simplemente Find (que devuelve unicamente el primer elemento encontrado) por Filter (que devuelve todos los elementos que cumplan las condiciones).

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

Solución 😄

return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

Esta es mi solución, la verdad lo veo bastante simple pero si tienen ideas de como mejorar el código lo revisaré con gusto 😄

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate
  });
}

Bueno como vimos en clases pasadas el find solo se recorre hasa el puno que encuentra la primera coincidencia, mientras que el filter recorre todo el array buscando coincidencias, en el ejercicio solo es cambiar el find por filter

Mi solución 😃

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate !== undefined) {
      return true;
    } else {
      return false;
    }
  });
}

Les dejo mi aporte, solo hay que recordar que el FILTER verifica que todos los valores coincidan y el FIND devuelve únicamente el primer valor que encuentre

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

export function solution(cars) {
return cars.filter((car) => car.licensePlate);
}

function solution(cars) {
    return cars.filter(car=>car.licensePlate);
}

Mi solución

export function solution(cars) {
  // 👇 Este es el código que no funciona

  return cars.filter(function (car) {
    if (car.licensePlate) {
      
      return car
    } 
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate
  });
}

function solution(cars) {//cars es un array
//Este es el código que no funciona
return cars.filter(function(car){
if (car.licensePlate) {
return true;
}
else {
return false;
}
});
};

Con funcion de flecha y un if ternario queda mas sencillo.

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(
    car => car.licensePlate ? true : false);
}

export function solution(cars) {
    // 
    return cars.filter(function (car) {
      
        if (car.licensePlate) {
          return true;
        } else {
          return false;
        }
    });
  }

export function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate;
  });
}

la solucion era mas sencilla de lo que esperaba, pero bueno esta es mi solucion

let solution = []
    let filter = cars.find(function (car) {
        if (car.licensePlate != undefined ) {
          solution.push(car);
        } 
      }
    );
    return solution

La solución es muy simple pues solo se cambia el find por filter y se retorna como condición la busqueda de la propiedad licensePlante del objeto car

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car['licensePlate'];
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    return car.licensePlate ? true : false;
  });
}

Este es el ejercicio que más rápido resolví…

export function solution(cars) {
  // 👇 Este es el código que funciona
  return cars.filter(car => car.licensePlate);
}

Dejo mi solución al reto:

export function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate
    }
  );
}

export function solution(cars) {
  return cars.filter(function (car) {
    //No es necesario validar ya que solamente filtrariamos por el atributo licensePlate
    return car.licensePlate
  });
}

export function solution(cars) {
// 👇 Este es el código que no funciona
return cars.filter(function (car) {
if (car.licensePlate) {
return true;
} else {
return false;
}
});
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(car => 'licensePlate' in car)
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

return cars.filter((car)=>{
        if(car.licensePlate){
            return true;
        }else{
            return false;
        }
    })

A mi me salió así:
function solution(cars) {
var tienenlicense = cars.filter(function (car) {
return car.licensePlate
});
return tienenlicense;
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}
const cars = [
  {
    color: 'red',
    brand: 'Kia',
  },
  {
    color: 'gray',
    brand: 'Chevrolet',
    licensePlate: 'AAA111',
  },
  {
    licensePlate: 'RGB255',
  },
];

solution(cars);

**
export function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate;
    var x = cars.unshift(solution);
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  return cars.filter(function (car) {
    if (car.licensePlate) {
      return true;
    } else {
      return false;
    }
  });
}

export function solution(cars) {
  // 👇 Este es el código que no funciona
  var arrayLicense = cars.filter(function (car) {
    if (car.licensePlate != null) {
      return true;
    } else { 
      return false; 
    }

  });

  return arrayLicense;
}

Mi aporte

function solution(cars) {
    let car = cars.filter(function (car) {
      if (car.licensePlate) {
        return true;
      } else {
        return false;
      }
    });
    return car 
}

const cars = [
    {
      color: 'red',
      brand: 'Kia',
    },
    {
      color: 'gray',
      brand: 'Chevrolet',
      licensePlate: 'AAA111',
    },
    {
      licensePlate: 'RGB255',
    },
];
  
console.log(solution(cars)) //[
  { color: 'gray', brand: 'Chevrolet', licensePlate: 'AAA111' },
  { licensePlate: 'RGB255' }
]

mi solución:

export function solution(cars) {
  return cars.filter(function (car) {
    return car.licensePlate !== undefined;
  });
}

export function solution(cars) {
  return cars.filter((c) => !!c?.licensePlate)
}

Mi aporte

export function solution(cars) {
  var carsFilter = cars.filter(function (car) {
    return car.licensePlate;
  });
  return carsFilter;
}

export function solution(cars) {
// 👇 Este es el código que no funciona
return cars.filter(function (car) {
if (car.licensePlate) {
return car.licensePlate;
} else {
return false;
}
});
}