Playground: retorna solo palabras de 4 letras o más

Estos desafíos prácticos son unas de las mejores actualizaciones que tiene Platzi sin dudas.
Sin embargo hay retos que te los marca como error solo porque los nombres de las variables no son las que eligió el equipo.
Quizás solo me paso a mí, pero me resulta raro porque lo he probando en mi VSC y los resultados siempre eran correctos y acá no.

Comparto mi solución al reto:

function solution(array) {
	return array.filter(word => word.length >= 4)
};

el mio le puedes enviar ademas la cantidad de letras que le puedes mandar

function solution (array, size){
  const  rta = array.filter(item =>{
        return item.length >= size;
    })
    return rta
}


console.table(solution(['amor', 'sol', 'piedra', 'día'], 4));

haria falta nada mas agregar un validacion que los datos no vayan vacios

Mi solucion

function solution(item) {
   return item.length >= 4;
} 

const words = ['amor', 'sol', 'piedra', 'día'].filter(solution);
console.log(words);

mi primer intento lo hice de la siguiente forma.

const solution = ['amor', 'sol', 'piedra', 'día'];
const resultado = [];

for (let i = 0; i<solution.length; i++) {
	const item = solution[i];
	if (item.length >= 4) {
		resultado.push(item);
	}
}
console.log(resultado);

Admitanlo, este estuvo easy:

return array.filter((word)=> word.length >= 4)

🥲 me encantan los playground

Fue sencillo y util 😃

export function filterByLength(array) {
  return array.filter(item => item.length >= 4)
}

reto solucionado

export function filterByLength(array) {
  // Tu código aquí 👈
  const words = array.filter((word) => {
    return word.length >= 4
  })

  return words
}

Solución

export function filterByLength(array) {
  return array.filter(text => text.length >= 4)
}

pero que demora para cargar

export function filterByLength(array) {
  return array.filter(item => item.length >= 4)
}

lel

return array.filter(item => item.length >= 4)

Mi solución

export function filterByLength(array) {
  return array.filter(item => item.length >= 4)
}

Mi solucion al reto:

export function filterByLength(array) {
  return array.filter(item => item.length >= 4);
}

Me gustan mucho los Playground

 return array.filter(item => item.length >= 4);

Esta es mi solución al reto, muy buena idea ir reforzando los conceptos aprendidos 💚

Aquí pueden probar el código:

export function filterByLength(array) {
  return array.filter(item => item.length >= 4)
}

Esta fue mi solucion:

export function filterByLength(array) {
return array.filter(element => element.length >= 4);
}

function filterByLength(array) {
const array2 = array.filter(word => word.length >= 4)
return array2;
}
console.log(filterByLength([‘amor’, ‘sol’, ‘piedra’, ‘día’]));

Que poderoso es filter

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(item => item.length >= 4)
}

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter((palabra)=>palabra.length>=4)
}

**AQUI UNA SOLUCION **

export function filterByLength(array) {
  // Tu código aquí 👈
  const solucion = array.filter(ele => ele.length >= 4)
  return solucion;
}

ES EL PRIMERO QUE ME SALE ALA PRIMERA EN LOS DEMAS SIMPRE FALLO POR ALGUNA COSA

export function filterByLength(array) {
  const newArray = array.filter(item => item.length>=4);
  return newArray;
}

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(item => item.length >= 4);
}

increíble como reduce la cantidad código

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(item=> item.length >=4)
}

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(item => item.length >= 4);
}
array = ['amor', 'sol', 'piedra', 'día'];

mi solucion

Este fue facil, en el primer intento 😅😅😅

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(item => item.length >= 4);
}

Una caricia al alma estas pruebas practicas :DD

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(rta => rta.length > 3)
}

export function filterByLength(array) {
  // Tu código aquí 👈

  return array.filter(item => item.length >= 4);
}

Holaaaa!
Esta es mi solución, espero les pueda ayudar

export function filterByLength(array) {
  return array.filter(item => item.length >= 4);
}

Código JavaScript

const ary1 = ['uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete']
const ary2 = ary1.filter(item => {
  return item.length >= 4;
})
console.log('ary1', ary1);
console.log('ary2', ary2);

