Playground - Crea tu propio método map

🛡️🛡️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
};