Introducción

1

Manipulación de Arrays en JavaScript para Desarrollo Full Stack

Fundamentos del manejo de arrays

2

Recorrido de Arrays con Foreach en JavaScript

3

Mutabilidad vs Inmutabilidad en Programación JavaScript

4

Uso de Map para Transformaciones en JavaScript y Renderizado HTML

5

Playground: multiplica todos los elementos por dos

6

Transformaciones avanzadas con map en JavaScript

7

Playground: calcula y agrega nuevas propiedades a un array

8

Filtrado de Arrays en JavaScript con el Método Filter

9

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

10

Uso del método reduce en JavaScript para sumar elementos de un array

11

Contar elementos en un array con reduce y agrupar por rango

12

Playground: calcula la suma total de elementos en un array

Métodos en JavaScript

13

Uso de la función "sum" en JavaScript para evaluar condiciones

14

Playground: ¿al menos 1 de los números es par?

15

Uso del método `every` en JavaScript para validaciones de arrays

16

Playground: retorna un booleano si todos los elementos son pares

17

Uso de los métodos find y findIndex en JavaScript

18

Uso del método includes en JavaScript para arrays y strings

19

Playground: buscador de palabras con parámetros de búsqueda

20

Unificación y separación de arrays con join y split en JavaScript

21

Playground: construye URLs a partir de strings

22

Fusión de Arrays con Concat y Operador Spread en JavaScript

23

Aplanar Arrays en JavaScript con Flat y FlatMap

24

Uso de FlatMap para Extraer Fechas de Calendarios en JavaScript

25

Playground: calcula el total de palabras en un texto

26

Métodos Mutables e Inmutables en Arrays: Manipulación y Búsqueda

27

Ordenamiento de Arrays con el Método Sort en JavaScript

Despedida

28

Manipulación de Rides con JavaScript

No tienes acceso a esta clase

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

Playground: calcula el total de palabras en un texto

25/28

Aportes 130

Preguntas 0

Ordenar por:

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

Aquí mi humilde aporte

function solution(lines) {
	return lines.flatMap((item) => item.split(" ")).length;
}; 
function solution(lines) {
 	// Tu código aquí 👈 
	return lines.join(" ").split(" ").length
}; 
//20

si no existiera el metodo flatMap

function solution2 (array) {
return array.map(item  => item.split(' ')).flat().length

}

Mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function countWords(array) {
  return array.map(element => element.split(" ")).flat().length;
}

Aplico .map() al array para recorrerlo y que a cada elemento le aplique .split() con respecto a espacios, creando así un array con 4 arrays dentro, conformados estos por las palabras de cada Zen. Luego a ese resultado le aplico .flat() para crear un solo array que contenga todas las palabras que conformaban los 4 Zens. Finalmente aplico .length para saber la cantidad de elementos del array definitivo.

  function solution(lines) {
    const rta = lines.map(item => item.split(' ')).flat().length;
    return rta;
};

mi solución:

export function countWords(array) {
  return array.flatMap(item => item.split(' ')).length
}

esta es mi solución

function solution(lines) {
	return lines.join(" ").split(" ").length; 
}; 

Recuerden que siempre se puede llegar a la solución de diferentes formas.

 function solution(lines) {
	// Tu código aquí 👈 
	const rta = lines.map(item => item.split(' ')).flat().length

	return rta;

}; 

console.log(solution([
	"Beautiful is better than ugly",
	"Explicit is better than implicit",
	"Simple is better than complex",
	"Complex is better than complicated",
]))
```js export function countWords(array) { // Tu código aquí 👈 return array.flatMap(item => item.split(" ")).length } ```Para cada `item` (cada oración), `item.split(" ")` divide la oración en un array de palabras utilizando el espacio (" ") como delimitador. * Por ejemplo, `"Beautiful is better than ugly".split(" ")` se convierte en `["Beautiful", "is", "better", "than", "ugly"]`. Después de aplicar `split(" ")` a cada oración, `flatMap` aplana el array de arrays resultante en un solo array de palabras. `length` obtiene la longitud del array resultante, es decir, el número total de palabras en todas las oraciones combinadas.
Mi solución: 1\) Con el .map paso cada string a un array de palabra. 2\) Con el flat paso todo a un solo array, no necesito parametro en este caso 3\). Con el .length obtengo la cantidad de elementos. ```js export function countWords(array) { return array.map(item => item.split(' ')).flat().length } ```export function countWords(array) {  return array.map(item => item.split(' ')).flat().length}
```js // Mi solución: export function countWords(array) { return array.reduce((countWord, sentence) => countWord + sentence.split(' ').length, 0) } ```

