Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Recorriendo Arrays con .find(), .forEach() y .some()

20/22
Recursos

Aportes 258

Preguntas 34

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Por si a alguien le quedó alguna duda con respecto a la diferencia entre find y filter:

El método find () devuelve el primer valor que coincide de la colección. Una vez que coincida con el valor en los resultados, no verificará los valores restantes en la colección de matriz.

El método filter () devuelve los valores coincidentes en una matriz de la colección. Verificará todos los valores de la colección y devolverá los valores coincidentes en una matriz.

Esta pregunta me la hicieron en una entrevista:
¿Cual es la diferencia entre find y filter ?

filter retorna todas las coincidencias y find retorna solo la primer coincidencia

A modo de recopilación:

  • find() : Devuelve el primer elemento del array que cumpla con la condición dada
  • foreach() : Ejecuta lo que le definamos una vez por cada elemento de nuestro array
  • some() : Comprueba si al menos un elemento del array cumple con la condición que le damos
  • filter() : Devuelve todos los elementos del array que cumplan con la condición dada
    Acá te dejo la documentación de cada uno: find() - foreach() - some() - filter()

Mi recomendación aprendan a la perfección a utilizar estos métodos y combinen los con un if, else if y generen nuevos arreglos con push…no se queden solo con la clase, busquen ejercicios complejos.
Estos métodos son los primeros que te evalúan en una prueba técnica para algún trabajo como desarrollador.

var articulos = [
    { nombre: "Bici", costo: 3000 },
    { nombre: "TV", costo: 2500 },
    { nombre: "Libro", costo: 320 },
    { nombre: "Celular", costo: 10000 },
    { nombre: "Laptop", costo: 20000 },
    { nombre: "Teclado", costo: 500 },
    { nombre: "Audifonos", costo: 1700 },
];

//filter Genera un nuevo array
var articulosFiltrados = articulos.filter(function(articulo){
    return articulo.costo <= 500; //articulos con precio menor a 500 pesos
});

//map Ayuda a mapear ciertos elementos de los articulos, es necesario generar nuevo array
var nombreArticulos = articulos.map(function(articulo){
    return articulo.nombre;
});

//find Ayuda a encontrar algo dentro del array articulos
var encuentraArticulo = articulos.find(function(articulo){
    return articulo.nombre === "Laptop";
});

//forEach No es necesario generar nuevo array, se utiliza para realizar un recorrido de un array principal
articulos.forEach(function(articulo){
    console.log(articulo.nombre);
});

//some Se genera nuevo array, regresa un condición en Boolean
var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
});```

Muy buena clase! Es importante conocer como funcionan los métodos para no confundirlos y sacarles el máximo provecho. Las diferencias más importantes son:
El .forEach() NO crea un nuevo array y el .map() sí lo hace.
El .filter() crea un nuevo array con los objetos que cumplan una condición, el .some() solamente indica si hay o no algún objeto que cumpla dicha condición.
El .find () devuelve SOLO el primer objeto que cumpla con la condición.
EJ: Si en tu array de artículos tienes una bici de $800 y luego un celular de $800, si usas un .find() para buscar un artículo de dicho costo aparecerá solo la bicicleta, si deseas ambos tienes que usar un .filter().

Espero que les sirva y háganme saber si me equivoqué en algo, saludos.

Que buen profesor! Explica muy bien.

¿y si no encuentran lo que buscan?

find() -> regresa “undefined” si no encuentra ningún elemento que cumpla con la condifción del filtro
some() -> regresa “false” cuando ningún elemento coincide con la condición
forEach() -> regresa “undefined” en un array vacío.

  • El método forEach() llama a una función (una función de devolución de llamada) una vez para cada elemento de la matriz.

  • El método map() crea una nueva matriz al realizar una función en cada elemento de la matriz.

  • El método filter() crea una nueva matriz con elementos de matriz que pasa una prueba.

  • El método reduce() ejecuta una función en cada elemento de la matriz para producir (reducirlo) un solo valor.



Si solo el metodo .some() devuelve true o false… para que genera un nuevo Array?

El método find solo devuelve el primer valor que coincida con la condición, si buscar por ejemplo un costo de 1000 y hay varios productos, devolverá el primero.

var articulos = [
    { nombre: "Bici", costo: 3000 },
    { nombre: "TV", costo: 2500 },
    { nombre: "Libro", costo: 320 },
    { nombre: "Celular", costo: 10000 },
    { nombre: "Laptop", costo: 20000 },
    { nombre: "Teclado", costo: 500 },
    { nombre: "Audifonos", costo: 1700 }
];

var encuentraArticulo = articulos.find(function(articulo){
    return articulo.nombre === "Laptop";
});

articulos.forEach(function(articulo){
    console.log(articulo.nombre);
});

var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
});

Aquí algunas notas de la clase, Platzicoders:
.

.
Espero que les ayude.
(⌐■_■)

Un dato….
Si ponen en vez de “Console.log” / “Console.table” les mostrará la info pero en forma de tabla.

var cars = [];
var year = 2010;
function addCar(marca, modelo, anio){
    this.marca = marca;
    this.modelo = modelo;
    this.anio = anio;
}
for (let index = 0; index < 10; index++) {
    var carName = "auto"+ index; //nombre unico modelo de carro
    cars[index] = new addCar(carName, "model", year);
    year++; //incremento de cada año
    console.log(cars[index]);
}


var cars = [];
var year = 2010;

function addCar(marca, modelo, anio){
    this.marca = marca;
    this.modelo = modelo;
    this.anio = anio;
}

for (let index = 0; index < 10; index++) {
    var carName = "auto"+ index; //nombre unico modelo de carro
    cars[index] = new addCar(carName, "model", year);
    year++; //incremento de cada año
    console.log(cars[index]);
}

//Metodo 1
//Me ayuda a filtrar todos los autos con un año menor o igual a 2014
var filtroAutos = cars.filter(function(carro){return carro.anio <= 2014});

//Metodo 2
//me ayuda a mapear los autos, esto me retorna todos las marcas de los autos
var nombreAutos = cars.map(function(carro){return carro.marca});

//Metodo 3
//Me ayuda a buscar todos los autos que se llamen auto4
var filtroAutos = cars.find(function(carro){return carro.marca === "auto4"});

//metodo 4
//me ayuda a filrar sin necesidad de crear una nueva variable
cars.forEach(function(car){console.log(car.marca);});

//metodo 5
//me ayuda a validar si una funcion es verdadera solo retorna true o false… Solo me ayuda a saber si algo es verdad (ejemplo si hay autos viejos en mi array de objetos)
var autosViejos = cars.some(function(car){return car.anio < 2014;});

🤔 Los métodos tienen un uso exclusivo para una ocasión especifica. Diferenciarlos nos permite realizar una mejor implementación de los mismos.

Apuntes completos en Notion

var articulos = [
  { nombre: "Tv", costo: 1500 },
  { nombre: "PC", costo: 4000 },
  { nombre: "Bombillo", costo: 1 },
  { nombre: "Mesa", costo: 100 },
];

// .filter = filtra segun lo necesitemos
var filtro = articulos.filter(function (articulo) {
  return articulo.costo <= 1000;
});

// .map = regresa el parametro del objeto
var nombre = articulos.map( function (articulo) {
    return articulo.nombre
})

//.find = encuentra el objeto buscado segun el parametro
var encuentra = articulos.find(function (articulos) {
    return articulos.nombre === "PC"
})

//.foreach = listar 
articulos.forEach(function (articulos) {
    console.log(articulos.nombre);
})

//some = comprobar si existe o no
var baratos = articulos.some(function (articulos) {
    return articulos.costo <= 1000
})```

