Introducción a JavaScript
¿Por qué aprender JavaScript?
¡Hola Mundo! en Mac
¡Hola Mundo! en Windows
Anatomía de una variable
Tipos de datos en JavaScript
Creación de strings
Operadores aritméticos
Conversión de tipos: Type Casting y Coerción
Conversión de tipos explícita e implícita
Estructuras de Control y Lógica
Operadores de comparación
Operadores lógicos
Ejecución condicional: if
Ejercicio: Adivina el número
Ejecución condicional: switch
Loop: for
Loop: for of
Loop: for in
Loop: while
Loop: do while
Funciones y This
Anatomía de una función
Funciones vs Métodos
Funciones puras e impuras
Arrow function y enlace léxico
Contextos de ejecución y scope chain
¿Qué es Closure?
Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?
Manipulación de Arrays
Introducción a Arrays
Mutabilidad e inmutabilidad de Arrays
Modificación básica del final con push( ), pop( )
Iteración con map( ) y forEach( )
Filtrado y reducción con filter( ) y reduce( )
Búsqueda de elementos con find( ) y findIndex( )
Crear copias con slice( )
Spread operator: casos de uso
Programación Orientada a Objetos
Anatomía de un Objeto
Trabajando con objetos en JavaScript
Función constructora
¿Qué es una clase?
Prototipos y herencias
Herencia en la práctica
Prototipos en la práctica
this en JavaScript
Proyecto: Crea una red social
Proyecto: Crea una red social parte 2
Asincronía en JavaScript
¿Cómo funciona el JavaScript Engine?
Promesas en JavaScript
Usando Async y await en JavaScript
For await of
¿Cómo funciona la web?
¿Cómo funciona HTTP?
Método GET en JavaScript
Método POST en JavaScript
Método DELETE en JavaScript
Importancia del id en el método DELETE
ECMAScript 6 y tus siguientes pasos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Iteración con map( ) y forEach( )
30/55Recursos
Aportes 18
Preguntas 1
Ordenar por:
## Resumen de la clase
Aquí te dejo mi resumen sobre esta clase! Si quieres ir un paso más adelante, sigue leyendo!
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!
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.
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.
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 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/>
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.
**¿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);
```
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.
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.
con la estructura de la clase, logre organizar una idea para una funcion que me ayude a convertir la temperatura de Fahrenheit a Celcius
**NOTAS:**
```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 🤠
*/\* 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());
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?