Comparto mi solución 😄

export function filterByLength(array) {
  return array.filter((element) => element.length >= 4);
}

export function filterByLength(array) {
  return array.filter((element) => element.length >= 4);
}

este es mi aporte
.
.
.
.
.
.
.
.
.
.
.
export function filterByLength(array) {
const newArray = array.filter(item => item.length >= 4);
return newArray;
}

Solución

export function filterByLength(array) {
  // Tu código aquí 👈
  return array.filter(elem => elem.length >= 4);
}

Mi solución también valida si realmente se le ha pasado un array.

export function filterByLength(array) {
  // Valida si se le ha pasado un array
  if (!Array.isArray(array)) {
    return [];
  } else {
    return array.filter(palabra => palabra.length >= 4);
  }
}

Este es mi resultado:
.
.
.
.
.
.

export function filterByLength(array) {
  return array.filter(item => item.length >= 4)
}

const palabras = ['amor', 'sol', 'piedra', 'día']
filterByLength(palabras)

Aquí el código completo en una sola línea.

export const filterByLength = (array) => array.filter(el => el.length >= 4)

mi solucion creo que la de todos xd

export function filterByLength(array) {
  return array.filter((word) => word.length >=4 )
}

Mi solución:

export function filterByLength(array) {
  return array.filter(word => word.length >= 4);
}

ez el tutorial

export function filterByLength(array) {
  return array.filter(item => {
    return item.length >= 4
  })
}

export function filterByLength(array) {
  // Tu código aquí 👈

  return array.filter(word => {
    return word.length >= 4;
  });

}

export function filterByLength(array) {
const rta = array.filter(item => item.length >= 4)
return rta
}

solución con for()

export function filterByLength(array) {
  // Tu código aquí 👈
  let newArray = []
  
  for(let i = 0; i < array.length; i++) {
    if(array[i].length >= 4) {
      newArray.push(array[i])
    }
  }
  return newArray
}

export function filterByLength(array) {
  return array.filter(item=>item.length >=4)
}

Respuesta usando lo aprendido en la clase anterior:

export function filterByLength(array) {
  return array.filter(element => element.length >= 4);
}

La solución

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function filterByLength(array) {
  return array.filter(item => item.length >= 4);
}

function filterByLength(array) {
    return array.filter( element => element.length >= 4 )
}
filterByLength(['amor', 'sol', 'piedra', 'día'])

Aqui dejo mi solucion