Operaciones sobre array:

  • find()
  • forEach()
  • some(): regresa un boolean

Diferencia entre find y filter.

.
find devuelve la primera coincidencia, filter devuelve todas

.find : devuelve el valor del primer elemento del array que cumple la función de prueba proporcionada. En cualquier otro caso se devuelve undefined.
.forEach: ejecuta la función indicada una vez por cada elemento del array.
.some : comprueba si al menos un elemento del array cumple con la condición implementada por la función proporcionada.

//Método para encontrar algo en el array, no modifica sino que crea uno nuevo
var encuentraArticulo = articulos.find(function(articulo) {
    return articulo.nombre === "Laptop";
})

//Método que no generar un nuevo array simplemente hace un filtrado, y es la forma de presentar valores o propiedades que nos interesan
articulos.forEach(function(articulo){
    console.log(articulo.nombre)
});

//Método que nos devuelve la validación de una condición específica pero no me muestra cuales son, para ello utilizo filter.
var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
})

¡Hola Platzinautas! Les comparto este apunte sobre Métodos para recorrer Arrays en JS. 😃

wo0w

Diego, eres un gran profesor!

Lo ultimo que dice es que en la siguiente clase vamos a ver dos metodos mas, pero la clase siguiente es el final del curso.
Falto una clase?

El método some() comprueba si al menos un elemento del array cumple con la condición implementada por la función proporcionada.

Documentación sobre el método some():
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array/some

No había usado some(), pero se me ocurrió hacer un filtro de esta manera:

let articulos = [
    { nombre: "Bici", costo: 3000 },
    { nombre: "TV", costo: 2500 },
    { nombre: "Libro", costo: 320 },
    { nombre: "Celular", costo: 10000 },
    { nombre: "Laptop", costo: 20000 },
    { nombre: "Teclado", costo: 500 },
    { nombre: "Audifonos", costo: 1700 }
];

let articulosBaratos = articulos.some(articulo => {
  return articulo.costo <= 700 ? console.log(articulo.nombre) : '';
});

Si la condición se cumple me retorna el nombre de los artículos que cuyo costo sea menor a 700

some retorna true o false. Dependiendo si se cumple la validación ejecutada.

const articulos = [
  { nombre: 'Bici', costo: 800000 },
  { nombre: 'Tv', costo: 2000000 },
  { nombre: 'Radio', costo: 350000 },
  { nombre: 'Movil', costo: 3000000 },
  { nombre: 'Cuaderno', costo: 50000 },
  { nombre: 'PC', costo: 1900000 },
  { nombre: 'Mouse', costo: 30000 },
  { nombre: 'Escoba', costo: 10000 }
];

let articulosFitrados = articulos.filter( ( {costo} ) => costo < 500000 ); // filtra todos los valores semejantes
console.log(articulosFitrados);

let nombreFitrados = articulos.map( ( {nombre} ) => nombre);
console.log(nombreFitrados);

let buscarArticulo = articulos.find( ( {nombre} ) => nombre === 'Cuaderno' ); // Devuelve el primer valor que encuentra
console.log(buscarArticulo);

let printArticulos = articulos.forEach( ( {nombre, costo} ) => console.log(nombre, costo)); // Itera el array como un for of

let exitenEsosArticulos = articulos.some( ( {costo} ) => costo <= 500000 ); // Devuelve Verdader cuando si existen o falso cuando no
console.log(exitenEsosArticulos);
let i = 0;
var articulosComprados = [
    {nombre:'Bici',costo:800000},
    {nombre:'Tv',costo:2000000},
    {nombre:'Radio',costo:350000},
    {nombre:'Movil',costo:3000000},
    {nombre:'Cuaderno',costo:50000},
    {nombre:'PC',costo:1900000},
    {nombre:'Mouse',costo:30000},
    {nombre:'Escoba',costo:10000}
];
var buscaArticuloCosto = articulosComprados.find(function(articulo){
    if(articulo.nombre === 'PC'){
        console.log('El articulo PC ya existe!!');
    }
});

buscaArticuloCosto;

var iteraArticulos = articulosComprados.forEach(function(articulo){
    i++;
    console.log(`Articulo #${i}. ${articulo.nombre}`);
});

var validaArticulo = articulosComprados.some(function(articulo){
    return articulo.costo<=30000;
});
console.log(`¿Existe al menos 1 articulo de 30.000 o menos? ${validaArticulo ?'Si' :'No'}`);

Apliqué el articulo.nombre === “Laptop” con el método FILTER y de igual forma funcionó. Dicho esto…
¿Cuál sería el mejor método a elegir y por qué?

Buena clase.
Aunque parece que algo hizo falta, pues el siguiente video es la despedida…

var articulos = [{
        nombre: "Bici",
        costo: 3000
    },
    {
        nombre: "TV",
        costo: 2500
    },
    {
        nombre: "Libro",
        costo: 320
    },
    {
        nombre: "Celular",
        costo: 1000,
    },
    {
        nombre: "Laptop",
        costo: 20000
    },
    {
        nombre: "Teclado",
        costo: 500
    },
    {
        nombre: "Audifonos",
        costo: 1700
    },
];
// Metodo .find

// Este metodo nos ayuda a encontrar algo adentro de este articulo en este ejemplo, este me generara un nuevo array con el valor que le puse este valida un true o un false si existe si existe me regresa un resultado si no se cumple no me devuelve nada

