¡Te damos la bienvenida a este reto!

1

¡Bienvenido al mundo de JavaScript!

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

Día 2

6

Operadores

7

Hoisting y coerción

8

Playground - Calcula la propina

9

Alcance de las variables

Día 3

10

Condicionales

11

Playground - Calcula años bisiestos

12

Switch

13

Playground - Obten información de mascotas según su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

Día 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

20

Playground - encuentra el palindromo más grande

Día 6

21

Reasignación y redeclaración

22

Modo estricto

Día 7

23

Debugging y manejo de errores

24

Programación funcional

Quiz: Día 7

Día 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio método map

Día 9

29

ECMAScript

30

TC39

Quiz: Día 9

Día 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

Día 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

Día 12

39

Arrays a profundidad

40

Métodos de arrays: Every, Find y findIndex

41

Playground - Válida el formulario

Día 13

42

Métodos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

Métodos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicación del valor buscado

Día 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

Métodos de arrays: sort

49

Playground - Ordena los productos

Día 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

Día 16

51

Programación orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

Día 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

Día 18

57

Abstracción en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

Día 19

61

Herencia en JavaScript

62

Playground - Jerarquía de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

Día 20 - Checkpoint

65

Playground - Agenda de vuelos

Día 21

66

Patrones de diseño

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

Día 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el código usando builder pattern

Día 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajería

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementación de Observador en Newsletter

Día 24 - Checkpoint

77

Playground - Crea un task manager con patrones de diseño

Día 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementación de un array

80

Hash tables en JavaScript

81

Playground - Implementación de una HashTable para Contactos

Día 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

Día 27

86

Singly Linked List en JavaScript

87

Playground - Agrega métodos a la singly linked list

88

Playground - Implementación de una singly linked list

Día 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

Día 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

Día 30

93

¡Lo lograste!

Live Class

94

30 días de JS con Juan DC

95

30 días de JS con Nicobytes

96

30 días de JS con GNDX

97

30 días de JS con LeoCode

98

30 días de JS con Teffcode

99

Sesión: Cierre de los 30 días de JavaScript

No tienes acceso a esta clase

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

Playground - Crea tu propio método map

28/99

Aportes 89

Preguntas 0

Ordenar por:

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

o inicia sesión.

🛡️🛡️Escudo anti-spoilers🛡️🛡️

/
Aprovechando el espacio dejame explicarte un poquito más acerca de las funciones puras como es este caso, la definición es un poco curiosa:

Una función pura es aquella que dado el mismo input, tendremos el mismo output

En palabras sencillas, una función que no modifica el input.
/
Lo siguiente no es un spoiler así que puedes seguir leyendo.
/
imaginemos que la función myMap modifica nuestro array, de tal manera que siempre tendremos un resultado diferente. Ejemplo

const array = [1,2,3,4,5]
myMap(array, (num) => num * 2)

console.log(array)
// Suponiendo que se modifica el array tendríamos [2,4,6,8,10]

// Lo volvemos a ejecutar
myMap(array, (num) => num * 2)

// Teniendo el mismo input estamos obteniendo un diferente output
console.log(array)
// en este caso, ahora sería [4,8,12,16,20]

La ventaja de las funciones de orden superior es básicamente eso, que no modifican el input (el array en este caso).
Por lo que esta HOF siempre nos dará el mismo resultado dado el mismo input

const array = [1,2,3,4,5]
myMap(array, (num) => num * 2)
// Si no modificamos el array, la función siempre nos retornará [2,4,6,8,10]

console.log(array)
// Al no modificar el array, nos dará siempre lo mismo [1,2,3,4,5]

// Lo volvemos a ejecutar
myMap(array, (num) => num * 2)
// El resultado sigue siendo el mismo [2,4,6,8,10]

// Teniendo el mismo input estamos obteniendo un mismo output
console.log(array)
// en este caso, sigue siendo [1,2,3,4,5] (conserva su estado)

Ahora sí, los spoilers aquí abajo

Explicación de la solución

Aquí el código de solución

