Introducción a JavaScript

1

Fundamentos de JavaScript para Principiantes

2

Instalación y Configuración de JavaScript en Visual Studio Code

3

Instalación y configuración de Visual Studio Code y Node.js en Windows

4

Variables y Buenas Prácticas en JavaScript

5

Tipos de Datos en JavaScript: Primitivos y Complejos

6

Manipulación de Strings en JavaScript: Escritura, Concatenación y Substrings

7

Números y Operaciones Matemáticas en JavaScript

8

Conversión de Tipos en JavaScript: Implícita y Explícita

9

Conversión de Tipos en JavaScript: Explícita e Implícita

Estructuras de Control y Lógica

10

Operadores de Comparación en JavaScript: Igualdad y Desigualdad

11

Operadores Lógicos en Programación: AND, OR y NOT

12

Estructuras Condicionales: Uso de IF, ELSE y ELSE IF en JavaScript

13

Juego de Adivinanza: Programación con Estructuras Condicionales

14

Estructura y uso del condicional Switch en programación

15

Ciclo For: Iteración de Listas y Uso de Console.log en JavaScript

16

Iteración con for-of en JavaScript para arrays y strings

17

Iteración sobre Objetos con forIn en JavaScript

18

Uso del ciclo while para iteración en programación

19

Ciclos doWhile: Estructura y Diferencias con While

Funciones y This

20

Funciones en JavaScript: Cómo Calcular Precios con Descuentos

21

Diferencias entre Funciones y Métodos en JavaScript

22

Funciones Puras e Impuras en Programación: Conceptos y Ejemplos

23

Arrow Functions y Enlace Léxico en JavaScript

24

Scope y Contextos de Ejecución en JavaScript

25

Closures y Ámbito Léxico en JavaScript

26

Fundamentos del Desarrollo Web: Frontend y Backend

Manipulación de Arrays

27

Arrays: Propiedades, Acceso y Creación en Programación

28

Mutabilidad e inmutabilidad en arrays: conceptos y ejemplos prácticos

29

Métodos push y pop para modificar arrays en JavaScript

30

Métodos map y forEach en JavaScript: Uso y Ejemplos Prácticos

31

Métodos Filter y Reduce en JavaScript: Uso y Ejemplos Prácticos

32

Métodos find y findIndex en JavaScript: Uso y ejemplos prácticos

33

Uso del método slice para extraer porciones de un array en JavaScript

34

Uso del Spread Operator en JavaScript: Copia, Combinación y Más

Programación Orientada a Objetos

35

Programación Orientada a Objetos en JavaScript: Conceptos y Práctica

36

Creación y Manipulación de Objetos en JavaScript

37

Función constructora y gestión de instancias en JavaScript

38

Clases en JavaScript: Creación y Uso de Objetos con Sintaxis Moderna

39

Programación Orientada a Objetos en JavaScript: Clases y Prototipos

40

Prototipos y Herencia en JavaScript: Construcción y Uso Práctico

41

Métodos y herencia prototípica en JavaScript

42

Uso de "this" en Clases y Funciones Constructoras

43

Validación de Usuarios en una Red Social: Algoritmo Básico

44

Implementación de la Función Sign-In y Validación de Usuario

Asincronía en JavaScript

45

Programación Síncrona y Asíncrona en JavaScript

46

Promesas en JavaScript: Asincronía y Manejo de Estados

47

Uso de Async/Await para Promesas Asíncronas en JavaScript

48

Peticiones asíncronas con for await en JavaScript

49

Fundamentos de HTTP: Cliente-Servidor y Métodos de Petición

50

Peticiones HTTP en Frontend: Uso de Fetch y Análisis en Network

51

Peticiones HTTP en JavaScript: Fetch, GET, POST y DELETE

52

Envío de Datos al Servidor con JavaScript y Fetch API

53

Eliminar Posts con JavaScript y Delegación de Eventos

54

Manejo de IDs en JavaScript para eliminar artículos del DOM

55

Actualizaciones y Nuevas Funciones en JavaScript

No tienes acceso a esta clase

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

Métodos map y forEach en JavaScript: Uso y Ejemplos Prácticos

30/55
Recursos

¿Qué son los métodos map y forEach en JavaScript?