var encuentraArticulo = articulos.find(function (articulo) {
    return articulo.nombre === "Laptop"
});

// Metodo forEach
// forEach no me genera un array simplemente hace un filtrado sobre el array
// en que queremos buscar sin modificar cosas
// mandamos a llamar a

articulos.forEach(function (articulo) {
    console.log(articulo.nombre);
});

// esto me regresa son los valores de nombre de mi array

// Bici
// TV
// Celular
// Laptop
// Teclado
// Audifonos
// Libro

// metodo .some()
// .some() Nos regresa una validacion de verdadero o falso para articulos que cumplan
// con esta validacion

var articulosBaratos = articulos.some(
    function(articulo) {
        return articulo.costo <= 700;
    }
);
//  en este caso ve devolvera un true por que tenggo articulos menosres a 700

//  esto nos puede ayudar si trabajamos en una tienda digital y el usuario quiere filtrar si hay articulos menorews a ese precio

Find. te devuelve el primero elemento del array que coincida con la condición.

ForEach. Recorre el array o elemento del array seleccionado.

some. te devuelve literalmente un boolean, si alguno de los elementos del array, cumple con la condición descrita dentro del some. Devuelve true, de lo contrario devuelve False.

mi pregunta es la siguiente ,para que nos serviría en el futuro estos metodos(filter, map ,find) para que nos serviria ?

/**
 * 3. find() ---> encontrar algo dentro del array
 * genera un nuevo array
 */

 var encuentraArticulo = articulos.find(function(articulo){
     return articulo.nombre === "Laptop"
 });

 console.log(encuentraArticulo)
 // { nombre: 'Laptop', costo: 20000 }

 /**
  * foreach ---> no genera un array nuevo
  */

  articulos.forEach(function (articulo){
        console.log(articulo.nombre);
  });

  /**
   * Bici
TV
Libro
Celular
Laptop
Teclado
Audifonos
   */

   // 4. some() --> regresa una validacion de veradero o falso
   // se genera un nuevo arreglo

   var articulosBaratos = articulos.some(function(articulo){
        return articulo.costo <= 700
   });

   console.log(articulosBaratos);

   // true ```

Si existe mas de 1 articulo con el mismo nombre, find solo te devuelve el primero que encuentra.

Algunos métodos son muy similares, aunque son exclusivamente para una ocasión especifica

//Javascript te permite crear arrays de objetos
var cumpleannos = [
    {persona:"Luna",dia:13},
    {persona:"Mia",dia:8},
    {persona:"Valery",dia:19},
    {persona:"Arturo",dia:3},
    {persona:"Marisol",dia:3},
    {persona:"Leo",dia:18},
    {persona:"Leslie",dia:24},
    {persona:"Mia",dia:22},
    {persona:"Jose",dia:31},
    {persona:"Mia",dia:4},
]
/* METODO FILTER Crea un nuevo arreglo y con la funcion pasando como parametro cada objeto, regresa al arreglo que se esta creando
los objetos que cumplen con la condicion en el return*/
var cumpleannosPosterioresA10 = cumpleannos.filter(function(cumpleanno){
    return cumpleanno.dia >= 10;
});
/* METODO MAP Crea un nuevo arreglo ya no con objetos, sino con los valores del valor que necesitamos */
var nombresCumpleanneros = cumpleannos.map(function(nombreCumpleannero){
    return nombreCumpleannero.persona;
});
/*METODO FIND Sirve para buscar dentro de un arreglo en este caso dentro de varios objetos el valor buscado y 
crea un nuevo arreglo con la busqueda, el detalle es que al parecer solo retorna el primer valor encontrado, en caso
que este se encuentre duplicado */
var buscarCumpleannero = cumpleannos.find(function(cumpleannero){
    return cumpleannero.persona === "Mia";
});
/*METODO FOREACH A diferencia de los anteriores no genenra un arreglo solo obtiene los valores indicados en el arreglo*/
cumpleannos.forEach(function(cumpleanno){
    console.log(cumpleanno.persona);
});