function myMap(array, func) {
  // Creamos el array que retornaremos
  // Inicialmente está vacío 
  const rta = [];
  for (let i = 0; i < array.length; i++) {
    // Luego iteramos por cada elemento del array
    const element = array[i];

    // Y lo vamos pasando al array vacío después de ejecutar 
    // la función sobre cada elemento del array
    rta.push(func(element));

    // Es importante recalcar que en ningún momento modificamos el array original 
  }

  // Al final lo retornamos
  return rta;
}

Y listo! Un par de lineas para resolver este ejercicio ¿Cómo te fue a ti?

Anti Spoiler

Anti Spoiler

Anti Spoiler

Anti Spoiler

Anti Spoiler

Anti Spoiler

Mi solución

Utilizo un ciclo for para recorrer desde la posición 0 hasta la última posición del arreglo y en cada iteración ejecuto la función que llegó como parámetro y la guardo dentro de la posición correspondiente

export function myMap(array, func) {
  let nuevoArray = array
  for (let i = 0; i < nuevoArray.length; i++){
    nuevoArray[i] = func(nuevoArray[i])
  }
  return nuevoArray
}

Mi solución, sin uso de metodos del Array, y funciona en Arrays de multiples dimensiones. Puro código vanilla.

export function myMap(array, func) {
    let newList = [];
    for ( let position = 0; position < array.length;  position++){
        const element = array[position];
        if (func(element)){
            newList[position] = func(element);
            continue;
        }
        newList[position] = myMap(element, func);
    }
    return newList;
}  

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Crea tu propio método map

export function myMap(array, func) {
  // Tu código aquí 👈
  let result = [];
  for (let element of array) {
    result.push(func(element));
  }

  return result;
}

console.log(myMap([1, 2, 3, 4], (num) => num * 2));
console.log(
  myMap(
    [
      { name: "michi", age: 2 },
      { name: "firulais", age: 6 },
    ],
    (pet) => pet.name
  )
);


Genial! siempre quise saber como funcionaba .map

El objetivo de este desafío es crear una función myMap que recibe un array y una función, y devuelve un nuevo array con los elementos transformados por la función.

Para lograr esto, se puede utilizar una función de orden superior, en este caso reduce, para iterar sobre el array original y aplicar la función a cada elemento. En cada iteración, se puede agregar el resultado de la función transformada a un nuevo array que se devolverá al final.

Aquí está una posible solución:

export function myMap(array, func) {
  return array.reduce((acc, curr) => {
    acc.push(func(curr));
    return acc;
  }, []);
}

En esta solución, la función reduce se utiliza para iterar sobre el array original y aplicar la función func a cada elemento. En cada iteración, se agrega el resultado de la función transformada al array acc, que se inicializa como un array vacío []. Al final de la iteración, reduce devuelve el array acc, que contiene los elementos transformados.

.

  • .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    asi tambien funciono 😃, jujuju siento que voy entendiendo
    function myMap(array, func) {
    var data = [];
    array.forEach(e => data.push(func(e)))
    return data;
    }

Pensé que me iba a costar mucho pero pude hacerlo rápido 😃
Dejo mi solución
.
.
.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  // Tu código aquí 👈
  let newArray = [];
  for (let i = 0; i < array.length; i++) {
    const newElement = func(array[i]);
    newArray.push(newElement);
  }
  return newArray;
}

**Alerta de spoiler **

export function myMap(array, func) {

  let arreglo = [];

  for (let i = 0; i < array.length; i++){
    arreglo[i] = func(array[i]);
  }

  return arreglo;
}

Anti-Spoiller
Esta fue mi solución 😃

Mi solución:

export function myMap(array, func) {
  array.forEach((value, i, arr) => {
    arr[i] = func(value);
  });
  return array;
}

buen día;
les comparto mi solución

function myMap(array, func) {
    const newArray = [];
    for (let i = 0; i < array.length; i++) {
        let resp = (func(array[i]));
        newArray.push(resp);
    };
    return newArray;
}

ALTO AHÍ, NO TE SPOILEES

PERO YA QUE INSISTES 🤷‍♂️