En el mundo de la programación con JavaScript, los métodos map y forEach son esenciales para cualquier desarrollador que trabaje con arrays. Ambos métodos permiten iterar sobre arrays, pero cada uno tiene características y propósitos distintos. Ambos son fundamentales para manipular datos de manera efectiva y eficiente en tus aplicaciones.

¿Cómo funciona el método map?

El método map es uno de los métodos de arrays más poderosos y versátiles en JavaScript. Este método crea un nuevo array al aplicar una función proporcionada a cada elemento del array original. Lo más relevante de map es que no modifica el array original, sino que devuelve un nuevo array con los resultados de la función aplicada.

Ejemplo de uso de map

Supongamos que tenemos un array de números. Queremos elevar al cuadrado cada número en el array. Usando map, esto se vería de la siguiente manera:

const numbers = [1, 2, 3, 4, 5];
const squaredNumbers = numbers.map(num => num * num);
console.log(numbers); // [1, 2, 3, 4, 5]
console.log(squaredNumbers); // [1, 4, 9, 16, 25]

En este ejemplo, numbers es el array original que permanece inalterado, mientras que squaredNumbers es el nuevo array con cada elemento elevado al cuadrado.

¿Cómo funciona el método forEach?

El método forEach también itera sobre cada elemento de un array y ejecuta una función para cada uno de ellos. Sin embargo, a diferencia de map, forEach no crea un nuevo array ni devuelve ningún resultado. Simplemente ejecuta una función proporcionada para cada elemento.

Ejemplo de uso de forEach

Veamos cómo iterar sobre un array de colores e imprimir cada color en la consola:

const colors = ['red', 'pink', 'blue'];
colors.forEach(color => console.log(color));

Aquí, forEach imprime cada color en la consola, pero no devuelve un nuevo array.

Comparación práctica de map y forEach

Cuando decides utilizar uno de estos métodos, la elección depende de lo que necesitas hacer con el resultado:

  • Usa map cuando quieras transformar cada elemento de un array en algo nuevo y obtener un nuevo array como resultado.
  • Usa forEach cuando necesites ejecutar una acción para cada elemento sin preocuparte por crear o devolver un nuevo array.

Ejemplo práctico: Conversión de temperaturas

Imagine que tiene temperaturas en Fahrenheit y necesita convertirlas a Celsius. Este es un ejemplo clásico donde map sería ideal porque queremos transformar y obtener un nuevo array con los valores convertidos.

const tempsInFahrenheit = [32, 68, 95, 212];
const tempsInCelsius = tempsInFahrenheit.map(fahrenheit => (5/9) * (fahrenheit - 32));
console.log(tempsInFahrenheit); // [32, 68, 95, 212]
console.log(tempsInCelsius); // [0, 20, 35, 100]

Ejemplo práctico: Suma de elementos de un array

En este caso, queremos sumar todos los elementos de un array. Un enfoque típico sería usar forEach, ya que estamos realizando una operación acumulativa y no necesitamos un nuevo array.

const numbers = [1, 2, 3, 4, 5];
let suma = 0;
numbers.forEach(number => suma += number);
console.log(suma); // 15

En este caso, forEach recorre el array y suma cada elemento a una variable acumuladora suma.

Conclusión

Conocer las diferencias entre map y forEach y saber cuándo utilizar cada uno es fundamental para escribir código JavaScript eficiente y limpio. Recuerda que map es ideal para transformar y obtener nuevos arrays, mientras que forEach es excelente para operaciones que no necesitan devolver un nuevo array. Con práctica y conocimientos sólidos, podrás manejar los arrays en JavaScript con seguridad y eficiencia. ¡Sigue explorando y experimentando para mejorar tus habilidades de programación!

Aportes 36

Preguntas 2

Ordenar por:

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