/* METODO SOME Te permite validar mediante un true o false si se cumple una condicion dentro de tus arreglos */
var nombreMia = cumpleannos.some(function(nombre){
    return nombre.persona === "Mia";
}
);```

Este es un excelente sitio para aprender y conocer todos los métodos que existen de los Arrays y este es un excelente sitio para practicar

METODO FILTER:
El metodo filter crea un nuevo array en donde se almacenan
solo los objetos que pasaron el filtro que se le indico en
la funcion.

METODO FIND:
El metodo find es un metodo de busqueda no de filtrado,
por lo que siempre retornara el primer objeto que
encuentre que cumpla con los parametros establecidos
por la funcion entonces dejara de iterar.

De la manera en que lo entendi la diferencia entre el metodo Find() y Filter() es: mientras filter itera por todo el array filtrando los objetos que cumplan con los parametros pasados por la funcion retarnodolos al nuevo array. Find es un metodo de busqueda, por lo que solo retornara el primer objeto que encuentre con los parametros pasados por la funcion y cuando esto ocurra ya no iterara mas por el array.

Les comparto mi trabajo

var articulos=[
    {nombre:"bici", costo:300, categoria:"deportes"},
    {nombre:"tv", costo:280,categoria:"tecnología"},
    {nombre:"libro", costo:60,categoria:"osio"},
    {nombre:"celular", costo:423,categoria:"tecnología"},
    {nombre:"trotadora", costo:253,categoria:"deportes"},
    {nombre:"revista", costo:4,categoria:"osio"},
    {nombre:"laptop", costo:1423,categoria:"tecnología"},
    {nombre:"lima", costo:5,categoria:"belleza"},
    {nombre:"licuadora", costo:75,categoria:"hogar"},
    
]

var categoriaArticulos=articulos.filter(function(articulo){
    return articulo.categoria==="tecnología"
})
console.log(`Los artículos filtrados por la categoría son :`)

console.log(categoriaArticulos)

var precios=articulos.filter(function(articulo){
    return articulo.costo>60 && articulo.costo<=300
})
console.log(`Los artículos filtrados por rango de precio son:`)

console.log(precios)

var nombre=articulos.filter(function(articulo){
    return articulo.nombre.includes("li")
})
console.log(`Los artículosque coinciden con el criterio de busqueda son:`)
console.log(nombre);

diferencia entre .map y forEach:

  • map: retorna un arreglo con la información solicitada.

  • forEach: retorna una lista con la información solicitada.

Para visualizar los arrays con objetos, en vez de usar
console.log( articulos) Les recomiendo utilizar console.table( articulo) 🙌🏻

En mi opinion esta es de las clases mas importantes para todo programador junior.

Ecomerce.

El celular y los audífonos más caros el curso jajaja

Se nota cuando un profesor sabe un tema, lo explica tan simple

Sigan a este canal de youtube.
https://www.youtube.com/watch?v=R8rmfD9Y5-c

🤖🤖🤖
find() : Devuelve el primer elemento del array que cumpla con la condición dada
foreach() : Ejecuta lo que le definamos una vez por cada elemento del array.
some() : Comprueba si al menos un elemento del array cumple con la condición que le demos.
filter() : Devuelve todos los elementos del array que cumplan con la condición dada.

Dejo mis apuntes

//.find nos ayuda a encontrar algo dentro de articulos
var encuentraArticulo = articulos.find(function (articulo) {
    return articulo.nombre === "Sillon"
});
console.log(encuentraArticulo);

//.forEach no crea un nuevo array
articulos.forEach(function (articulo) {
    console.log(articulo.nombre);
});

//.some devuelve true o false dependiendo si cumple la condición
var articulosBaratos = articulos.some(function (articulo) {
    return articulo.costo <= 700;
});
console.log(articulosBaratos);

Aqui les dejo los 5 metodos con arrow functions:

//Metodos de recorrido

const items = [
	{ nombre: 'Celular', precio: 1000 },
	{ nombre: 'Computadora', precio: 1500 },
	{ nombre: 'Calculadora', precio: 2000 },
	{ nombre: 'Teclado', precio: 100 },
	{ nombre: 'Raton', precio: 70 },
	{ nombre: 'Bicicleta', precio: 30000 },
];
//Metodo filter
const itemsFilter = items.filter(item => item.precio <= 500);
console.log(itemsFilter);

//Metodo map

const nameItems = items.map(item => item.nombre);
console.log(nameItems);

//Metodo find

const itemFind = items.find(item => item.nombre === "Calculadora");
console.log(itemFind);

//Metodo foreach 

items.forEach(item => console.log(item.nombre));

//Metodo some

const cheapItems = items.some(item => item.precio <= 500);
console.log(cheapItems);

Apuntes resumidos para quien le interese y sirva:

Más métodos

  1. Find: funciona con false y true, si existe el artículo es true y lo regresa, si no existe es false y no va a regresar nada.
var encuentraArticulo = articulos.find(function(articulo){
    return articulo.nombre === "Laptop"
});
undefined
encuentraArticulo
{nombre: "Laptop", costo: 20000}
  1. For each: a diferencia de métodos pasados, este no crea arrays nuevos.
articulos.forEach(function(articulo){
    console.log(articulo.nombre)
});

Bici
Tv
Libro
Celular
Laptop
Teclado
Audífonos

Regresa la propiedad deseada únicamente.

  1. Some: Regresa una validación de true o false a la condición que establezca la función
var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
});

articulosBaratos
true

Solo indica que sí, sí hay artículos que cuesten menos de 700.

otra forma de llamar al foreach

articulos.forEach(articulo => {
    console.log(articulo.nombre);
});```

El método find() devuelve un objeto (el primero coincidente), el método filter() devuelve un array con todas las coincidencias.

var articulos  = [
    {nombre: "bici", costo: 3000 },
    {nombre: "tv", costo: 2500 },
    {nombre: "libro", costo: 320 },
    {nombre: "celular", costo: 10000 },
    {nombre: "laptop", costo: 20000 },
    {nombre: "teclado", costo: 500 },
    {nombre: "audifonos", costo: 1700 },
];

var articulosFiltrados = articulos.filter(function(articulo){
    return articulo.costo <= 500
});

var nombreArticulos = articulos.map(function(articulos){
    return articulos.nombre
});
var encuentraArticulos = articulos.find(function(articulos){
    return articulos.nombre === "laptop"
});

var articulosBaratosdd = articulos.some(function(a){
    return a.costo >= 700
});

articulos.forEach(function(a){
    console.log(a.nombre)
    console.log(a.costo)
});
  • .find(): Como su nombre lo dice, es utilizada estrictamente para buscar un elemento en especifico dentro de nuestra array.

  • .forEach(): Este método en comparación con los demás anteriores no generara ningún array nuevo, si no que caminará sobre el array original y dependiendo las condiciones que le pongamos a dicho método nos generará algunas cosas.

  • .some(): este método nos retornara un nuevo arreglo de artículos que cumplan con la validación que nosotros le asignemos en dicho método. Pero debemos tener en cuenta que esta validación será de valor booleano, solo retornará verdadero o falso.

// Recorrer Array
let tasks = [{
        description: "Enviar mail de status laboral",
        priority: "HIGH",
        done: false,
    },
    {
        description: "Buscar ropa de la lavandería",
        priority: "LOW",
        done: false,
    },
    {
        description: "Pagar el seguro",
        priority: "HIGH",
        done: false,
    },
    {
        description: "Pasar por el super mercado",
        priority: "LOW",
        done: false,
    },
];

// filter() devuelve un nuevo array con los elementos que coinciden con el filtro.
const tasksHigh = tasks.filter((task) => {
    return task.priority === "HIGH";
});
const tasksLow = tasks.filter((task) => {
    return task.priority === "LOW";
});
console.log('Prioridad Alta: ', tasksHigh);
console.log('Prioridad Baja: ', tasksLow);

// maps() recorre todos los elementos
// en caso de pasarle algo para que compare devuelve true o false.
const tasksMaps = tasks.map(task => {
    return task.description;
});
const tasksFilterWhitMaps = tasks.map(task => {
    return task.priority === "LOW";
});
console.log('Mapeando  ', tasksMaps);
console.log('Mapeando tasksFilterWhitMaps ', tasksFilterWhitMaps); // [ false, true, false, true ]

// find() Devuelve la primera coincidencia
const tasksFind = tasks.find(task => {
    return task.priority === 'HIGH';
});
console.log('tasksFind', tasksFind);

// foreach() // No genera un nuevo array
tasks.forEach(task => {
    console.log('Descripción: ', task.description);
});

// some() recorre y verifica si hay algún elemento que coincida con el parámetro enviado
const tasksSome = tasks.some(task => {
    return task.done === true;
});
console.log('tasksSome: ', tasksSome);

buena clase, nos toca es practicar