function myMap(array, func) {
  let arrayMap = [];
  for (let element of array) {
    arrayMap.push(func(element));
  }
  return arrayMap;
}```

Fue el más fácil luego del ejercicio de retornar el typeof  😅

Bueno debo confesar que me costo pero la satisfacción es muy grande cuando lo consigues desarrollar.

Solución !
.
.
.
.
.
.
.
.
.

Es extraño, ni siquiera la propia solución propuesta pasa la quinta prueba

Mi solución:
👀
👀
👀
👀
👀
👀

export function myMap2(array, func) {
  const newArray = []
  array.forEach(e=>newArray.push(func(e)))
  return newArray
}
export function myMap(array, func) {
  // Tu código aquí 👈
  let nuevoArray = [];
  array.forEach(item => {
    nuevoArray.push(func(item));
  });
  return nuevoArray;
}


.
.
.
.
.
.

export function myMap(array, func) {
    let output = [];
    for (let i of array) {
      output.push(func(i));
    }
    return output;
}

Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo

function myMap(array, func) {
  const newArr = [];
 
  for (let i = 0; i <= array.length - 1; i++){
    
    newArr.push(func(array[i]))
  }
  console.log(newArr)
  return newArr;
  
  
}
export function myMap(array, func) {
  // Tu código aquí 👈
  let result = []
  array.forEach((data) => {
    result.push(func(data))
  })
  return result;
}


🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto, sin usar array methods:

export function myMap(array, func) {
  let result = []
  for (let e = 0; e < array.length; e++) {
    result[e] = func(array[e])
  }
  return result
}

export function myMap(array, func) {
  let i = 0;
  let rtaDelMap = [];
  while (i < array.length) {
    const element = array[i];
    rtaDelMap.push(func(element));
    i++;
  }
  return rtaDelMap;
}

export function myMap(array, func) {

let array2 = [];

for (let i = 0; i <array.length; i++){
array2.push(func(array[i]))

}
return array2
// Tu código aquí 👈
}

vamos!
*
*
*
*
*
*
*
*

export function myMap(array, func) {
  const resultado = [];

  for (let i = 0; i < array.length; i++) {
    resultado.push(func(array[i], i, array));
  }

  return resultado;
}

Mi solución:

function myMap(array, func) {
  const result = []
  array.forEach(element => {
    result.push(func(element))
  })
  return result;
}
export function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = array.map(func);
  return newArray;
}

👾 Mi solución

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function myMap(array, func) {
  // Tu código aquí 👈
  let newArray = []
  array.forEach((el) => newArray.push(func(el)))
  return newArray
}

solucion

export function myMap(array, func) {
  let result = []
  for (let i=0; i < array.length; i++){
    result[i] = func(array[i])
  }
  return result
}
export function myMap(array, func) {
  // Dia 8 💚
  const newArray = []
  for (const value of array) {
    newArray.push(func(value))
  }
  return newArray
}

export function myMap(array, func) {
  // Tu código aquí 👈
  let resultado = []
  for (let i = 0; i < array.length; i++){
    const e = array[i]
    resultado.push(func(e));
  }
  return resultado
}

export function myMap(array, func) {
const res = [];

for (let i = 0; i < array.length; i++){
res.push(func(array[i]));
}

return res;
}

export function myMap(array, func) {
const xd = array.map(func)
return xd
}

lo mismo, pero mas barato, porque sacan el mismo error, pero en la solucion sale 632 calls, en este solo hace 1

export function myMap(array, func) {

  let arrResult=[]
  for (let item of array) {
    let result = func(item)
    if (result) {
      arrResult.push(result)
    }
  }
  return arrResult;
}

Reto cumplido

Mi solución

let resultado = []
    for (let i = 0; i < array.length; i++){
        resultado.push(func(array[i]))
    }
    return resultado

método map,logrado! 😃

function myMap(array, func) {
  // Tu código aquí 👈
  let maparr = [];
  for (let num of array) {
    maparr.push(func(num));
  }
  return maparr;
}

Solucion

function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = []
  for (item of array) {
  	const mappedItem = func(item)
    newArray.push(mappedItem)
  }
  console.log(newArray)
  return newArray
}

Hola. Mi solución al ejercicio
.
.
.
.
.
.
.
.
.
.
.
Consiste en la creación de un array de salida, para luego recorrer el array de entrada e irle haciendo .push a los valores con la función aplicada. Finalmente retorna el array de salida

export function myMap(array, func) {
  let ans = []
  for (let i of array) ans.push(func(i));
  return ans;
}
const myMap = (array, func) => {
  let result = [];
  for(let i = 0; i < array.length; i++){
    result.push(func(array[i]));
  }
  return result;
}

Mi solución:

export function myMap(array, func) {
  let result = [];
  for (let i of array) {
    result.push(func(i));
  }
  return result;
}

+++
+
+
+

export function myMap(array, func) {
  let newArray = array.map((element) => {
    return func(element);
  });
  return newArray;
}

Mi solución

export function myMap(array, func) {
  let newArr = []
  for (let el of array) {
    newArr.push(func(el))
  }
  return newArr
}

Aqui esta mi ejercicio inicialmente me equivoque y pense que se usaba map() hasta que vi las respuestas de los compa;eros, una vez entendido el ejercicio …

 export function myMap(array, func) {
  let output = []
  for (let i = 0; i < array.length; i ++){
    output.push(func (array[i]))
  }
  return output
}

Escudo anti spoilers
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&
&

export function myMap(array, func) {
//myMap(array, (num) => * 2);
const returnArray = [];
for (const element of array) {
returnArray.push(func(element));
}
return returnArray;
}

Mi solución:

export function myMap(array, func) {
  let newArray = []
  for (let i = 0; i < array.length; i++) {
    newArray[i] = func(array[i])
  }
  return newArray
}

Respuesta después del escudo 😄
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

function myMap(array, func) {
  const respuesta = []
  array.forEach((element) => {
    respuesta.push(func(element))
  })
  return respuesta
}

Hola, comparto mi solución. Pero antes…
¡ESCUDO!
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

La función myMap recibe como parámetros un array y una función func que será aplicada a cada elemento del array. Dentro de la función, se inicializa un array vacío llamado result que almacenará los resultados de la función aplicada a cada elemento del array original. Luego, se recorre el array original utilizando un bucle for, y en cada iteración se llama a la función func pasando como argumentos el elemento actual, su índice y el array original completo. El resultado de la función es añadido al array result utilizando el método push. Finalmente, se devuelve el array result con los resultados de la función aplicada a cada elemento del array original.

function myMap(array, func) {
  // Tu código aquí 👈
  let result = [];
  for (let i = 0; i < array.length; i++) {
    result.push(func(array[i]));
  }
  return result;

}
export function myMap(arr, func) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    result.push(func(arr[i]));
  }
  return result;
}```
function myMap(array, func) {
  let nArray = [];
  
  for (let a of array){
    nArray.push(func(a));
  }

  return nArray;
}