aqui va mi respuesta

export function countWords(array) {
  if (array.length > 0) {
    return array.join(" ").split(" ").length
  } else {
    return 0
  }
}

Solución sin flatMap

function solution(lines) {
	let count = 0;
	lines.map(item => count += item.split(' ').filter(a => a !== '').length);
	return count;
}
Mi solución export function countWords(array) { // Tu código aquí 👈 return array.map(item => item.split(" ")).flat().reduce((sum) => sum +1, 0);} Ya luego leí otras respuestas y no me gustó tanto pero practiqué el resto de funciones.
mi aporteexport function countWords(array) {  // Tu código aquí 👈  return array.reduce((total, frase) => total + frase.split(' ').length, 0); } ```js export function countWords(array) { // Tu código aquí 👈 return array.reduce((total, frase) => total + frase.split(' ').length, 0); } ```
```js function countWords(array) { // Tu código aquí 👈 return array.reduce((acc, item) => { acc += item.split(" ").length; return acc; }, 0); } ```function countWords(array) { // Tu código aquí 👈 return array.reduce((acc, item) => { acc += item.split(" ").length; return acc; }, 0);}
export function countWords(array) {  // Tu código aquí 👈  const rta = array.flatMap(item => item.split(' ').length)  return rta.reduce((sum, item) => sum += item , 0)}
```js export function countWords(array) { // Tu código aquí 👈 return array.reduce((sum, phrase) => { let len = phrase.split(' ').length + sum; return len; }, 0); } ```
Dejo por aquí mi solución: ```js function countWords(array) { return array.reduce((acc, curr) => curr.split(' ').length + acc, 0) } ```
Esta fue la manera en la que logré eliminar los espacios que quedaban.const letters = \[  "Beautiful is better than ugly",  "Explicit is better than implicit",  "Simple is better than complex",  "Complex is better than complicated",] const rtaB = letters.flatMap  (    item => item.split(' ').join('')  ).join('').split(''); console.log(rtaB.length) ```js const rta = letters.flatMap ( item => item.split(' ').join('') ).join('').split(''); console.log(rta.length); ```
export function countWords(array) {  // Tu código aquí 👈  if (array.length === 0)    return 0;      return array.flat().join(" ").split(" ").length;}
Trato de correr el código pero se queda procesando infinitamente. ¿Qué estoy haciendo mal? Ya hice la prueba en la consola de y si funciona, el problema es en la pagina de platzi. Este es mi código: `export function countWords(array) {  return array.flatMap(s => s.split(" ")).length}` `countWords([  "Beautiful is better than ugly",  "Explicit is better than implicit",  "Simple is better than complex",  "Complex is better than complicated",])`
Tip: tengan en cuenta que llas cadenas de caracteres son arreglos en potencia usando el metodo split
Hola! Por que será que en el VS me dá correcto el código pero en el ejercicio no ?? Gracias![](https://static.platzi.com/media/user_upload/image-c6c935f7-df72-4db0-b265-68b01e5ed848.jpg)
Paso el mio, haciendo la validación para el array vacio. ```js function countWords(array) { // Tu código aquí 👈 let contador = 0; let newArray; if (array.length === 0) { return contador; } else { newArray = array.join(' ').split(' '); return newArray.length; } } console.log(countWords(array)); ```
  • Mi función debe devolver el resultado de aplicar reduce al array, ya que reduce retorna un solo valor iterando cada elemento y eso es lo que buscamos.

  • La sintaxis de reduce es array.reduce(function(accumulator, element, index, array), initialValue).

  • Solo voy a necesitar el accumulator, cada elemento y el valor inicial, que será cero.

  • Cada elemento del array es un string compuesto por palabras que se separan por espacios, así que, en cada iteración, aplicaré un split(’ ') que creará un nuevo array con cada palabra como su elemento, así, la longitud (length) de este array será el número de palabras.

  • Por último, sumaré al acumulador cada length de cada array.

export function countWords(array) {
  return array.reduce(
    (accumulator, element) => 
      element.split(' ').length += accumulator,
    0 
  )
}
![](https://static.platzi.com/media/user_upload/image-3c01f84c-27e7-4437-968c-c16e22b45b93.jpg)
Tenemos un array de strings, la alternativa más óptima es extraer cada string del array, luego separar cada string por palabra, y al final con la propiedad length ver cuantos elementos tiene el array y así podemos saber cuantas palabras son. Solución: Con flatMap transformamos el array para extraer cada string del array, pero ya que flatMap aplana en un solo array, a cada array transformado le aplicamos split con el separador de espacio que se da en cada palabra, y así tenemos todas las palabras en un array uniforme y con .length podemos saber la longitud de ese array. ```js function countWords(array) { return array.flatMap(item => item.split(" ")).length; } ```function countWords(*array*) {    return *array*.flatMap(*item* => *item*.split(" ")).length;}
Tenemos un array de strings, la alternativa más óptima es extraer cada string del array, luego separar cada string por palabra, y al final con la propiedad length ver cuantos elementos tiene el array y así podemos saber cuantas palabras son. Solución: Con flatMap transformamos el array para extraer cada string del array, pero ya que flatMap aplana en un solo array, a cada array transformado le aplicamos split con el separador de espacio que se da en cada palabra, y así tenemos todas las palabras en un array uniforme y con .length podemos saber la longitud de ese array. ```js function countWords(array) { return array.flatMap(item => item.split(" ")).length; } ```function countWords(array) {  return array.flatMap(item => item.split(" ")).length;}
```js export function countWords(array) { return array.flatMap(string => string.split(" ")).length } ```
Solucion: // Contador de palabras ```js // Contador de palabras function countWords(array) { return array.flatMap(item => item.split(' ').join('').length).reduce((sum, item) => sum + item, 0) } console.log("Palabras: ", countWords(palabras)); ```
2 solutions: `export function countWords(array) { ` `// first solution` `// return array.flatMap((item) => item.split(" ").length).reduce((a, b) => a + b, 0)` `// second solution` ` return array.length > 0 ? array.join(' ').split(' ').length : 0;}`
![](https://static.platzi.com/media/user_upload/image-1fc628c8-8503-4132-b57f-0be0ab3d0753.jpg)
Spoiler . . . . . . . . . . . . ```js export function countWords(array) { return array.length === 0 ? 0 : array.join(' ').split(' ').length } export function countWords(array) { return array.flatMap((element) => element.split(' ')).length } ```
Mi humilde solución, estos retos me gustan y mas ver todas las posibles soluciones que tienen todos :) ```js export function countWords(array) { // Tu código aquí 👈 return array.flatMap(item => item.split(' ')).reduce((count, item) => count += 1, 0); } ```

Mi solución:

function solution(lines) {
	return lines.flatMap(item => item.split(' ')).reduce((sum, _) => sum + 1, 0);	
}; 
```js export function countWords(array) { // Tu código aquí 👈 return array.reduce((sum, item) => sum + item.split(' ').length, 0); } ```export function countWords(array) {  // Tu código aquí 👈  return array.reduce((sum, item) => sum + item.split(' ').length, 0);}

reto realizado

export function countWords(array) {
  // Tu código aquí 👈
  let numerodePalabras = 0
  if (array.length === 0) {
    numerodePalabras
  } else {
    let number = array.join(' ').split(' ').length
    numerodePalabras = number
  }

  return numerodePalabras
}

Mi solución:

export function countWords(array) {
  return array.reduce((acc, string) => {
    const result = string.split(" ").length;
    return acc + result;
  }, 0)
}
Mi solucion: ```js function countWords(array) { const arrayDividido = array.map(elemento => elemento.split(" ")) const flat = arrayDividido.flat() return flat.length } ```
```js function countWords(array) { return array.reduce((sum, item) => item.split(' ').length + sum,0) } ``` function countWords(array) {  return array.reduce((sum, item) => item.split(' ').length + sum,0)} function countWords(array) {  return array.reduce((sum, item) => item.split(' ').length + sum,0)} ```js ```
export function countWords(array) {
  return array.join(" ").split(" ").length
}

Ok, lo hice con ayuda, me perdí xd

array.flatMap(item => item.split(" ").length).reduce((sum, act) => sum + act, 0)```

Aquí va mi solución:

export function countWords(array) {
  const separate = array.map(item => item.split(" "))
  const total = separate.flatMap(obj => obj)
  return total.length
}
Mi solución para que pase todas las pruebas `export function countWords(array) {  return array.length > 0 ? array.join(" ").split(" ").length : 0;}`
<code> 
export function countWords(array) {
  // Tu código aquí 👈
  return array.join(' ').split(' ').reduce((acu, item) => {
    acu = !item.length == 0 ? acu + 1 : acu
    return acu
  }, 0)
}

Aún seguimos aprendiendo con este increíble curso, en mi caso mi solución al reto fue de la siguiente manera:

function countWords(array) {
  if (array.join(' ').length === 0) {
    return 0;
  }

  return array.join(' ').split(' ').length;
}

Solución:

function countWords(array) {
  return array.length ? array.join(" ").split(" ").length : 0
}

"Si el array que se recibe si tiene elementos (o sea array.length es true), entonces ejecuta join() luego slipt() y devuelve cuánto es su length. Si el array no tiene ningún elemento (o sea array.length es false), se retorna 0, porque no tiene nada .

export function countWords(array) {
if (array.length === 0) {
return 0
} else {
let arr = array.join(’ ‘);
arr = arr.split(’ ');
return arr.length
}
}

otra forma de resolver el desafio es este

let totalWords = 0;
  for (let i = 0; i < array.length; i++) {
    let words = array[i].split(' ');
    totalWords += words.length;
  }
  return totalWords;

Esta es mi solución usando el método ‘flatMap()’ y 'splt()'


Acá pueden probar el código:

export function countWords(array) {
  return array.flatMap(sentence => sentence.split(' ')).length
}

lo pensé de esta manera

export function countWords(array) {
  // Tu código aquí 👈
  return array.length !=0 ? array.join(' ').split(' ').length : 0;
}

mi solucion

export function countWords(array) {
  if (array.length === 0) {
    return 0
  } else {
    return array.join(' ').split(' ').length
  }
}

otro tipo de solución sin usar flatMap:
export function countWords(array) {
if (array.length === 0) {
return 0
} else {
let newArray = []
newArray = array.join(’ ‘).split(’ ')
return newArray.length
}
}

export function countWords(array) {
  // Tu código aquí 👈
  const words = array.length === 0 ? 0: array.join(' ').split(' ').length

  return words;

}

return array
    .map(phrase => phrase.split(' '))
    .flat()
    .length
export function countWords(array) {
  // Tu código aquí 👈
  let total = 0;
  for (let index = 0; index < array.length; index++) {
    const element = array[index].split(" ")
    total += element.length

  }
  return total
}

Lo primero que se me pasó por la cabeza no incluia flatMap 😐

export function countWords(array) {
  return array.reduce((acc, item) => acc + item.split(' ').length, 0)
}

Aquí mis soluciones
Con reduce:

function countWords(phrasesList) {
  return phrasesList.reduce((accumulator, phrase) => {
    accumulator += phrase.trim().split(" ").length;
    return accumulator;
  }, 0);
}

Con flatMap:

function countWordFlatMap(phrasesList) {
  return phrasesList.flatMap((phrase) => phrase.trim().split(" ")).length;
}

Solucionogra

function count_words(array) {
    return array.join(' ').split(' ').length; //20
}

count_words([
    "Beautiful is better than ugly",
    "Explicit is better than implicit",
    "Simple is better than complex",
    "Complex is better than complicated"
]);

Aqui mi solución:

function countWords(array) {
   return array.length === 0 ? 0 : array.join(" ").split(" ").length
}

Así lo hice:

if (array.length === 0) return 0;
return array.join(" ").split(" ").length;
export function countWords(array) {
  return array.reduce((total, sentence) => {
    total += sentence.split(" ").length;
    return total;
  }, 0);
}

Mi solución:
👇
👇
👇
👇
👇
👇
👇
👇

export function countWords(array) {
  return array.flatMap(string => string.split(" ")).reduce((e, i) => e + 1, 0)
}

Mi solucion considerando que puedo tener varios elementos vacios " " , lo cual no implica tener una palabra y fallaria el _.length _

function countWords(array) {
  if (array.join(' ').split(' ').includes('')) {
    return 0
  } else {
    return array.join(' ').split(' ').length
  }
}

export function countWords(array) {
var res = 0;
array.map(element => res = res + element.split(’ ').length)
return res
}

Código JavaScript:


const ary1 = ["Beautiful is better than ugly","Explicit is better than implicit","Simple is better than complex","Complex is better than complicated",];
console.log(' ary1', ary1);
console.log('rslt1', ary1.join(' ').split(' ').length);
console.log('rslt2', ary1.map(item => item.split(' ')).flat().length);

Les dejo mi solución 😄

export function countWords(array) {
  return array.length === 0 ? 0 : array.join(' ').split(' ').length
}

Mi solución:
||
||
||
||
||
||
||
||
||
||
v

export function countWords(array) {
  return array.reduce((totalWords, item) => totalWords + item.split(" ").length, 0)
}

Esta solución contempla casos extremos, en donde pueden haber strings con espacios al inicio y al final, dobles espacios o incluso strings con solamente espacios:

function countWords(array) {
    return array.flatMap(line =>
      line.trim().match(/\b\w+\b/g) ?? []
    ).length;
}  

Comparto mi solución, no se me ocurrió utilizar 😔.

export function countWords(array) {
  return (array.length != 0) ? (array.join(" ").split(" ")).length: 0;
}

Mi solucion:

export function countWords(array) {
  let suma = 0
  array.flatMap(element => suma += element.split(" ").length)
  return suma
}

export function countWords(array) {
return array.flatMap(item => {
return item.toString().split(’ ')
}).length
}

Este es mi aporte, tambien lo hice con reduce porque creo que es mas facil de entender el codigo

const conutWordOneLine = (array) => array.reduce((num, phrase)=> num += phrase.split(' ').length, 0);

const conutWorsFM = (array) => array.flatMap(element => element.split(' ')).length;


export function countWords(array) {
  return array.flatMap((element) => element.split(' ')).length;
}

Lo hice sin usar map o flatMap y pasa todos los test,

export function countWords(array) {
  // Tu código aquí 👈
  return array.length > 0 ? array.join(' ').split(' ').length : 0;
}

Solución

export function countWords(array) {
  // Tu código aquí 👈
  return array.flatMap(elem => elem.split(" ")).length;
}
function countWords(array) {
  return array.reduce((acc,item) => item.split(' ').length + acc, 0)
}

Mi solución

export function countWords(array) {
  return array.length === 0 ? 0 : array.join(' ').split(' ').length;
}

This is my solution for the challenge. Hope you like it1

function countWords(array) {
  // Tu código aquí 👈
  if (array.length != 0) {
    return array.join(" ").split(" ").length
  } else {
    return array.length
  }
  
}

Mi aporte, pero recuerden que deben intentarlo.

const strings = [
  "Beautiful is better than ugly",
  "Explicit is better than implicit",
  "Simple is better than complex",
  "Complex is better than complicated",
]

export function countWords(array) {
  // Tu código aquí 👈
  const rta = array.flatMap(item => {
    const strSplit=  item.split(' ')
    console.log(strSplit);
    return strSplit.length
  })
  console.log(rta)
  const rta2 = rta.reduce((count, item) =>{
    return count +=item
  }, 0)
  console.log(rta2)
  return rta2
}

countWords(strings);
export function countWords(array) {
  // Tu código aquí 👈

  const result = array.reduce((newArr, item) => {
    return newArr.concat(item.split(" "))
  }, [])

  return result.length;
}

Mi solución:

export function countWords(array) {
  return array.flatMap(item => item.split(' ')).length; 
}

No sólo se puede lograr con flatMap:

export function countWords(array) {
  return (array.length > 0) ? array.join(' ').split(' ').length : 0;
}

aqui mi colucion, primero paso un map que convierte cada item en un nuevo array, en donde cada elemento depende de los espacion, para eso uso el split, y luego simplemente aplano ese array nuevo, y retorno su longitud con length

export function countWords(array) {
  const array2 = array.map(item => item.split(' '))
  return array2.flat().length
}
const conteo = (array) => {
    if(array.length > 0){
        return array.join(' ').split(' ').length;
    }
    else{
        return 0;
    }
};

export function countWords(array) {
   return array != 0 ? array.join(' ').split(' ').length : 0
}
export function countWords(array) {
  // Tu código aquí 👈
  const resp = array.map(string => string.split(" ")).flat(Infinity).length;
  console.log(resp)
  return resp
}

Aquí mi código.

Estuve tentado hacer el reduce ya en otra arrayFunctión para ser más sencillo de leer pero por ahora lo deje así.

export function countWords(array) {
  return array.map( words => words.split(' ').length)
    .reduce((acumulador, item) => acumulador + item, 0);  
}

Mi solucion:

export function countWords(array) {
  return array.reduce((sum, num) => sum + num.split(' ').length, 0)
}
 
//Mi solución! 

export function countWords(array) {
  let sumar = array.flatMap(line => {
    return line.split(" ");
  });
  return sumar.length;
}

export function countWords(array) {
return array.flatMap((item) => item.split(" ")).length;
}

Input.join(' ').split(' ').length

Es raro la solucion del ejecicio solo suma una sola palabra, Esta es mi solución y sumo todas las palabras de mi array.

function countWord(array){
    const newArray = array.flatMap(item => item.length)
    return newArray.reduce((obj,suma) => obj + suma, 0)
}

eeeezzzz

export function countWords(array) {
  return array.reduce((total, element) => total + element.split(' ').length, 0)
}

a que se refieren este ejercicio con el Zen de Python? y con cada línea? se refiere a cada índice dentro del array? es algo confusa la instrucción.

Solucion

export function countWords(array) {
  // Tu código aquí 👈
  let words = 0
  array.forEach(astr => {
    let newArr = astr.split(' ')
    words += newArr.length
  })
  return words
}

Utilizando reduce() y split()

function countWords(array) {
  return array.reduce((acum, el) => acum + el.split(' ').length, 0)
}
undefined