Muy bien explicado.

Para crear un array con un grupo de objetos que cumplan la condición hice lo siguiente, comentarios please para saber si estoy en lo correcto:

var articulosEncontrados = [];
articulos.forEach((articulo) => {
  articulo.nombre === 'Laptop' ? articulosEncontrados.push(articulo) : false;
})

var articulos = [
{nombre: “bici”, costo: 3000},
{nombre:“tv”, costo: 2500},
{nombre: “libro”, costo:320},
{nombre: “celular”, costo: 10000},
{nombre: “laptop”, costo:20000},
{nombre: “teclado”, costo: 500},
{nombre: “audifonos”, costo: 1700},
];

//metodo filter
var articulosfiltados = articulos.filter(function(articulos){
return articulos.costo <= 500
});

//metodo map
var nombrearticulos = articulos.map(function(articulos){
return articulos.nombre
});

//metodo for forEach
articulos.forEach(function(articulo) {
console.log(articulo.nombre);

});

//metodo some

var articulosbaratos = articulos.some(function(articulos){
return articulos.costo <= 700;
});

que clase tan estupenda 😄 que felicidad 😄

Muy interesante, ya estoy aclarando algo que me confundía mucho en JS el tema de las functions como parámetros, porqué razón colocan eso, etc… y los métodos perfectamente explicados profe, muy bien!

Diego explica todo súper simple y con excelentes ejemplos! 😮

<code>var articulos = [
      {nombre: "arduino",costo: 1000},
      {nombre: "raspberrypi",costo: 1500},
      {nombre: "nodemcu",costo: 500},
      {nombre: "pic",costo: 200},
      {nombre: "plc",costo: 3000},
      {nombre: "daq",costo: 5000}  
];
var articulo = articulos.push("tarjeta personalizada"); //agrega elemento al final del arreglo
var articulo = articulos.pop("tarjeta personalizada"); //elimina elemento del final del arreglo
var articulo = articulos.shift("tarjeta personalizada"); //agrega elemento al inicio del arreglo
var articulo = articulos.unshift("tarjeta personalizada"); //elimina elemento al inicio del arreglo
var articulo = articulos.indexOf("arduino"); //Regresa el index del elemento dentro del arreglo
var filtrado = articulos.filter(function(articulo){
      return articulo.costo <= 1000});    //filtra un elemento con base a una condición
var mapeo = articulos.map(function(articulo){
            return articulo.nombre});     //regresa un arreglo con la información de los elementos solicitados
var encuentra = articulos.find(function(articulo){
      return articulo.nombre==="pic"});   //Encuentra el elemento del arreglo con la característica solicitada
articulos.forEach(function(articulo){
      console.log(articulo.nombre);       //itera todo el arreglo y regresa la información solicitada
});
var filtrado = articulos.some(function(articulo){
      return articulo.costo >= 1000});    //regresa un valor booleano si el arreglo cuenta con elementos que coincidan con la descripción</code>

Transmito el resumen de los métodos de recorrido:

var articulos = [
    { nombre: "Bicicleta", costo: 200 },
    { nombre: "Telvesion", costo: 2300 },
    { nombre: "Libro", costo: 120 },
    { nombre: "Celular", costo: 4000 },
    { nombre: "Laptop", costo: 5400 },
    { nombre: "Mesa", costo: 400 },
    { nombre: "Audifonos", costo: 1700 }
];

//Metodo Filter
var articulosFiltrados = articulos.filter(function (articulo) {
    return articulo.costo < 500;
});

// Método Map
var nombreArticulos = articulos.map(function (articulo) {
    return articulo.nombre;
});

//Método find
var encuentraArticulo = articulos.find(function (articulo) {
    return articulo.nombre === "Libro";
});

// Método forEach
articulos.forEach(function (articulo) {
    console.log(articulo.nombre == "Libro");
});