No se si estara bien del todo, pero fue el razonamiento que me pareció más sencillo y me funciono sin problema.

export function myMap(array, func) {
  // Tu código aquí 👈

  const nuevoArray = array.map(func)

  return nuevoArray
}

aporte solucion 1:
.
.
.
.
.
.
.
.
.
export function myMap(array, func) {
// Tu código aquí 👈
let retorno = array.map((element) => func(element))
return retorno;
}

Solucion 2:
.
.
.
.
.
.
.
.
.
.
.
.
.
export function myMap(array, func) {
// Tu código aquí 👈
let nuevoArray = [];
for (let element of array)
{
let cambio = func(element);
nuevoArray.push(cambio);
}
return nuevoArray;
}

.
.
.
.
.
.
.
.
.
.
.

function myMap(array, func) {
    let array2 = []

    array.forEach(element => {
        array2.push(func(element))
    })
    return array2
  }

Hola a todos yo entendí pero solamente retorné esto y funcionó

  return array.map(element => func(element));

Para que reinventar la rueda no se mucho de javascript pero lo que aprendi en estos dias es usar lo que ya tien javascript, y use la funcion map jajaja:

export function myMap(array, func) {
  return array.map(func);
}

Mi solución. Escudo anti-spoilers 🚨🚨🚨