function solution(array) {
	return array.filter(item => item.length >= 4)
}; ```

no habia entendido este tipo de retos!!! pero que espectacular!! ojala todos los cursos lo tuvieran!

Brindo mi solución…
Genial esta opción para prácticar…

Adjunto mi solución

Excelente desafío!
Dejo mi solución, espero les sirva😀

Comparto 2 soluciones que utilice para resolver el ejercicio

// Tienes un array con palabras, tu desafío es retornar un array solo con las que cumplan con la condición de tener 4 o más letras.
// La solución debería tener un input y output como los siguientes:

let arrayLetras = [‘amor’, ‘sol’, ‘piedra’, ‘día’];

const solution = arrayLetras.filter(palabras => palabras.length >= 4)
console.log(‘solution’, solution);

//---------------------------------------------------------------------

function solution(array) {
const solution = ([‘amor’, ‘sol’, ‘piedra’, ‘día’]);
return array.filter(word => word.length >= 4)
};console.log(‘solution’, solution)

solution = [‘amor’, ‘sol’, ‘piedra’, ‘día’]
const rta = solution.filter(word => word.length >= 4)
console.log(rta)

me encantan estos desafíos entre clases, hace que pongamos a nuestra mente mas activa y genera mayor pego de información recién aprendida :p

Comparto mi solución:

const palabras = ['amor', 'sol', 'piedra', 'día'];
const palabrotas = palabras.filter( palabra => palabra.length >= 4 );

console.log('De las palabras: ', palabras);
console.log('las que tienen 4 o más letras son: ', palabrotas);

Resultado:

Mi Solucion

function solution(array) {
    // Tu código aquí 👈 

    return array.filter(arr=> {
        return arr.length >= 4})

}; 

Aquí mi solución:

function solution(array) {
	return array.filter(item => item.length >= 4);
};

<const solution = ['amor', 'sol', 'piedra', 'día'];

const newSolution = solution.filter(item => item.length >= 4);

console.log(newSolution);> 

MI aporte:

const words2 = ['amor', 'sol', 'piedra', 'día'];
const wordLenght = words2.filter(item => item.length >= 4);
console.log('Words:', words2);
console.log('Words Lenght:', wordLenght);

Mi respuesta al desafio

function solution(array) {
 	// Tu código aquí 👈 
	return array.filter(array => array.length >= 4);
}; 

Me encantas los desafíos prácticos!! hacen la clase mucha más dinámica

const array = ['amor', 'sol', 'piedra', 'día'];

console.log( array.filter( item => item.length >= 4 ) );

Muy buenos!! asi lo hice yo

 const solution= (['amor', 'sol', 'piedra', 'día']);


const busqueda = solution.filter(item => item.length >= 4)
console.log(busqueda)

Aquí esta mi respuesta 😃 Estan muy buena esta dinamica para ir resolviendo ejercicios entre clases

function solution(array) {
	const newArray = array.filter(item => item.length >= 4);
	return newArray;
}; 

solution(['amor', 'sol', 'piedra', 'día']);

<script>
const solution = [‘amor’,‘sol’,‘piedra’,‘dia’];
const rta = solution.filter(solution => solution.length >= 4);
console.log(‘rta’, rta);
reto.innerHTML = <li>${solution} - ${rta}</li>
</script>

me encantan estos mini desafios deberian implementarlos en los demas cursos de platzi 😉

Reto 3 me regresa un error, en el navegador y en el editor si sale correcto.

function solution(array) {
	const solutions = array.map((item) => {
		item.taxes = (item.price / 100) * 19;
		return item
	})
	return solutions
};

Este es el output:

[
  { name: 'Product 1', price: 1000, stock: 10, taxes: 190 },
  { name: 'Product 2', price: 2000, stock: 20, taxes: 380 }
]

Excelente desafio, nunca me termino de cargar (Analisando…) pero compare mi codigo con el de los compañeros y el resultado es optimo.

function solution(array) {
 	let array = array.filter(a => a.length >= 4)
}; 

function solution(array) {
const response = array.filter(item => item.length > 3)
return console.log(response)👈
};

Necesita mejoras a veces marca errores de caracteres que no son

Reto: Retorna solo palabras de 4 letras o más, hecho.

const arcoiris = ["flor", "amor", "flores", "colores", "mio", "sol", "cariño" ];
const search3 = arcoiris.filter(item => item.length >= 4 );

function solution(array) {
// Tu código aquí 👈
let nuevo = [];
for (let i = 0; i < array.length; i++){
const elemento = array[i];
if (elemento.length >= 4) {
nuevo.push(elemento)
}
}return nuevo
};

//-- con filter –
let nuevo = array.filter( i => i.length >= 4 );
nuevo;

Reto

function solution(array) {
	return array.filter(item => item.length >= 4);
}; 

const solutionArray = solution(['amor', 'sol', 'piedra', 'día']);

console.log(solutionArray);

😀

function solution(array) {
	return (array.filter(item => item.length >=4))
}; 

Mi solución

function solution(array) {
	return array.filter(i => i.length >= 4)// Tu código aquí 👈 
}; 

Mi solución del reto

const arrayBonito = ['amor', 'sol', 'piedra', 'día'];
function solucion(array){
  const finalWords = array.filter(item => item.length >= 4); 
  return finalWords;
};
console.log(solucion(arrayBonito));

function solution(array) {
return array.filter(word => word.length >= 4);
};

solution([‘amor’, ‘sol’, ‘piedra’, ‘día’]);

function solution(array) {
	// Tu código aquí 👈 
	const filteredWords = array.filter(word => word.length >= 4);
	return filteredWords;
}; 

<function solution(array) {
	return array.filter(item => item.length >= 4);
}; >