## Resumen de la clase Aquí te dejo mi resumen sobre esta clase! Si quieres ir un paso más adelante, sigue leyendo! ![](https://i.imgur.com/biK1bPo.png) Una habilidad fundamental que debemos trabajar como desarrolladores es la capacidad de leer documentación (y si, en inglés también) te animo a que te adentres en la documentación de estos 2 métodos, intenta leerla en inglés, y si sientes que no logras entenderlo del todo, visita la escuela de inglés de Platzi! ## 📃 Documentación * [.map()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) * [.forEach()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) Ánimo, y nunca pares de aprender!
me equivoque 20 veces, pero descubri 20 formas de como no hacerlo :B
Para los que han preguntado por el anterior curso, si guardaron un acceso en favoritos o algo asi, pueden segui accediendo a el. Solo usen el boton de ver clases para que vean las clases del curso pasado. Les dejo este link a una clase del otro curso. <https://platzi.com/home/clases/8617-javascript-fundamentos/66453-funciones-puras-e-impuras/>
Tanto `map()` como `forEach()` son métodos que permiten iterar sobre los elementos de un array en JavaScript, pero tienen diferencias importantes en su funcionalidad y propósito. Aquí te explico cada uno y sus diferencias. ### **1.** `forEach()` El método `forEach()` recorre cada elemento de un array y ejecuta una función proporcionada para cada uno de ellos. **No devuelve nada** y solo sirve para realizar una acción sobre cada elemento (por ejemplo, imprimir, actualizar, etc.). **Ejemplo:** \[javascriptCopiar código`let numbers = [1, 2, 3, 4`]; `numbers.forEach(function(number`) { ` console.log(number * 2`); }); **Salida:** Copiar código2 4 6 8 **Características de** `forEach()`: * No devuelve un nuevo array. * Modifica el array si es necesario o realiza alguna operación en cada elemento, pero no genera un valor de retorno. * No se puede encadenar con otros métodos, ya que no devuelve ningún valor. ### **2.** `map()` El método `map()` también recorre cada elemento del array, pero **devuelve un nuevo array** con los resultados de aplicar una función a cada uno de sus elementos. Es útil cuando quieres transformar cada elemento en algo nuevo. **Ejemplo:** javascriptCopiar código`let numbers = [1, 2, 3, 4`]; `let doubledNumbers = numbers.map(function(number`) { ` return number * 2`; }); `console.log`(doubledNumbers); **Salida:** csharpCopiar código`[2, 4, 6, 8`] **Características de** `map()`: * **Devuelve un nuevo array** con los resultados de la función aplicada a cada elemento. * No modifica el array original. * Se puede **encadenar** con otros métodos porque devuelve un array. ### **Diferencias clave entre** `map()` **y** `forEach()`: * **Retorno**: `map()` devuelve un nuevo array, mientras que `forEach()` no devuelve nada. * **Uso**: Usa `forEach()` cuando solo necesitas ejecutar un bloque de código para cada elemento, pero si necesitas transformar los elementos de un array y devolver un nuevo array, debes usar `map()`. * **Encadenamiento**: `map()` se puede encadenar con otros métodos de arrays, pero `forEach()` no, ya que no devuelve ningún valor. ### Ejemplo de comparación: javascriptCopiar código`let numbers = [1, 2, 3, 4`]; `// Con forEach` `numbers.forEach(function(number`) { ` console.log(number * 2); // Solo imprime los valores multiplicados` }); `// Con map` `let doubledNumbers = numbers.map(function(number`) { ` return number * 2`; }); `console.log(doubledNumbers); // Devuelve un nuevo array con los valores multiplicados`
Como van a eliminar el curso anterior, si actualizan den acceso al curso anterior o dejen ver hasta donde uno llego para que pueda seguir con el nuevo y no fumarse todo desde el principio.
Realice otros ejercicios, la cual recorre el Array para convertir en mayúsculas el contenido del Array. ![](https://static.platzi.com/media/user_upload/image-61fcc129-a80f-412c-b42f-17d96a3a0687.jpg)
usaria en la ultima actividad reduce ```js let far = [32,68,95]; const res = far.reduce((acc, num) => acc + num); console.log(res); ```let far = \[32,68,95];
Para devolver la temperatura con menos números decimales modifiqué esa línea de código de la siguiente manera: `const temperaturesInCelsius = temperaturesInFahrenheit.map((temp) =>  parseFloat(((5 / 9) * temp - 32).toFixed(1)));` Para mejorar la legibilidad se podría extraer a una función.
En JavaScript, `forEach` y `map` son dos métodos muy útiles para trabajar con arrays. Aunque pueden parecer similares a primera vista, tienen propósitos y comportamientos diferentes. Veamos cómo funciona cada uno: ## **forEach** El método `forEach` se utiliza para ejecutar una función en cada elemento de un array, pero no devuelve nada. Es útil cuando quieres realizar una acción para cada elemento sin modificar el array original. Ejemplo: ```js const frutas = ['manzana', 'banana', 'naranja']; frutas.forEach((fruta, index) => { console.log(`Fruta ${index + 1}: ${fruta}`); }); // Salida: // Fruta 1: manzana // Fruta 2: banana // Fruta 3: naranja ``` ## **map** Por otro lado, `map` crea un nuevo array con los resultados de llamar a una función para cada elemento del array original. Es ideal cuando quieres transformar cada elemento de un array. Ejemplo: ```js const numeros = [1, 2, 3, 4, 5]; const cuadrados = numeros.map(numero => numero * numero); console.log(cuadrados); // [1, 4, 9, 16, 25] ``` ## **Diferencias clave** 1. **Valor de retorno**: `forEach` no devuelve nada (undefined), mientras que `map` devuelve un nuevo array. 2. **Modificación**: `forEach` no modifica el array original, `map` crea un nuevo array sin modificar el original. 3. **Uso**: Usa `forEach` para efectos secundarios (como logging), y `map` para transformar datos.
![](https://static.platzi.com/media/user_upload/image-f5a03aee-c1ac-4ed1-837d-2029b1d7b648.jpg) con la estructura de la clase, logre organizar una idea para una funcion que me ayude a convertir la temperatura de Fahrenheit a Celcius
Ya vieron que les marca error cuando declaran como const a la variable sum. Esto se debe a que el valor de esa variable no debe cambiar una vez que ha sido asignado.
Estoy un poco perdido. Al hacer numbers.map(num), javascript entiende automáticamente que num es cada uno de los elementos del array numbres?
**¿Qué es** `map()`**?** `map()` es un método que se utiliza con arreglos. Su trabajo es recorrer cada elemento de un arreglo, aplicar una función a ese elemento y luego devolver un **nuevo arreglo** con los resultados. **¿Cómo funciona?** 1. Tienes un arreglo. 2. `map()` aplica una función a **cada elemento** del arreglo. 3. Devuelve un **nuevo arreglo** con los resultados de esa función. Lo importante es que `map()` **no modifica el arreglo original**. **Ejemplo sencillo con un arreglo de números** Imagina que tienes un arreglo de números y quieres multiplicar cada número por 3. Con `map()`, esto se hace de manera súper sencilla. ```js // Uso de map let numeros = [1,2,3,4,5]; // Modificar el arreglo con map let modificador = numeros.map (element=>{ return element*3; }); console.log(modificador); ``` ![](https://static.platzi.com/media/user_upload/Map-method-in-JS-4867f2f3-9de5-4071-8f06-1b8a6098ab3f.jpg)
Dos ejemplos sobre como hacer el ejercicio mencionado en la clase: ```js // Forma 1 function convert(temperature) { const res = 5 / 9 * (temperature - 32) return res } const temp = [93.2, 98.6, 140] const convert_to_celsius = temp.map(temp => convert(temp)) console.log(convert_to_celsius) // Forma 2 const celsius_00 = temp.map(temp => 5 / 9 * (temp - 32)) console.log(celsius_00) ```
Hola a todos, la forma en que solucioné el ejercicio fue esta const temperature = [12, 16, 2, 18, 190]; const convertToCelcius = temperature.map(temp => (5/9) * (temp-32)) console.log(convertToCelcius);
![](https://static.platzi.com/media/user_upload/image-af1d9fe4-8a8c-453e-9e21-8263b4354b7f.jpg) ![](https://static.platzi.com/media/user_upload/image-fa6d14aa-9987-42fd-ae73-799b070b28ee.jpg) ![](https://static.platzi.com/media/user_upload/image-c4602546-8202-4dd4-808e-457754986cf5.jpg)
En el método `forEach`, el valor de retorno es `undefined` porque su propósito es simplemente ejecutar una función para cada elemento del array sin generar un nuevo array. A diferencia de `map`, que crea y devuelve un nuevo array basado en los resultados de la función aplicada a cada elemento, `forEach` solo realiza la operación sin alterar el array original ni producir un retorno útil. Por eso, puedes observar que al usar `forEach`, la variable que almacena el resultado se queda indefinida.
No entendí porque salio indefinido en forEach
Me paso que em equivoque en la formula, me marca un error de typeError que no reconocia el 9, peor era porque me faltaba colcoar entre () el 5/9
The `forEach` method is convenient for iterating over arrays when you want to perform operations on each item without needing to return a new array. It's especially useful for side effects, such as logging or updating other variables. If you have any specific scenarios in mind or further questions, feel free to ask!
![](https://static.platzi.com/media/user_upload/image-a7fbd33c-6d1b-435e-88b5-4b598370b832.jpg)
Yo usé .map()const farenheitTemperatures = \[70, 78, 67, 95, 110]const celsiusTemperatures = farenheitTemperatures.map(temperature => `${Math.floor((5 / 9) \* (temperature - 32))}°C`)console.log('Temperaturas en fareheit: ' + farenheitTemperatures, 'Temperaturas en celsius: ' + celsiusTemperatures)```js const farenheitTemperatures = [70, 78, 67, 95, 110] const celsiusTemperatures = farenheitTemperatures.map(temperature => `${Math.floor((5 / 9) * (temperature - 32))}°C`) console.log('Temperaturas en fareheit: ' + farenheitTemperatures, 'Temperaturas en celsius: ' + celsiusTemperatures) ```
En JavaScript, al usar el método `map()`, se pasa una función que se ejecuta para cada elemento del array. Esta función toma un argumento, que en este caso es `num`. El método `map()` automáticamente itera sobre cada elemento del array `numbers`, y `num` representa el elemento actual en cada iteración. Así, la función sabe a qué elemento se refiere porque `map()` lo proporciona como argumento. Es un mecanismo integral del funcionamiento de las funciones de callback en JavaScript.
```js Usaria map de la siguiente forma: ``` ````js const tempF = [92, 103, 87, 45, -3] const tempC = tempF.map(t => 5/9 * (t-32)) console.log(tempF) console.log(tempC) ```const tempF = \[92, 103, 87, 45, -3]const tempC = tempF.map(t => 5/9 \* (t-32)) console.log(tempF)console.log(tempC) ````
```js const temperaturaCelsius = [10, 16, 20, 24, 32]; const temperaturaFarenheit = temperaturaCelsius.map(celsius_a_farenheit); function celsius_a_farenheit(temperatura) { return (temperatura * 1.8) + 32; } console.table([temperaturaCelsius, temperaturaFarenheit]); //celsius: [10, 16, 20, 24, 32]; //fahrenheit: [50, 60.8, 68, 75.2, 89.6]; ```
const colores = \["red", "green", "ble", "yellow"];const interatuaColores = colores.forEach(colores => console.log(colores)); const interColor = colores.push("blanco", "rojo intenso");console.log(interColor); console.log(interatuaColores);console.log(colores);     // pasar de fahrenheit a  celsius const temperaturafahrenheit = \[32,68,95,104,212];const temperaturecelsius = temperaturafahrenheit.map(fahrenheit=> (5/9)  \* (fahrenheit  - 32) ) ; console.log("la temperatura en fahrenheit es  " + temperaturafahrenheit);console.log("la temperatura  en celsius es " + temperaturecelsius);
La diferencia principal entre `map` y `forEach` en JavaScript radica en su propósito y retorno. - `map`: Crea un nuevo array con los resultados de aplicar una función a cada elemento del array original. No modifica el array original. Por ejemplo, si tienes un array de números y quieres obtener sus cuadrados, usarías `map`. - `forEach`: Ejecuta una función en cada elemento del array sin crear un nuevo array. Su propósito es realizar acciones en cada elemento, como imprimirlos en consola o modificar variables externas. No devuelve ningún valor y, por lo tanto, devuelve `undefined`. Ambos son métodos útiles, pero se utilizan en contextos diferentes según lo que necesites lograr.
## Métodos de Arrays en JavaScript * Los métodos de arrays en JavaScript son herramientas poderosas que permiten manipular y transformar datos de manera eficiente. * Algunos de estos métodos, como `map` y `forEach`, iteran sobre los elementos del array sin modificar el array original. ## Método `map` * `map` es uno de los métodos más utilizados en arrays. * Permite aplicar una función a cada elemento del array y construir un nuevo array con el resultado. * Ejemplo:const numbers = \[2, 4, 8, 10, 12]; const doubledNumbers = numbers.map(num => num \* 2); console.log(doubledNumbers); // \[4, 8, 16, 20, 24] * En este ejemplo, cada número del array `numbers` se multiplica por 2, resultando en un nuevo array `doubledNumbers`. ## Método `forEach` * `forEach` también itera sobre cada elemento del array y ejecuta una función proporcionada. * A diferencia de `map`, `forEach` no crea un nuevo array. * Ejemplo:const colors = \['red', 'pink', 'blue']; colors.forEach(color => console.log(color)); * En este ejemplo, `forEach` recorre el array `colors` e imprime cada color en la consola. ## Ejemplo Aplicado: Conversión de Temperaturas * Vamos a convertir temperaturas de Fahrenheit a Celsius utilizando `map`. * Ejemplo:const temperaturesInFahrenheit = \[32, 68, 95, 212]; const temperaturesInCelsius = temperaturesInFahrenheit.map(f => (5/9) \* (f - 32)); console.log(temperaturesInFahrenheit); // \[32, 68, 95, 212] console.log(temperaturesInCelsius); // \[0, 20, 35, 100] * En este ejemplo, se utiliza `map` para aplicar la fórmula de conversión a cada elemento del array, resultando en un nuevo array `temperaturesInCelsius`. ## Ejemplo Aplicado: Suma de Elementos en un Array * Vamos a sumar todos los elementos de un array utilizando `forEach`. * Ejemplo:const numbers = \[1, 2, 3, 4, 5]; let sum = 0; numbers.forEach(num => sum += num); console.log(numbers); // \[1, 2, 3, 4, 5] console.log(sum); // 15 * En este ejemplo, `forEach` recorre el array `numbers` y suma cada número a la variable `sum`. ## Próximos pasos * Practicar el uso de `map` y `forEach` en diferentes escenarios y problemas. * Aplicar estos métodos en proyectos personales para consolidar el aprendizaje. * Explorar otros métodos de arrays en JavaScript, como `filter`, `reduce` y `find`, para ampliar tus habilidades en manipulación de datos.
Utilizé map const Farenheit = \[55, 33, 0] const Celsius = Farenheit.map(temp =>(temp-32)\*5/9) console.log(Farenheit) console.log(Celsius) Por cierto. Lo hice en codepen.io que me parece muy bueno para estos ejercicios rápidos donde no quieres crear todo un ambiente de programación en un folder.
Como usar map Tienes un array original que llamaremos: const arrayOriginal = \["dato1", "dato2", "dato3"] Luego tienes una constante que almacenara un nuevo array a partir de aplicar el método map al arrayOriginal: const nuevoArray = arrayOriginal.map(nombreCualquiera => nombreCualquiera y al lado la operación o acción con la que quieras modificar cada uno de los elementos del array)
creo yo que la mejor opcion es map() ya que le estaria haciendo la funcion a cada elemento del array
Hice una modificacion al ejercicio final: ```js //Exercise: Sum of Elements in an Array let ramdomNumber = Math.floor(Math.random() * 5) const numbers = [1, 2, 3, 4, 5] numbers.forEach(number => { console.log(`La suma a realizar es: ${number} + ${numbers[ramdomNumber]} = `) number += numbers[ramdomNumber] console.log(number) }) console.log('El numero aleatorio es:', numbers[ramdomNumber]) console.log('Los numeros del Array son:', numbers) ```Se genera un numero aleatorio entre 0 y 4, y selecciona dicho numero como posicion en el Array, posteriormente se suma a cada uno de los valores del Array.
**NOTAS:** ![](https://static.platzi.com/media/user_upload/image-033bcd03-a1fc-4941-809f-935bdb220a91.jpg) ![](https://static.platzi.com/media/user_upload/image-ad30cdb7-8a37-4a3e-a368-84e98d4b144f.jpg)
```js /* Sum of Elements in an Array Create a program that takes an array of numbers as input and calculates the sum of all elements in that array */ const numbers = [1, 2, 3, 4, 5, 6] let sum = 0 const sumOfNumbers = numbers.map(num => sum += num) console.log(numbers); console.log(sumOfNumbers.pop()); ```Este es mi aporte del ejercicio.
Me divertí con esta clase 🤠 ![](https://static.platzi.com/media/user_upload/image-9b5db6e1-bb61-429c-b1f9-8a003990fc8b.jpg)
*/\* Sum of Elements in an Array* *Create a program that takes an array of numbers as input and calculates the sum of all elements in that array\*/* const numbers = \[1, 2, 3, 4, 5, 6]let sum = 0const sumOfNumbers = numbers.map(num => sum += num) console.log(numbers);console.log(sumOfNumbers.pop());