function myMap(array, func) {
  // Tu código aquí 👈
  let output = [];

  array.forEach((element) => {
    output.push(func(element));
  });

  return output;
}

Al inicio pensé que era muy difícil, después de leerlo unas cuantas veces la lógica fue surgiendo, aquí mi solución:

export function myMap(array, func) {
    let copy = [];
    for (const prop in array) {
      copy.push(func(array[prop]));
    }
    return copy;
}

Revisé el código de algunos de mis compañeros y me llamó mucho la atención que mi solución fue muy diferente así que aquí les dejo la mía:

export function myMap(array, func) {
  const mapNumbers = array.map(func)
  const mapPets = array.filter(func)  

  return mapNumbers
  return mapPets
}

export function myMap(array, func) {
  let arrayIm = []
  array.forEach((value) => {
    let element = func(value)
    arrayIm.push(element)
  }) 
    
  return arrayIm
}

Aquí esta mi solución al playground.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Declare e inicialice el arreglo nuevo, que voy a devolver, para después con un ciclo for recorrerlo y asignarle en cada posición el nuevo valor que resulta de aplicar la función a cada elemento del arreglo inicial.

export function myMap(array, func) {
  // Tu código aquí 👈
  const nuevoArray = [];

  for (let i = 0; i < array.length; i++){
    nuevoArray[i] = func(array[i]);
  }

  return nuevoArray;
}

Hola a todos, aquí mi solución:

export function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = [];
  for (const item of array) {
    newArray.push(func(item));
  }
  return newArray;
}

Mi aporte:

export function myMap(array, func) {
  // Tu código aquí 👈
  let changes = [];
  array.forEach(el => {
    const res = func(el);
    changes.push(res);
  });

  return changes;
}

Hola a todos, les comparto la forma como lo realice:

export function myMap(array, func) {
  let arrayResultado = [];
  array.forEach(element => {
    const resultUnit = func(element);
    arrayResultado.push(resultUnit);
  });
  return arrayResultado; 
}

Hola a todos! les comparto mi solución ☝️🤓
Si llegaron a este comentario supongo que no necesitaran un anti-spoiler (confió en el escudo de LeoCode)

export function myMap(array, func) {
  //inicializacion y declaraciond e variables
  let newArray = []
  let element = null
  //hacemos uso de la funcion iterativa for para tomar los elementos del array, a los cuales le aplicmos la funcion y los pasamos al nuevo array
  for (element of array) {
    let newElement = func(element)
    newArray.push(newElement)
  }
  //devolvemos el array como resultado
  return (newArray)
}

ez el tutorial

export function myMap(array, func) {
  let newArray = []
  for (let arr of array) newArray.push(func(arr))
  return newArray
}

Comparto mi solución

export function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = [];

  for (let item of array) {
    newArray.push(func(item));  
  }
  return newArray;
}

++
+
+
+
++
+
+
+
+
+
+
+

export function myMap(array, func) {
  let answer = [];
  for (let i of array) {
    let resultado = func;
    answer.push(resultado(i));
  }
  return answer;
}

mi solución como principiante:

  • Buscar que func se definiera como una función
  • Hacer el llamado a cada elemento del array
  • Ejecutar func para cada elemento del array
  • Retornar el resultado
  let result = [];
  function secondFunc(objeto) {
    func;
  }

  for (let i = 0; i < array.length; i++) {
    result.push(func(array[i]));
  }
  return result;   
function myMap(array, func) {
    const resultado = [];
    for (let i = 0; i < array.length; i++){
      resultado.push(func(array[i]));
    }
    return resultado;
  }

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

export function myMap(array, func) {
  let newarr=[]
  for (let value of array) {
    newarr.push(func(value))
    
  }
  return(newarr)
  // Tu código aquí 👈
}

here the sol guys

export function myMap(array, func) {
  let newArry = [];
  for (let i = 0; i < array.length; i++) {
    newArry.push(func(array[i]))
  }
  return newArry;
}