// Método some. Solo nos regresa si es True o False.
var articulosBaratos = articulos.some(function (articulo) {
    return articulo.costo <= 500;
});```

Find. te devuelve el primero elemento del array que coincida con la condición.

ForEach. Recorre el array o elemento del array seleccionado.

some. te devuelve literalmente un boolean, si alguno de los elementos del array, cumple con la condición descrita dentro del some. Devuelve true, de lo contrario devuelve False.

no me queda claro porque en la funcion se coloca articulo en vez de colocarlo en plural articulos?

No digo que el curso esté super super claro pero la verdad está bastante entendible respecto a otros cursos que he tomado. Gracias Diego

hola compañeros les comparto una nueva sintasis para lo visto en clase por el momento no se como es el nombre a este tipo de funciones …xd les recomiendo si lo saben gracias

var productos=[
    {nombre: "Bicicleta",costo:3000},
    {nombre: "Ollas", costo:2500},
    {nombre: "Pintura", costo:3400},
    {nombre:"Tempera", costo:4500},
    {nombre:"Tasa",costo:5455 },
    {nombre:"Rompecabezas", costo:2330}
];
//metodo visto en clase
var BuscandoProductos = productos.filter(function(encontrado){
    return encontrado.costo >= 500 
}) ;
//metodo con nueva sintasis por el momento no se el nombre..xd
var productosEncontrados = productos.filter(nuevo => {return nuevo.costo >= 3000})

el find no regresa un array regresa un objeto o undefined

El uso de los arrays es muy importante y los métodos asociados al trabajo con ellos ayudan a estar más preparados a hacerlo de manera más eficiente

var articulos = [
    {nombre: "Bici", costo: 3000},
    {nombre: "Tv", costo: 2500},
    {nombre: "Libro", costo: 320},
    {nombre: "Celular", costo: 10000},
    {nombre: "Laptop", costo: 20000},
    {nombre: "Teclado", costo: 500},
    {nombre: "Audifonos", costo: 1700}
];

articulos.forEach(function(p){
    console.log(p.costo + " " + p.nombre);

Si funciona

El metodo find NO DEVUELVE UN ARRAY, devuelve un objeto del valor encontrado.

Dejo códigos con anotaciones;

/*Array con objetos */
let articulos =[
    {nombre: "Bici", costo: 3000},
    {nombre: "Tv", costo: 2500},
    {nombre: "Libro", costo: 320},
    {nombre: "Celular", costo: 10000},
    {nombre: "Laptop", costo: 20000},
    {nombre: "Teclado", costo: 500},
    {nombre: "Audifonos", costo: 1700}
];

/*some() comprueba si al menos un elemento del array cumple con la 
condición implementada por la función proporcionada. */
var buscarExistencia = articulos.some(function(articulo){
    return articulo.nombre === "Bici";
});

/*forEach() ejecuta la función indicada una vez por 
cada elemento del array. NO RETORNA DATOS*/
articulos.forEach(function(articulo){
    console.log(articulo.nombre);
});

/*filter()  crea un nuevo array con todos los elementos que cumplan 
la condición implementada por la función dada.*/

let articulosEncontrados = articulos.filter(function(articulo){
    return articulo.costo >= 3000;
});

/*map() crea un nuevo array con los resultados de la llamada a la función 
indicada aplicados a cada uno de sus elementos. */

let articulosCostos = articulos.map(function(articulo){
    return articulo.costo;
});

La forma más sencilla que yo encontrè para diferenciar
Filter: devuelve varios parámetros respecto a la validación
Find: devuelve un único parámetro respecto a la validación

Lo siento tenia hambre :v

var productos=[
    {articulo:"Tabla",tipo:"Res"},
    {articulo:"Higado",tipo:"Res"},
    {articulo:"Solomo Extranjero",tipo:"Res"},
    {articulo:"Cañon",tipo:"Cerdo"},
    {articulo:"Costillas",tipo:"Res"},
    {articulo:"Costillas",tipo:"Cerdo"},
    {articulo:"Morcilla",tipo:"Cerdo"}
    
]

var clasificarArticulos=productos.filter(function(articulo){
        return articulo.tipo=="Cerdo";
});

console.log(clasificarArticulos);

var nombreArticulos=productos.find(function(producto){
       return producto.articulo=="Higado";
})

console.log(nombreArticulos);
var articulos = [
	{ nombre: '📱', precio: 1000 },
	{ nombre: '💻', precio: 1500 },
	{ nombre: '🖥', precio: 2000 },
	{ nombre: '⌨️', precio: 100 },
	{ nombre: '🖱', precio: 70 },
	{ nombre: '🚗', precio: 30000 },
];

// Metodo filter, valida si es verdad o falso
let articulosFiltrados = articulos.filter( (articulo) => {
   return articulo.precio <= 500; // Quiero que mefiltren los articulos que sean menor a 500
});
console.log(articulosFiltrados);

// Map, ayuda a mapear ciertos articulos
let nombreArticulos = articulos.map( (articulo) => {
    return articulo.nombre;
});
console.log(nombreArticulos);

// El find sirve para encontrar cosas que tengan el valor que tu pongas
let encuentraArtriculo = articulos.find( (articulo) => {
    return articulo.nombre == '🚗'; 
});
console.log(encuentraArtriculo);

// ForEach() hace el filtrado y regresa los valores, no genera un array
articulos.forEach( (recorrer ) => {
    console.log(recorrer.nombre);
});

// El some() nos hace una validacion, nos regresa true o false
let articulosBaratos = articulos.some( (articulos) => {
    return articulos.precio <= 700;
});
console.log(articulosBaratos);
var articulos = [
    { nombre: "Bicicleta" , costo: 3750 },
    { nombre: "Motocicleta" , costo: 10000 },
    { nombre: "Television" , costo: 7500 },
    { nombre: "iPhone 11" , costo: 8900 },
    { nombre: "iPad" , costo: 4800 },
    { nombre: "Teclado" , costo: 500 },
    { nombre: "Airpods" , costo: 3200 }
];

//


var articulosFiltrados = articulos.filter( function( articulo ) {
    return articulo.costo <= 500;
} );

var nombreArticulos = articulos.map( function( articulo ) {
    return articulo.nombre;
} );

var encuentraArticulo = articulos.find( function( articulo ) {
    return articulo.nombre === "Laptop";
} );

// articulos.forEach( function( articulo ) {
//     console.log( articulo.nombre );
// } );

articulos.forEach( function( articulo ) {
    if ( articulo.costo > 4000 ) {
        console.log( articulo.nombre );
    }
} );

var articulosBaratos = articulos.some( function( articulo ) {
    return articulo.costo <= 700
} );
// Recorriendo Arrays con .find(), .forEach() y .some()

var articulos = [
    {nombre: "Bicicleta", costo: 3000},
    {nombre: "TV", costo: 2500},
    {nombre: "Libro", costo: 320},
    {nombre: "Celular", costo: 10000},
    {nombre: "Laptop", costo: 20000},
    {nombre: "Teclado", costo: 500},
    {nombre: "Audifonos", costo: 1700},
];

//find nos devuelve el primer elemento del array que cumpla con la condicion
var encuentraArticulo = articulos.find(function(articulo){
    return articulo.nombre === "Laptop";
});

//forEach ejecuta lo definido una vez por cada elemento 
articulos.forEach(function(articulo){
    console.log(articulo.nombre);
});

//Some nos comprueba si hay al menos un elemento que cumpla con la condicion
var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
});
var articulo =[
    {nombre: "bici",costo:3000},
    {nombre: "tv",costo:2500},
    {nombre: "tv",costo:320},
    {nombre: "celular",costo:1000},
    {nombre: "laptop",costo:20000},
    {nombre: "teclado",costo:500},
    {nombre: "audifonos",costo:1700},
]

//Filter:
//este metodo consiste en crear un array en que se filtraran los valores que solicitamos de un array 
//articulos_filtrados tiene como valor a los objetos del array iguales o menores a 500

var articulos_filtrados = articulos.filter(function(articulo){
    return articulo.costo <= 500
});

//Map:
//este metodo consiste en mapear un tipo de valor de un array en otro array
//articulos_mapeados tendra el valor de los nombres de los objetos del array articulo 

var articulos_mapeados = articulos.map(function(articulo){
    return articulo.nombre
});

//Find:
//este metodo consiste en filtrar valores que tengan un tipo exacto segun la validacion que tenga la funcion 
//es un metodo mas estricto que filter 

var articulos_filtrados = articulos.find(function(articulo){
    return articulo.nombre === "laptop"
});

//Some:
//este metodo consiste en crear una variable que retorne valor boleano dependiendo la validcion que se le haga al array

var articulo_de_filtro = articulos.some(function(articulo){
    return articulo.costo <= 700;
});

var  articulos = [
	{ nombre: "Bici", costo: 3000 },
	{ nombre: "Tv", costo: 2500 },
	{ nombre: "Libro", costo: 320 },
	{ nombre: "Celular", costo: 10000 },
	{ nombre: "Laptop", costo: 20000 },
	{ nombre: "Teclado", costo: 500 },
	{ nombre: "Audífonos", costo: 1700 },
] ;

Find: éste método no va a modificar el array que ya tenemos, sino que va a generar un nuevo array con el valor que le pasemos, si es que lo encuentra, find va a validar un true o un false, si el artículo existe lo va a regresar, si no existe no lo hace.

var encuentraArticulo = articulos.find(function(articulo){
	return articulo.nombre === "Laptop"
});

Estamos generando un array que va a tener como valor “articulos.find”(el array del ejemplo anterior), este a su vez va a tener una function que como parámetro va a tener “articulo”, es decir, vamos a buscar un artículo, y pedimos que la función nos retorne del array “articulos” un articulo cuya referencia sea estrictamente igual a “Laptop”. si tiene el articulo llamado “Laptop”, que lo regrese o retorne, si no lo tiene que no regrese nada.

> encuentraArticulo
< { nombre: "Laptop", costo: 20000 }

Ahora éste nuevo array “encuentraArticulo” ya tiene el artículo del ejemplo.

ForEach (): este método no va a generar un nuevo array, simplemente va a hacer el filtrado sobre “articulos” y nos va a regresar cosas:

articulos.forEach(function(articulo){
	console.log(articulo.nombre);
});

Como no va a generar un nuevo array, hay que llamar directamente articulos.forEach(), adentro del método generamos una función, como parámetro colocamos el articulo que queremos que nos traiga, y le pedimos nos imprima los nombres de los artículos que tiene este array.

Si en vez de .nombre colocamos .costo, nos traería los mismos. Esto nos puede servir por ejemplo, si estamos trabajando en un e-comerce, y el usuario que esta intentando comprar un artículo y hace ciertos filtros dentro del sitio, para ver productos de cierto costo o marca, de ésta manera programaríamos los filtros del e-comerce.

Some(): nos va a regresar una validación de verdadero o falso, para artículos que cumplan con esa validación.

var articulosBaratos =  articulos.some(function(articulo) {
	return articulo.costo <= 700;
});

Con éste método creamos un nuevo array, la función nos va a ayudar a validar, si un artículo tiene un costo menor o igual a 700 pesos.

> articulosBaratos
< true

Nos regresa true, porque nos dice, si hay artículos menores a 700 pesos, si no se cumple la condición, nos regresa false.

//**Las diferencias más importantes son:
//El .forEach() NO crea un nuevo array y el .map() sí lo hace.
//El .filter() crea un nuevo array con los objetos que cumplan una condición, el .some() solamente indica si hay o no algún objeto que cumpla dicha condición.
//El .find () devuelve SOLO el primer objeto que cumpla con la condición.
//EJ: Si en tu array de artículos tienes una bici de $800 y luego un celular de $800, si usas un .find() para buscar un artículo de dicho costo aparecerá solo la bicicleta, si deseas ambos tienes que usar un .filter().
//find() -> regresa “undefined” si no encuentra ningún elemento que cumpla con la condifción del filtro
//some() -> regresa “false” cuando ningún elemento coincide con la condición
//forEach() -> regresa “undefined” en un array vacío.


var articulos = [
    { nombre: "Bici", costo: 3000 },
    { nombre: "TV", costo: 2500 },
    { nombre: "Libro", costo: 320 },
    { nombre: "Celular", costo: 10000 },
    { nombre: "Laptop", costo: 20000, fabricacion: "Esp" },
    { nombre: "Teclado", costo: 500 },
    { nombre: "Audifonos", costo: 1700 },
];
////crea New array filter filtra lo que pides
var articulosFiltrados = articulos.filter(function(articulo) {
    return articulo.costo <= 500;
    //Devuelve articulos con precio menor a 500 pesos
});

//crea New array map Ayuda a mapear ciertos elementos de los articulos, 
var nombreArticulos = articulos.map(function(articulo) {
    return articulo.nombre;
    // Devuelve el nombre de todos los articulos
});

//find Ayuda a encontrar algo dentro del array articulos
var encuentraArticulo = articulos.find(function(articulo) {
    return articulo.nombre === "Laptop";
    // Devuelve todos los datos de dicha peticion coste etc
    // Si hay varios articulos con el mismo nombre solo devuelve el primero
    // Si buscar por ejemplo un costo de 1000 y hay varios productos, devolverá el primero.
});

//forEach No es necesario generar nuevo array, 
// se utiliza para realizar un recorrido de un array principal
// El método forEach() llama a una función (una función de devolución de llamada) una vez para cada elemento de la matriz.
articulos.forEach(function(articulo) {
    console.log(articulo.nombre); // Devuelve todos los nombres
});

//crea New array !!! PERO NO ES NECESARIO !!!, some , regresa un condición en Boolean
var articulosBaratos = articulos.some(function(articulo) {
    return articulo.costo <= 700;
    // Return = True: Si lo encuentra, False: Si no lo encuentra
    //EJ: cumplen especificacion, marca, promocion,fecha,costo.
});

// !!! RECOMENDACION !! 
//Aprendan a la perfección a utilizar estos métodos y combinen los con un if, else if y generen nuevos arreglos con push…no se queden solo con la clase, busquen ejercicios complejos.
//Estos métodos son los primeros que te evalúan en una prueba técnica para algún trabajo como desarrollador

metodos para recorrer arrays:
find()
some()
foreach()
filter()

forEach

.find

<
//Resumen

var articulos = [
    { nombre: "Bici", costo: 3000 },
    { nombre: "TV", costo: 2500 },
    { nombre: "Libro", costo: 320 },
    { nombre: "Celular", costo: 10000 },
    { nombre: "Laptop", costo: 20000 },
    { nombre: "Teclado", costo: 500 },
    { nombre: "Audifonos", costo: 1700 },
];

//  filter
//Crea un nuevo array con los elementos del array que se pasó como parámetro y que cumplan con la condición definida.

var articulosFiltrados = articulos.filter(function(articulo){
    return articulo.costo <= 500; //articulos con precio menor a 500 pesos
});

// map
//Crea un nuevo array con los resultados de la llamada a la función indicada aplicados a cada uno de sus elementos.

var nombreArticulos = articulos.map(function(articulo){
    return articulo.nombre;
});

//  find
//Retorna el primer elemento de un array que cumple con una condición definida en un nuevo array.

var encuentraArticulo = articulos.find(function(articulo){
    return articulo.nombre === "Laptop";
});

//    forEach
// Ejecuta la función indicada una vez por cada elemento del array.

articulos.forEach(function(articulo){
    console.log(articulo.nombre);
});

// some
//Retorna "true"o “false” si hay elementos en un array que cumplan con la condición indicada.

var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;
});





> 

Podemos verificar si depronto un usuario existe o no en el array.

var user = prompt("Ingresa tu usuario");

var usuarios = [
    {usuario: "Darwing"},
    {usuario: "Dallana"},
    {usuario: "Nicolas"},
]

var verificacion = usuarios.some(function(nickname){
    return nickname.usuario === user;
})

if(verificacion){
    alert("usuario ya existe");
}else{
    usuarios.push({usuario: user})
    alert("Usuario se registro con éxito");
}

console.log(usuarios);

Recorriendo Arrays con .find(), .forEach() y .some()

//Recorriendo Arrays con .find(), .forEach() y .some()
//23-Noviembre-2021
//JavaScript

var articulos = [
	{ nombre: "Bicicleta", costo: 3000 },
	{ nombre: "Tv", costo: 2500 },
	{ nombre: "Libro", costo: 320 },
	{ nombre: "Celular", costo: 1000},
	{ nombre: "Laptop", costo: 20000},
	{ nombre: "Teclado", costo: 500},
	{ nombre: "Audifonos", costo: 1700},		
]
//FIND:  No modifica el array genera uno nuevo
//Valida un true o false si existe lo regresa y si no devuelve false
var encuentraArticulos = articulos.find(function(articulo){
	return articulo.nombre === "Laptop"
})
console.log(encuentraArticulos);  
//Salida: {nombre: 'Laptop', costo: 20000}


//FOREACH hará un filtrado sobre un arreglo y genera un nuevo array
//de acuerdo al la propiedad escogida para filtrar
articulos.forEach(function(articulo){
	console.log(articulo.nombre)
})
//Salida: Bicicleta
//		  Tv
//		  Libro
//		  Celular
//		  Laptop
//		  Teclado
//		  Audifonos


//SOME regresa una validación de verdadero o falso
// para articulos que cumplan esa validación
// tambien se va a generar un nuevo array
var articulosBaratos = articulos.some(function(articulo){
	return articulo.costo <= 700;
	});
console.log(articulosBaratos)
//salida: True


var articulos = [
    { Nombre: "bici", costo: 3000}, 
    { Nombre: "TV", costo: 2500 },
    { Nombre: "Libro", costo: 320 },
    { Nombre: "Celular", costo: 10000 },
    { Nombre: "Laptop", costo: 20000 },
    { Nombre: "Teclado", costo: 500 },
    { Nombre: "Audifonos",costo: 1700},
];

// var articulosFiltrados = articulos.filter(function(articulo){
//     return articulo.costo <= 500
//         console.log(articulosFiltrados);         //Estos filtran los valores con un menor costo segun lo indicado


var nombreA = articulos.map(function(articulo){  //Filtramos todos los nombres dentro de "articulos"
    return articulo.Nombre
});


var encuentraArticulo = articulos.find(function(articulo){
    return articulo.Nombre === "Laptop" ///Encuentra un articulo en especifico
});



articulos.forEach(function(articulo){
    console.log(articulo.Nombre);



}); /// Recorre todo los nombres

var articulosBaratos = articulos.some(function(articulo){
    return articulo.costo <= 700;


}); //Solo imprime si es true and false si tenemos disponibilidad de objetos que cumplen con el parametro


//recopilación:

/* find() : Devuelve el primer elemento del array que cumpla con la condición dada
foreach() : Ejecuta lo que le definamos una vez por cada elemento de nuestro array
some() : Comprueba si al menos un elemento del array cumple con la condición que le damos
filter() : Devuelve todos los elementos del array que cumplan con la condición dada
Acá te dejo la documentación de cada uno: find() - foreach() - some() - filter() */

**Diferencia entre find, filter y map.
**

var productos = [
  { nombre: 'TV', costo: 2500 },
  { nombre: 'Libro', costo: 500 },
  { nombre: 'Celular', costo: 20000 },
  { nombre: 'laptop', costo: 20000 },
  { nombre: 'teclado', costo: 500 },
  { nombre: 'audifonos', costo: 1700 }
];
encontrarProductos = productos.find( function(producto) {
  return producto.costo === 20000; 
});
console.log("Usando find: ",encontrarProductos);
// >> {nombre: 'Celular', costo: 20000}

encontrarProductos = productos.filter( function(producto) {
  return producto.costo === 20000;
});
console.log("Usando filter: ",encontrarProductos);
  /* 0: {nombre: 'Celular', costo: 20000}
    1: {nombre: 'laptop', costo: 20000}*/

encontrarProductos = productos.map( function(producto) {
  return producto.costo === 20000;
});
console.log("Usando map: ",encontrarProductos);
  /* [false, false, true, true, false, false] */
// Recorriendo Arrays con .find(), .forEach() y .some()

var articulos = [
    {nombre:"bicicleta", costo:"3000"},
    {nombre:"tv", costo:"2500"},
    {nombre:"libro", costo:"320"},
    {nombre:"celular", costo:"10000"},
    {nombre:"Laptop", costo:"20000"},
    {nombre:"Teclado", costo:"500"},
    {nombre:"Audifonos", costo:"1700"}
]

// forma de recorrer un array list con el metodo find
var encontrarArticulo = articulos.find(function(articulo){
    return articulo.nombre ==="Laptop" // este es mas preciso por que retorna el articulo con su precio
});

// forma de recorrer un array list con el metodo foreach
articulos.forEach(function(articulo){
    console.log(articulo.nombre)// retorna todos los nombres de los articulos que existen
});

// forma de recorrer un array list con el metodo some
// retorna un boleano que nos comprueba si existe o no
var aticulosBaratos = articulos.some(function(articulo){
    return articulo.costo <=1700;
})

Cabe destacar que el método find devuelve el primer objeto que coincida con la condición, no devuelve un array

Utilizar el método find(), en este caso aplicaría perfectamente a la búsqueda de objetos.

var articulos = [
{nombre:‘bici’,costo:300},
{nombre:‘bici’,costo:500},
{nombre:‘moto’,costo:600},
{nombre:‘carro’,costo:800},
{nombre:‘avion’,costo:5000}

]

function filtrando (value){
var filter = [];

articulos.find(( articulo )=>{
    
if(articulo.nombre === value){
    filter.push(articulo)    
}


})
if(filter){
    console.log(filter)
}else{
    console.log('bici')
}

}

filtrando(‘bici’)