Solución… 😄
.
En primer lugar, creamos un array de resultados vacío ‘result’.
.
Posteriormente, procedemos a recorrer el ‘array’ con un ciclo for, dentro del cual crearemos un variable ‘element’.
.
esta variable será igual a func(array[i]); es decir, la función func tiene la siguiente estructura:
.

/* (<parámetro>) => <Se aplica alguna operación al parámetro, se retorna el resultado> */
(num) => num * 2

/* (<objeto>) => <Se retorna alguna propiedad del objeto> */
(pet) => pet.name
 

.
Por lo cual, ‘element’ obtendrá el valor del resultado de la función, según el array[i] correspondiente.
.
Añadimos ‘element’ al array de resultado, y retornamos ‘result’.
.

export function myMap(array, func) {
  const result = [];

  for (let i = 0; i < array.length; i++) { 
    let element = func(array[i]);
    result.push(element);
  }

  return result;
}

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

export function myMap(array, func) {
  // Tu código aquí 👈
  const returnArray = [];
  for (let i of array ) {
    let result = func(i);
    returnArray.push(result);
  }
  return returnArray;
}

Bueno ya lo resolvi pero creo que todavía me hace falta mas por entender, a seguir estudiando:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = [];
  for (const dataArray of array) {
    newArray.push(func(dataArray));
  }
  return newArray;
}

.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  // Tu código aquí 👈
  const newArray = [];
  array.forEach(element => {
    newArray.push(func(element));
  })
  return newArray;
}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  const output = [];
  array.forEach(element => output.push(func(element)));
  return output;
}

Mi solución con foreach:

function myMap(array, func) {
  // Tu código aquí 👈
  let newArr = []

  array.forEach(element => {
    newArr.push(func(element));
  });

  return newArr

};

Esta es mi respuesta al reto
.
.
.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  let output = [];
  for (let i = 0; i < array.length; i++){
    output.push(func(array[i]));
  }
  return output;
}

Solución

export function myMap(array, func) {
  // Tu código aquí 👈
  let newArray = [];
  for (let element of array) {
    newArray.push(func(element));
  }
  return newArray;
}

¡Hola, Desafío cumplido 😃!
Objetivo
Desarrollar una implementación personalizada del método map
Mi solución,
Se detalla hasta abajo.⬇





export function myMap(array, func) {
  //@autor:dmos
  const evenRta = [];
  let itemNew = 0;
  array.forEach(element => {
    itemNew = func(element);
    evenRta.push(itemNew);
  });

return evenRta;
}

export function myMap(array, func) {
 //@autor:dmos
const  evenRta = array.map(func);
return evenRta;
}

Aquí mi solución:

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

export function myMap(array, func) {
  // Tu código aquí 👈
  return array.map(func);
}

Hola a todos, acá está la solución que realicé
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  let output = [];
  array.forEach(element => {
    output.push(func(element));
  });
  return output;
}

Mi solución:

export function myMap(array, func) {
  const final = [];
  for (let element of array) {
    const result = func(element);
    final.push(result);
  }

  return final;
}

Mi solución:
.
.
.
.
.
.

function myMap(array, func) {
  const result = [];
  for (const element of array) {
      result.push(func(element));
  }
  return result
}

Mi solucion:
SPOILER
.
.
.
.
.
.
.
.

export function myMap(array, func) {
  let newArr = [];

  for (let i = 0; i < array.length; i++) {
    newArr.push(func(array[i]));
  }

  return newArr;
}

.
. YA QUE NO HAY ESCUDO ANTI SPOILER
. USENME COMO UNO 😃
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. que curiosos, mi respuesta es:

export function myMap(array, func) {
  // si usaramos un map: return array.map(func)
  let arr = []
  for(let val of array) {
    arr.push(func(val))
  }
  return arr
}

Hoy aprendí que se pueden pasar funciones de esta manera.
Spoilers:
.
.
.
.

export function myMap(array, func) {
    let newArray = [];

    for(let i = 0; i < array.length; i++){
        newArray.push(func(array[i]))
    };

    return newArray
};
undefined