Playground - Crea tu propia implementación de un array

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

1
¡Bienvenido al mundo de JavaScript!
01:33 min

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

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

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - Crea tu propia implementación de un array

Comentarios

Santiago Arias

student

En el constructor la estructura que utilicen para almacenar la informacion debe llevar el nombre de "data" y la variable que lleva el control del tamaño del array debe llevar el nombre de "length". No lo aclara en el enunciado y las pruebas no pasan si no usan esos nombres en especifico.

Leonardo de los angeles Espinoza Hernandez

student

Me llevo este feedback para ponerlo en la guía, mil gracias por tu comentario Santiago 💪

HERNANDO RAMIREZ

student

Aparte de estas aclaraciones, no se indica que parametro se debe retornar, creo que para nosotros los principiantes no es posible intentar una solución si el enunciado no es claro, ademas falta un ejemplo con filter y map

Osvaldo Martinez Guillen

student

Después de 10 horas con lagrimas en el camino, aquí mi solución:

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }
  map(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      copy.data[prop] = func(this.data[prop]);
      copy.length++;
    }
    return copy;
  }
  filter(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      if (func(this.data[prop])) {
        copy.data[copy.length] = this.data[prop];
        copy.length += 1;
      }
    }
    return copy;
  }
  push(item) {
    if (this.length === 0) {
      this.data[this.length] = item;
    } else {
      this.data[this.length] = item;
    }
    return this.length += 1;
  }
  pop() {
    let deleted = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length -= 1;
    return deleted;
  }
  join(character = ",") {
    let joined = "";
    for (let prop in this.data) {
      prop = Number(prop);
      if (prop === 0) {
        joined += this.data[prop] + character;
      }
      else if (prop === this.length - 1) {
        joined += this.data[prop];
      } else {
        joined += this.data[prop] + character;
      }
    }
    return joined;
  }
  shift() {
    let deleted = this.data[0];
    delete this.data[0];
    let copy = { ...this.data }, contador = 0;
    this.data = {};
    for (let prop in copy) {
      this.data[contador] = copy[prop];
      contador++;
    }
    this.length -= 1;
    return deleted;
  }
  unshift(item) {
    if (item != null) {
      let copy = { ...this.data };
      this.data = {};
      this.data[0] = item;
      for (let prop in copy) {
        this.data[this.length] = copy[prop];
      }
      return this.length += 1;
    }
  }
}

Santiago Andres Alvarez Cuadros

student

Teniendo en cuenta la funcionalidad regular de los métodos de arreglos a clonar en este playground, es importante recordar que:

map y join son métodos inmutables, así que no deberían modificar el array original y deben devolver un nuevo arreglo (esto incluye tanto los datos como la longitud)
push, pop, shift y unshift son métodos mutables, se espera que el array original sea modificado
pop devuelve el elemento que fue eliminado
push, shift y unshift devuelven la longitud del arreglo ya mutado
join debe devolver un string . Mi solución: . . . .

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    const mutatedData = new MyArray()
    for (let key in this.data) {
      newData.push(func(this.data[key]))
    }
    return mutatedData
  }

  filter(func) {
    const filteredData = new MyArray()
    for (let key in this.data) {
      if (func(this.data[key])) {
        filteredData.push(this.data[key])
      }
    }
    return filteredData
  }

  push(item) {
    this.data[this.length] = item
    this.length++
    return this.length
  }

  pop() {
    if (this.data['0']) {
      this.length--
      const deletedItem = this.data[this.length]
      delete this.data[this.length]
      return deletedItem
    }
  }

  join(character = ",") {
    let joinedValues = ''
    for (let key in this.data) {
      if (Number(key) === this.length - 1) {
        joinedValues += this.data[key]
      } else {
        joinedValues += this.data[key] + character
      }
    }
    return joinedValues
  }

  shift() {
    const deletedItem = this.data['0']
    delete this.data['0']
    const newData = {}
    this.length--
    for (let i = 0; i < this.length; i++) {
      newData[i] = this.data[i + 1]
    }
    this.data = newData
    return deletedItem
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    }
    const newData = {}
    newData['0'] = item
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i]
    }
    this.data = newData
    this.length++
    return this.length
  }
}

Carina Payleman

student

. . . . . . Fue difícil pero la verdad me encantó el ejercicio, porque a medida iba creando mis métodos los iba implementando en otros! De a piecitas iba armando la resolución completa.

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let newArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const element = this.data[i];
      newArray.push(func(element));
    }
    return newArray;
  }

  filter(func) {
    let newArray = new MyArray();
    this.map((element) => {
      if (func(element)) {
        newArray.push(element);
      }
    });
    return newArray;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.data;
  }

  pop() {
    let deletedItem = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deletedItem;
  }

  join(character = ",") {
    let myString = '';
    for (let i = 0; i < this.length; i++) {
      myString += this.data[i] + character;
    }
    return myString.slice(0, -1);
  }

  shift() {
    let deletedItem = this.data[0];
    delete this.data[0];
    for (let i = 0; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    this.pop();
    return deletedItem;
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    } else {
      this.data[0] = item;
      for (let i = 0; i < this.length; i++) {
        this.data[i + 1] = this.data[i];
      }
      this.length++;
      return this.length;
    }
  }
}

David Esteban Giraldo Duque

student

Mi solución: . . . . . .

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    let newData = new MyArray
    for (let item in this.data) {
      newData.data[item] = func(this.data[item])
      newData.length++
    }
    return newData
  }

  filter(func) {
    let filteredData = new MyArray
    for (let item in this.data) {
      if (func(this.data[item])) {
        filteredData.data[filteredData.length] = this.data[item]
        filteredData.length++
      }
    }
    return filteredData
  }

  push(item) {
    this.data[this.length] = item
    this.length++
    return this.length
  }

  pop() {
    const deleted = this.data[this.length - 1]
    delete this.data[this.length - 1]
    this.length--
    return deleted
  }

  join(character = ",") {
    let str = ""
    for (let i = 0; i < this.length; i++) {
      str += (i < this.length - 1) ? this.data[i] + character : this.data[i]
    }
    return str
  }

  shift() {
    const deleted = this.data[0]
    delete this.data[0]
    this.length--
    for (let i = 0; i < this.length; i++) {
      this.data[i] = this.data[i + 1]
    }
    delete this.data[this.length]
    return deleted
  }

  unshift(item) {
    if (!item && item !== 0) { return this.length }
    for (let i = this.length; i >= 0; i--) {
      this.data[i] = this.data[i - 1]
    }
    this.data[0] = item
    this.length++
    console.log(this)
    return this.length
  }
}

HERNANDO RAMIREZ

student

no se indica que se debe retornar en el pop, shift y unshift, apesar que se devuelve la longitud del objeto. Para nosotros los principiantes pueden aclararlo?

Gabriel Luna

student

¿Cómo se entiende la guía cuando dice "No podrás usar los corchetes [], aquí entenderás porque los arrays se consideran objetos"?

Joan Alexander Valerio Rodríguez

student

Un ejercicio super interesante la verdad! Pero por favor denle un poco de amor a la documentación 🤓 algunos puntos fueron un tanto confusos... especialmente las instrucciones del constructor.

Rubén Hernández Hernández

student

💚 Mi solución 💚

🛡️ESCUDO ANTI-SPOILERS🛡️

!cat

En algunas partes de mi código uso operadores tipo ++ o --, recuerden que dependiendo del lugar en donde se pone (izquierda o derecha de la variable) es el momento en el que se ejecuta (una línea de ejecución antes o después respectivamente).

👾Código

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let mapArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      mapArray.data[i] = func(this.data[i]);
    }
    mapArray.length = this.length;
    return mapArray;
  }

  filter(func) {
    let filteredArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      if (func(this.data[i])) filteredArray.push(this.data[i]);
    }
    return filteredArray;
  }

  push(item) {
    this.data[this.length] = item;
    return ++this.length;
  }

  pop() {
    let temp = this.data[--this.length];
    delete this.data[this.length];
    return temp;
  }

  join(character = ",") {
    let string = "";
    for (let i = 0; i < this.length; i++) {
      string += this.data[i] + character;
    }
    return string.slice(0, -character.length);
  }

  shift() {
    let newData = {};
    let temp = this.data[0];
    for (let i = 0; i < this.length; i++) {
      newData[i] = this.data[i + 1];
    }
    delete this.data;
    this.data = newData;
    this.length--;
    return temp;
  }

  unshift(item) {
    if (item == null) return this.length;

    let newData = { 0: item };
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i];
    }
    delete this.data;
    this.data = newData;
    return ++this.length;
  }
}

Diego Herrera Prado

student

Comparto mi solución . . . . . . . . . . .

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {};
    this.length = 0;
  }

  map(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.length; i++){
      newArray.push(func(this.data[i]));
    }
    return newArray;
  }

  filter(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.length; i++){
      if (func(this.data[i])) {
        newArray.push(this.data[i]);
      }
    }
    return newArray;
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item;
    this.length += 1;
    return item;
  }

  pop() {
    // Tu código aquí 👈
    if (this.length) {
      const last = this.data[this.length-1]
      delete this.data[this.length - 1];
      this.length -= 1;
      return last;
    }
    return undefined;
    
  }

  join(character = ",") {
    // Tu código aquí 👈
    let str = "";
    for (let i = 0;i<this.length-1; i++){
      str += this.data[i] + character;
    }
    str += this.data[this.length - 1];
    return str;

  }

  shift() {
    // Tu código aquí 👈
    const first = this.data[0];
    for (let i = 1; i < this.length; i++){
      this.data[i-1] = this.data[i]
    }
    delete this.data[this.length - 1];
    this.length -= 1;
    return first;
  }

  unshift(item) {
    // Tu código aquí 👈
    if (item !==undefined) {
      for (let i = this.length - 1; i >= 0; i--) {
        this.data[i + 1] = this.data[i];
      }
      this.data[0] = item;
      this.length += 1;
      return this.length;
    }
  }
}

Ulises Serrano Pérez

student

Jajaja yo lo hice con for's acá mi solución este si me hizo sudar. Las instrucciones si deben de mejorar la verdad me ayudo leer los comentario y además leer la documetación de los arreglos por ejempolo el de método pop: https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/pop

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let temp = {};
    for (let i = 0; i < this.length; i++) { 
      temp[i] = func(this.data[i]);
    }
    let newArray = new MyArray();
    newArray.data = temp;
    newArray.length = this.length;
    return newArray;
  }

  filter(func) {
    let temp = {};
    let contador = 0;
    for (let i = 0; i < this.length; i++) { 
      if (func(this.data[i]) === true) { 
        temp[contador] = this.data[i];
        contador += 1;
      }
    }
    let newArray = new MyArray();
    newArray.data = temp;
    newArray.length = contador;
    return newArray;
  }

  push(item) {
    let resultado = Number(item);
    if (resultado == NaN) { 
      this.data[this.length] = item;
    }
    else {
      this.data[this.length] = resultado;
    }
    this.length += 1;
  }

  pop() {
    let eliminado = {};
    eliminado.length = this.length;
    this.length -= 1;
    let temp = {};
    for (let i = 0; i < this.length; i++) { 
      temp[i] = this.data[i];
    }
    this.data = temp;
    return eliminado.length;
  }

  join(character = ",") {
    let cadena = "";
    for (let i = 0; i < this.length; i++) { 
      cadena += this.data[i] + character;
    }
    return cadena.trim().substring(0, (cadena.length-character.length));
  }

  shift() {
    let eliminado = {};
    eliminado = this.data[0];
    let temp = {};
    let contador = 0;
    for (let i = 1; i < this.length; i++) { 
      temp[contador] = this.data[i];
      contador += 1;
    }
    this.length = Object.keys(temp).length;
    this.data = temp;
    return eliminado;
  }

  unshift(item) {
    if (item !== undefined ) { 
      let temp = {};
      let resultado = Number(item);
      if (resultado == NaN) {
        temp[0] = item;
      }
      else {
        temp[0] = Number(item);
      }
      for (let i = 0; i < this.length; i++) {
        temp[i + 1] = this.data[i];
      }
      this.data = temp;
      this.length = Object.keys(temp).length;
      return this.length;
    }
  }
}

David Ochoa

student

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

Crea tu propia implementación de un array

!Spoiler Shield

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.lenght = 0;
    this.data = {};
  }

  map(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.lenght; i++) {
      const element = this.data[i];
      newArray.push(func(element));
    }
    return newArray;
  }

  filter(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.lenght; i++) {
      const element = this.data[i];
      if (func(element)) {
        newArray.push(element);
      }
    }
    return newArray;
  }

  push(item) {
    this.data[this.lenght] = item;
    this.lenght++;
  }

  pop() {
    // Tu código aquí 👈
    this.lenght--;
    const deletedItem = this.data[this.lenght];
    delete this.data[this.lenght];
    return deletedItem;
  }

  join(character = ",") {
    // Tu código aquí 👈
    let result = "";
    for (let i = 0; i < this.lenght; i++) {
      result += this.data[i];
      if (i < this.lenght - 1) {
        result += character;
      }
    }
    return result;
  }

  shift() {
    // Tu código aquí 👈
    const deletedItem = this.data[0];
    delete this.data[0];
    this.lenght--;
    for (let i = 0; i < this.length; i++) {
      const nextElement = this.data[i + 1];
      this.data[i] = nextElement;
    }
    delete this.data[this.lenght];

    return deletedItem;
  }

  unshift(item) {
    // Tu código aquí 👈
    if (!item && item !== 0) {
      return this.lenght;
    }

    if (this.item == 0) {
      this.data[0] = item;
      this.lenght++;
      return this.lenght;
    }

    for (let i = this.length; i > 0; i--) {
      this.data[i] = this.data[i - 1];
    }

    this.data[0] = item;

    this.length++;
    return this.length;
  }
}

Victor Hernandez

student

Algo que no aclara el enunciado es que en el caso del método unshift una de las pruebas corresponde a recibir un arreglo de valores como entrada. Mi código inicial no pasaba esta prueba y en la vista no hay forma de replicar el escenario.

A continuación dejo mi código:

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    const mapData = new MyArray();
    for (let index in this.data) {
      mapData.push(func(this.data[index]));
    }
    return mapData;
  }

  filter(func) {
    const filterData = new MyArray();
    for (let index in this.data) {
      if (func(this.data[index])) {
        filterData.push(this.data[index]);
      }

    }
    return filterData;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.length;
  }

  pop() {
    if (this.length > 0) {
      this.length--;
      const item = this.data[this.length];
      delete this.data[this.length];
      return item;
    }
  }

  join(character = ",") {
    let values;
    for (let index in this.data) {
      if (values) {
        values += character + this.data[index];
      } else {
        values = this.data[index];
      }
    }
    return values;
  }

  shift() {
    const item = this.data['0'];
    delete this.data['0'];
    this.length = 0;
    const newData = {};
    for (let index in this.data) {
      newData[this.length] = this.data[index];
      this.length++;
    }
    this.data = newData;

    return item;
  }

  unshift(...items) {
    if (items) {

      this.length = 0;
      const newData = {};
      for (let item of items) {
        newData[this.length] = item;
        this.length++;
      }

      for (let index in this.data) {
        newData[this.length] = this.data[index];
        this.length++;
      }
      this.data = newData;
    }

    console.log(this.length);
    return this.length;

  }
}

Elias Rayas Gonzalez

student

Solucion

Como sugerencia, pueden revisar los enlaces a la especificación de ECMAScript al final de los artículos de MDN. + + + + + + + +

class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {};
    this.length = 0;
  }

  map(func) {
    // Tu código aquí 👈
    if (!typeof func === "function") throw TypeError("Not a function");

    let A = new MyArray();
    let k = 0;

    while (k < this.length) {
      let Pk = k;
      let kPresent = this.data[Pk];

      if (kPresent) {
        let kValue = this.data[Pk];
        let mappedValue = func(kValue);
        A.push(mappedValue);
      }
      k++;
    }
    return A;
  }

  filter(func) {
    // Tu código aquí 👈
    if (!typeof func === "function") throw TypeError("Not a function");
    let A = new MyArray();
    let k = 0;

    while (k < this.length) {
      let Pk = k;
      let kPresent = this.data[Pk];

      if (kPresent) {
        let kValue = this.data[Pk];
        let selected = Boolean(func(kValue));
        if (selected) {
          A.push(kValue);
        }
      }
      k++;
    }
    return A;
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item;
    this.length++;
    return this.data[this.length - 1];
  }

  pop() {
    // Tu código aquí 👈
    if (this.length === 0) return undefined;

    const deleted = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deleted;
  }

  join(character = ",") {
    // Tu código aquí 👈
    if (this.length === 0) return "";

    let R = "";
    let k = 0;
    while (k < this.length) {
      if (k > 0) R += character;

      let element = this.data[k];

      let next =
        element === undefined || element === null ? "" : element.toString();

      R += next;

      k++;
    }
    return R;
  }

  shift() {
    // Tu código aquí 👈
    if (this.length === 0) return undefined;

    let first = this.data[0];
    let k = 1;

    while (k < this.length) {
      let from = k;
      let to = k - 1;
      let fromPresent = this.data[from];
      if (fromPresent) {
        let fromVal = this.data[from];
        this.data[to] = fromVal;
      } else {
        delete this.data[to];
      }
      k++;
    }

    delete this.data[this.length - 1];
    this.length--;
    return first;
  }

  unshift(item) {
    // Tu código aquí 👈
    let argCount = arguments.length;

    if (argCount > 0) {
      if (argCount >= 2 ** 53) throw TypeError("Tooooo many arguments");
      let k = this.length;

      while (k > 0) {
        let from = k - 1;
        let to = k + argCount - 1;
        let fromPresent = this.data[from];
        if (fromPresent) {
          let fromValue = this.data[from];
          this.data[to] = fromValue;
        } else {
          delete this.data[to];
        }
        k--;
      }

      let j = 0;
      for (let i of arguments) {
        this.data[j] = i;
        j++;
      }
    }
    this.length += argCount;
    return this.length;
  }
}

Alexis Corrales

student

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }

  push(element) {
    this.data[this.length] = element;
    this.length++;
  }

  pop() {
    if (this.length === 0) return undefined;
    const lastElement = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return lastElement;
  }

  shift() {
    if (this.length === 0) return undefined;
    const firstElement = this.data[0];
    for (let i = 0; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1];
    this.length--;
    return firstElement;
  }

  unshift(element) {
    if (element != null) {
      for (let i = this.length - 1; i >= 0; i--) {
        this.data[i + 1] = this.data[i];
      }
      this.data[0] = element;
      return this.length += 1;
    }
  }

  map(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      copy.data[prop] = func(this.data[prop]);
      copy.length++;
    }
    return copy;
  }

  filter(func) {
    const filteredArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      if (func(this.data[i], i, this)) {
        filteredArray.push(this.data[i]);
      }
    }
    return filteredArray;
  }

  join(separator = ",") {
    let joined = "";
    for (let prop in this.data) {
      prop = Number(prop);
      if (prop === 0) {
        joined += this.data[prop] + separator;
      }
      else if (prop === this.length - 1) {
        joined += this.data[prop];
      } else {
        joined += this.data[prop] + separator;
      }
    }
    return joined;
  }
}

Fabrizio López

student

Tardé 2 horas antes de poder empezar a resolver el reto, buscando en internet alguna forma para poder acceder a las propiedades de un objeto sin tener que usar los corchetes (al menos que se use el operador punto "." pero en este caso no sirve). Así que no se rompan la cabeza, si que se pueden utilizar los corchetes, en la propia solución que dan los utilizan. Ahora si, mi respuesta: . . . . . . . . . . . . . .

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let filteredData = new MyArray;
    for (let prop in this.data) {
      filteredData.push(func(this.data[prop]));
    }

    return filteredData;
  }

  filter(func) {
    let filteredData = new MyArray;
    for (let prop in this.data) {
      if (func(this.data[prop])) filteredData.push(this.data[prop]);
    }

    return filteredData;
  }

  push(item) {
    this.data[this.length] = item;
    return ++this.length;
  }

  pop() {
    const deletedItem = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deletedItem;
  }

  join(character = ",") {
    let newData = "";
    for (let prop in this.data) {
      newData += this.data[prop];
      newData += character;
    }
    newData = newData.slice(0, newData.length - character.length);
    return newData;
  }

  shift() {
    if (this.length === 0) return undefined;
    let newArray = {};
    const deletedItem = this.data[0];
    for (let i = 1; i < this.length; i++){
      newArray[i - 1] = this.data[i];
    }
    this.length--;
    this.data = newArray;
    return deletedItem;
  }

  unshift(item) {
    if (typeof item === "undefined") return undefined;
    let newArray = {};
    let newLength = 0;
    if (item instanceof MyArray) {
      for (let i = 0; i < item.length; i++, newLength++) {
        newArray[i] = item[i];
      }
    }
    else {
      newArray[0] = item;
      newLength++
    }
    
    for (let prop in this.data) {
      newArray[newLength++] = this.data[prop];
    }

    this.data = newArray;
    this.length = newLength;

    return newLength;

  }
}

Pablo Pincay Alvarez

student

. . . SPOILERS . .

. .

. . . .

. . . . . .

. . . . .

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    let newData = new MyArray
    for (let item in this.data) {
      newData.data[item] = func(this.data[item])
      newData.length++
    }
    return newData
  }

  filter(func) {
    let newData = new MyArray
    let newLength = 0
    for (const item in this.data) {
      if (func(this.data[item])) {
        newData.data[newLength] = this.data[item]
        newLength++
      }
    }
    newData.length = newLength
    return newData
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.length
  }

  pop() {
    if (this.data[0]) {
      const deleted = this.data[this.length - 1]
      delete this.data[this.length - 1]
      this.length--
      return deleted
    }
  }


  join(character = ",") {
    let joinList = ''
    for (let i = 0; i < this.length; i++) {
      if (i !== this.length - 1) {
        joinList += `${this.data[i]}${character}`
      } else {
        joinList += this.data[i]
      }
    }
    return joinList
  }

  shift() {
    const deleted = this.data[0]
    delete this.data[0]
    this.length--
    for (let i = 0; i < this.length; i++) {
      this.data[i] = this.data[i + 1]
    }
    delete this.data[this.length]
    return deleted
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    }
    const newData = {}
    newData[0] = item
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i]
    }
    this.data = newData
    this.length++
    return this.length
  }
}

Alfonso Neil Jiménez Casallas

student

antes de resolver estos desafíos sobre estructuras de datos en JavaScript, les recomiendo revisar el curso de Diego De Granda

Angel Javier Sanchez Tenjo

student

Hola, comparto la solución, me guie mucho de mis compañeros.

✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    const copyArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const item = this.data[i];
      copyArray.push(func(item));
    }

    return copyArray;
  }

  filter(func) {
    const copyArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const item = this.data[i];
      if (func(item)) {
        copyArray.push(item);
      }
    }

    return copyArray;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
  }

  pop() {
    this.length--;
    const deletedItem = this.data[this.length];

    delete this.data[this.length];

    return deletedItem;
  }

  join(character = ",") {
    let result = this.data[0];

    for (let i = 1; i < this.length; i++) {
      result = `${result}${character}${this.data[i]}`;
    }

    return result;
  }

  shift() {
    const deletedItem = this.data[0];

    delete this.data[0];

    this.length--;
    for (let i = 0; i < this.length; i++) {
      const nextItem = this.data[i + 1];
      this.data[i] = nextItem;
    }

    delete this.data[this.length];

    return deletedItem;
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length;
    }

    if (this.length === 0) {
      this.data[0] = item;
      this.length++;
      return this.length;
    }

    for (let i = this.length; i > 0; i--) {
      this.data[i] = this.data[i - 1];
    }

    this.data[0] = item;

    this.length++;
    return this.length;
  }
}

Gilberto Espinoza Maciel

student

Lloré logrando este reto, no porque fuera más difícil si no por los días en los que me tocó resolverlo. Plenas "vacaciones de SS" y ando medio roto y necesite volver a herramientas para el desarrollo personal . . . https://platzi.com/cursos/crecimiento-personal/ . . . . .

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {}
    this.length = 0
  }

  map(func) {
    // Tu código aquí 👈
    let result = new MyArray()
    for (let i = 0; i < this.length; i++){
      result.push(func(this.data[i]))
    }
    return result
  }

  filter(func) {
    // Tu código aquí 👈
    let result = new MyArray()
    for (let i = 0; i < this.length; i++){
      if (func(this.data[i])) {
        result.push(this.data[i])
      }
    }
    return result
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item
    this.length++
  }

  pop() {
    // Tu código aquí 👈
    this.length--
    let result = this.data[this.length]
    delete this.data[this.length]
    return result
  }

  join(character = ",") {
    // Tu código aquí 👈
    let result = ``
    for (let i = 0; i < this.length; i++){
      result += `${this.data[i]}`
      if (i !== this.length - 1) {
        result += `${character}`
      }
    }
    return result
  }

  shift() {
    let deleted = this.data[0];
    delete this.data[0];
    let copy = { ...this.data }, contador = 0;
    this.data = {};
    for (let prop in copy) {
      this.data[contador] = copy[prop];
      contador++;
    }
    this.length -= 1;
    return deleted;
  }

  unshift(item) {
    if (item != null) {
      let copy = { ...this.data };
      this.data = {};
      this.data[0] = item;
      for (let prop in copy) {
        this.data[this.length] = copy[prop];
      }
      return this.length += 1;
    }
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }
  map(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      copy.data[prop] = func(this.data[prop]);
      copy.length++;
    }
    return copy;
  }
  filter(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      if (func(this.data[prop])) {
        copy.data[copy.length] = this.data[prop];
        copy.length += 1;
      }
    }
    return copy;
  }
  push(item) {
    if (this.length === 0) {
      this.data[this.length] = item;
    } else {
      this.data[this.length] = item;
    }
    return this.length += 1;
  }
  pop() {
    let deleted = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length -= 1;
    return deleted;
  }
  join(character = ",") {
    let joined = "";
    for (let prop in this.data) {
      prop = Number(prop);
      if (prop === 0) {
        joined += this.data[prop] + character;
      }
      else if (prop === this.length - 1) {
        joined += this.data[prop];
      } else {
        joined += this.data[prop] + character;
      }
    }
    return joined;
  }
  shift() {
    let deleted = this.data[0];
    delete this.data[0];
    let copy = { ...this.data }, contador = 0;
    this.data = {};
    for (let prop in copy) {
      this.data[contador] = copy[prop];
      contador++;
    }
    this.length -= 1;
    return deleted;
  }
  unshift(item) {
    if (item != null) {
      let copy = { ...this.data };
      this.data = {};
      this.data[0] = item;
      for (let prop in copy) {
        this.data[this.length] = copy[prop];
      }
      return this.length += 1;
    }
  }
}

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    const mutatedData = new MyArray()
    for (let key in this.data) {
      newData.push(func(this.data[key]))
    }
    return mutatedData
  }

  filter(func) {
    const filteredData = new MyArray()
    for (let key in this.data) {
      if (func(this.data[key])) {
        filteredData.push(this.data[key])
      }
    }
    return filteredData
  }

  push(item) {
    this.data[this.length] = item
    this.length++
    return this.length
  }

  pop() {
    if (this.data['0']) {
      this.length--
      const deletedItem = this.data[this.length]
      delete this.data[this.length]
      return deletedItem
    }
  }

  join(character = ",") {
    let joinedValues = ''
    for (let key in this.data) {
      if (Number(key) === this.length - 1) {
        joinedValues += this.data[key]
      } else {
        joinedValues += this.data[key] + character
      }
    }
    return joinedValues
  }

  shift() {
    const deletedItem = this.data['0']
    delete this.data['0']
    const newData = {}
    this.length--
    for (let i = 0; i < this.length; i++) {
      newData[i] = this.data[i + 1]
    }
    this.data = newData
    return deletedItem
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    }
    const newData = {}
    newData['0'] = item
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i]
    }
    this.data = newData
    this.length++
    return this.length
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let newArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const element = this.data[i];
      newArray.push(func(element));
    }
    return newArray;
  }

  filter(func) {
    let newArray = new MyArray();
    this.map((element) => {
      if (func(element)) {
        newArray.push(element);
      }
    });
    return newArray;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.data;
  }

  pop() {
    let deletedItem = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deletedItem;
  }

  join(character = ",") {
    let myString = '';
    for (let i = 0; i < this.length; i++) {
      myString += this.data[i] + character;
    }
    return myString.slice(0, -1);
  }

  shift() {
    let deletedItem = this.data[0];
    delete this.data[0];
    for (let i = 0; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    this.pop();
    return deletedItem;
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    } else {
      this.data[0] = item;
      for (let i = 0; i < this.length; i++) {
        this.data[i + 1] = this.data[i];
      }
      this.length++;
      return this.length;
    }
  }
}

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    let newData = new MyArray
    for (let item in this.data) {
      newData.data[item] = func(this.data[item])
      newData.length++
    }
    return newData
  }

  filter(func) {
    let filteredData = new MyArray
    for (let item in this.data) {
      if (func(this.data[item])) {
        filteredData.data[filteredData.length] = this.data[item]
        filteredData.length++
      }
    }
    return filteredData
  }

  push(item) {
    this.data[this.length] = item
    this.length++
    return this.length
  }

  pop() {
    const deleted = this.data[this.length - 1]
    delete this.data[this.length - 1]
    this.length--
    return deleted
  }

  join(character = ",") {
    let str = ""
    for (let i = 0; i < this.length; i++) {
      str += (i < this.length - 1) ? this.data[i] + character : this.data[i]
    }
    return str
  }

  shift() {
    const deleted = this.data[0]
    delete this.data[0]
    this.length--
    for (let i = 0; i < this.length; i++) {
      this.data[i] = this.data[i + 1]
    }
    delete this.data[this.length]
    return deleted
  }

  unshift(item) {
    if (!item && item !== 0) { return this.length }
    for (let i = this.length; i >= 0; i--) {
      this.data[i] = this.data[i - 1]
    }
    this.data[0] = item
    this.length++
    console.log(this)
    return this.length
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let mapArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      mapArray.data[i] = func(this.data[i]);
    }
    mapArray.length = this.length;
    return mapArray;
  }

  filter(func) {
    let filteredArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      if (func(this.data[i])) filteredArray.push(this.data[i]);
    }
    return filteredArray;
  }

  push(item) {
    this.data[this.length] = item;
    return ++this.length;
  }

  pop() {
    let temp = this.data[--this.length];
    delete this.data[this.length];
    return temp;
  }

  join(character = ",") {
    let string = "";
    for (let i = 0; i < this.length; i++) {
      string += this.data[i] + character;
    }
    return string.slice(0, -character.length);
  }

  shift() {
    let newData = {};
    let temp = this.data[0];
    for (let i = 0; i < this.length; i++) {
      newData[i] = this.data[i + 1];
    }
    delete this.data;
    this.data = newData;
    this.length--;
    return temp;
  }

  unshift(item) {
    if (item == null) return this.length;

    let newData = { 0: item };
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i];
    }
    delete this.data;
    this.data = newData;
    return ++this.length;
  }
}

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {};
    this.length = 0;
  }

  map(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.length; i++){
      newArray.push(func(this.data[i]));
    }
    return newArray;
  }

  filter(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.length; i++){
      if (func(this.data[i])) {
        newArray.push(this.data[i]);
      }
    }
    return newArray;
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item;
    this.length += 1;
    return item;
  }

  pop() {
    // Tu código aquí 👈
    if (this.length) {
      const last = this.data[this.length-1]
      delete this.data[this.length - 1];
      this.length -= 1;
      return last;
    }
    return undefined;
    
  }

  join(character = ",") {
    // Tu código aquí 👈
    let str = "";
    for (let i = 0;i<this.length-1; i++){
      str += this.data[i] + character;
    }
    str += this.data[this.length - 1];
    return str;

  }

  shift() {
    // Tu código aquí 👈
    const first = this.data[0];
    for (let i = 1; i < this.length; i++){
      this.data[i-1] = this.data[i]
    }
    delete this.data[this.length - 1];
    this.length -= 1;
    return first;
  }

  unshift(item) {
    // Tu código aquí 👈
    if (item !==undefined) {
      for (let i = this.length - 1; i >= 0; i--) {
        this.data[i + 1] = this.data[i];
      }
      this.data[0] = item;
      this.length += 1;
      return this.length;
    }
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let temp = {};
    for (let i = 0; i < this.length; i++) { 
      temp[i] = func(this.data[i]);
    }
    let newArray = new MyArray();
    newArray.data = temp;
    newArray.length = this.length;
    return newArray;
  }

  filter(func) {
    let temp = {};
    let contador = 0;
    for (let i = 0; i < this.length; i++) { 
      if (func(this.data[i]) === true) { 
        temp[contador] = this.data[i];
        contador += 1;
      }
    }
    let newArray = new MyArray();
    newArray.data = temp;
    newArray.length = contador;
    return newArray;
  }

  push(item) {
    let resultado = Number(item);
    if (resultado == NaN) { 
      this.data[this.length] = item;
    }
    else {
      this.data[this.length] = resultado;
    }
    this.length += 1;
  }

  pop() {
    let eliminado = {};
    eliminado.length = this.length;
    this.length -= 1;
    let temp = {};
    for (let i = 0; i < this.length; i++) { 
      temp[i] = this.data[i];
    }
    this.data = temp;
    return eliminado.length;
  }

  join(character = ",") {
    let cadena = "";
    for (let i = 0; i < this.length; i++) { 
      cadena += this.data[i] + character;
    }
    return cadena.trim().substring(0, (cadena.length-character.length));
  }

  shift() {
    let eliminado = {};
    eliminado = this.data[0];
    let temp = {};
    let contador = 0;
    for (let i = 1; i < this.length; i++) { 
      temp[contador] = this.data[i];
      contador += 1;
    }
    this.length = Object.keys(temp).length;
    this.data = temp;
    return eliminado;
  }

  unshift(item) {
    if (item !== undefined ) { 
      let temp = {};
      let resultado = Number(item);
      if (resultado == NaN) {
        temp[0] = item;
      }
      else {
        temp[0] = Number(item);
      }
      for (let i = 0; i < this.length; i++) {
        temp[i + 1] = this.data[i];
      }
      this.data = temp;
      this.length = Object.keys(temp).length;
      return this.length;
    }
  }
}

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.lenght = 0;
    this.data = {};
  }

  map(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.lenght; i++) {
      const element = this.data[i];
      newArray.push(func(element));
    }
    return newArray;
  }

  filter(func) {
    // Tu código aquí 👈
    const newArray = new MyArray();
    for (let i = 0; i < this.lenght; i++) {
      const element = this.data[i];
      if (func(element)) {
        newArray.push(element);
      }
    }
    return newArray;
  }

  push(item) {
    this.data[this.lenght] = item;
    this.lenght++;
  }

  pop() {
    // Tu código aquí 👈
    this.lenght--;
    const deletedItem = this.data[this.lenght];
    delete this.data[this.lenght];
    return deletedItem;
  }

  join(character = ",") {
    // Tu código aquí 👈
    let result = "";
    for (let i = 0; i < this.lenght; i++) {
      result += this.data[i];
      if (i < this.lenght - 1) {
        result += character;
      }
    }
    return result;
  }

  shift() {
    // Tu código aquí 👈
    const deletedItem = this.data[0];
    delete this.data[0];
    this.lenght--;
    for (let i = 0; i < this.length; i++) {
      const nextElement = this.data[i + 1];
      this.data[i] = nextElement;
    }
    delete this.data[this.lenght];

    return deletedItem;
  }

  unshift(item) {
    // Tu código aquí 👈
    if (!item && item !== 0) {
      return this.lenght;
    }

    if (this.item == 0) {
      this.data[0] = item;
      this.lenght++;
      return this.lenght;
    }

    for (let i = this.length; i > 0; i--) {
      this.data[i] = this.data[i - 1];
    }

    this.data[0] = item;

    this.length++;
    return this.length;
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    const mapData = new MyArray();
    for (let index in this.data) {
      mapData.push(func(this.data[index]));
    }
    return mapData;
  }

  filter(func) {
    const filterData = new MyArray();
    for (let index in this.data) {
      if (func(this.data[index])) {
        filterData.push(this.data[index]);
      }

    }
    return filterData;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.length;
  }

  pop() {
    if (this.length > 0) {
      this.length--;
      const item = this.data[this.length];
      delete this.data[this.length];
      return item;
    }
  }

  join(character = ",") {
    let values;
    for (let index in this.data) {
      if (values) {
        values += character + this.data[index];
      } else {
        values = this.data[index];
      }
    }
    return values;
  }

  shift() {
    const item = this.data['0'];
    delete this.data['0'];
    this.length = 0;
    const newData = {};
    for (let index in this.data) {
      newData[this.length] = this.data[index];
      this.length++;
    }
    this.data = newData;

    return item;
  }

  unshift(...items) {
    if (items) {

      this.length = 0;
      const newData = {};
      for (let item of items) {
        newData[this.length] = item;
        this.length++;
      }

      for (let index in this.data) {
        newData[this.length] = this.data[index];
        this.length++;
      }
      this.data = newData;
    }

    console.log(this.length);
    return this.length;

  }
}

class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {};
    this.length = 0;
  }

  map(func) {
    // Tu código aquí 👈
    if (!typeof func === "function") throw TypeError("Not a function");

    let A = new MyArray();
    let k = 0;

    while (k < this.length) {
      let Pk = k;
      let kPresent = this.data[Pk];

      if (kPresent) {
        let kValue = this.data[Pk];
        let mappedValue = func(kValue);
        A.push(mappedValue);
      }
      k++;
    }
    return A;
  }

  filter(func) {
    // Tu código aquí 👈
    if (!typeof func === "function") throw TypeError("Not a function");
    let A = new MyArray();
    let k = 0;

    while (k < this.length) {
      let Pk = k;
      let kPresent = this.data[Pk];

      if (kPresent) {
        let kValue = this.data[Pk];
        let selected = Boolean(func(kValue));
        if (selected) {
          A.push(kValue);
        }
      }
      k++;
    }
    return A;
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item;
    this.length++;
    return this.data[this.length - 1];
  }

  pop() {
    // Tu código aquí 👈
    if (this.length === 0) return undefined;

    const deleted = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deleted;
  }

  join(character = ",") {
    // Tu código aquí 👈
    if (this.length === 0) return "";

    let R = "";
    let k = 0;
    while (k < this.length) {
      if (k > 0) R += character;

      let element = this.data[k];

      let next =
        element === undefined || element === null ? "" : element.toString();

      R += next;

      k++;
    }
    return R;
  }

  shift() {
    // Tu código aquí 👈
    if (this.length === 0) return undefined;

    let first = this.data[0];
    let k = 1;

    while (k < this.length) {
      let from = k;
      let to = k - 1;
      let fromPresent = this.data[from];
      if (fromPresent) {
        let fromVal = this.data[from];
        this.data[to] = fromVal;
      } else {
        delete this.data[to];
      }
      k++;
    }

    delete this.data[this.length - 1];
    this.length--;
    return first;
  }

  unshift(item) {
    // Tu código aquí 👈
    let argCount = arguments.length;

    if (argCount > 0) {
      if (argCount >= 2 ** 53) throw TypeError("Tooooo many arguments");
      let k = this.length;

      while (k > 0) {
        let from = k - 1;
        let to = k + argCount - 1;
        let fromPresent = this.data[from];
        if (fromPresent) {
          let fromValue = this.data[from];
          this.data[to] = fromValue;
        } else {
          delete this.data[to];
        }
        k--;
      }

      let j = 0;
      for (let i of arguments) {
        this.data[j] = i;
        j++;
      }
    }
    this.length += argCount;
    return this.length;
  }
}

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }

  push(element) {
    this.data[this.length] = element;
    this.length++;
  }

  pop() {
    if (this.length === 0) return undefined;
    const lastElement = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return lastElement;
  }

  shift() {
    if (this.length === 0) return undefined;
    const firstElement = this.data[0];
    for (let i = 0; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1];
    this.length--;
    return firstElement;
  }

  unshift(element) {
    if (element != null) {
      for (let i = this.length - 1; i >= 0; i--) {
        this.data[i + 1] = this.data[i];
      }
      this.data[0] = element;
      return this.length += 1;
    }
  }

  map(func) {
    let copy = new MyArray();
    for (let prop in this.data) {
      copy.data[prop] = func(this.data[prop]);
      copy.length++;
    }
    return copy;
  }

  filter(func) {
    const filteredArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      if (func(this.data[i], i, this)) {
        filteredArray.push(this.data[i]);
      }
    }
    return filteredArray;
  }

  join(separator = ",") {
    let joined = "";
    for (let prop in this.data) {
      prop = Number(prop);
      if (prop === 0) {
        joined += this.data[prop] + separator;
      }
      else if (prop === this.length - 1) {
        joined += this.data[prop];
      } else {
        joined += this.data[prop] + separator;
      }
    }
    return joined;
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    let filteredData = new MyArray;
    for (let prop in this.data) {
      filteredData.push(func(this.data[prop]));
    }

    return filteredData;
  }

  filter(func) {
    let filteredData = new MyArray;
    for (let prop in this.data) {
      if (func(this.data[prop])) filteredData.push(this.data[prop]);
    }

    return filteredData;
  }

  push(item) {
    this.data[this.length] = item;
    return ++this.length;
  }

  pop() {
    const deletedItem = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return deletedItem;
  }

  join(character = ",") {
    let newData = "";
    for (let prop in this.data) {
      newData += this.data[prop];
      newData += character;
    }
    newData = newData.slice(0, newData.length - character.length);
    return newData;
  }

  shift() {
    if (this.length === 0) return undefined;
    let newArray = {};
    const deletedItem = this.data[0];
    for (let i = 1; i < this.length; i++){
      newArray[i - 1] = this.data[i];
    }
    this.length--;
    this.data = newArray;
    return deletedItem;
  }

  unshift(item) {
    if (typeof item === "undefined") return undefined;
    let newArray = {};
    let newLength = 0;
    if (item instanceof MyArray) {
      for (let i = 0; i < item.length; i++, newLength++) {
        newArray[i] = item[i];
      }
    }
    else {
      newArray[0] = item;
      newLength++
    }
    
    for (let prop in this.data) {
      newArray[newLength++] = this.data[prop];
    }

    this.data = newArray;
    this.length = newLength;

    return newLength;

  }
}

export class MyArray {
  constructor() {
    this.data = {}
    this.length = 0
  }

  map(func) {
    let newData = new MyArray
    for (let item in this.data) {
      newData.data[item] = func(this.data[item])
      newData.length++
    }
    return newData
  }

  filter(func) {
    let newData = new MyArray
    let newLength = 0
    for (const item in this.data) {
      if (func(this.data[item])) {
        newData.data[newLength] = this.data[item]
        newLength++
      }
    }
    newData.length = newLength
    return newData
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.length
  }

  pop() {
    if (this.data[0]) {
      const deleted = this.data[this.length - 1]
      delete this.data[this.length - 1]
      this.length--
      return deleted
    }
  }


  join(character = ",") {
    let joinList = ''
    for (let i = 0; i < this.length; i++) {
      if (i !== this.length - 1) {
        joinList += `${this.data[i]}${character}`
      } else {
        joinList += this.data[i]
      }
    }
    return joinList
  }

  shift() {
    const deleted = this.data[0]
    delete this.data[0]
    this.length--
    for (let i = 0; i < this.length; i++) {
      this.data[i] = this.data[i + 1]
    }
    delete this.data[this.length]
    return deleted
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length
    }
    const newData = {}
    newData[0] = item
    for (let i = 0; i < this.length; i++) {
      newData[i + 1] = this.data[i]
    }
    this.data = newData
    this.length++
    return this.length
  }
}

export class MyArray {
  constructor() {
    this.data = {};
    this.length = 0;
  }

  map(func) {
    const copyArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const item = this.data[i];
      copyArray.push(func(item));
    }

    return copyArray;
  }

  filter(func) {
    const copyArray = new MyArray();
    for (let i = 0; i < this.length; i++) {
      const item = this.data[i];
      if (func(item)) {
        copyArray.push(item);
      }
    }

    return copyArray;
  }

  push(item) {
    this.data[this.length] = item;
    this.length++;
  }

  pop() {
    this.length--;
    const deletedItem = this.data[this.length];

    delete this.data[this.length];

    return deletedItem;
  }

  join(character = ",") {
    let result = this.data[0];

    for (let i = 1; i < this.length; i++) {
      result = `${result}${character}${this.data[i]}`;
    }

    return result;
  }

  shift() {
    const deletedItem = this.data[0];

    delete this.data[0];

    this.length--;
    for (let i = 0; i < this.length; i++) {
      const nextItem = this.data[i + 1];
      this.data[i] = nextItem;
    }

    delete this.data[this.length];

    return deletedItem;
  }

  unshift(item) {
    if (!item && item !== 0) {
      return this.length;
    }

    if (this.length === 0) {
      this.data[0] = item;
      this.length++;
      return this.length;
    }

    for (let i = this.length; i > 0; i--) {
      this.data[i] = this.data[i - 1];
    }

    this.data[0] = item;

    this.length++;
    return this.length;
  }
}

export class MyArray {
  constructor() {
    // Tu código aquí 👈
    this.data = {}
    this.length = 0
  }

  map(func) {
    // Tu código aquí 👈
    let result = new MyArray()
    for (let i = 0; i < this.length; i++){
      result.push(func(this.data[i]))
    }
    return result
  }

  filter(func) {
    // Tu código aquí 👈
    let result = new MyArray()
    for (let i = 0; i < this.length; i++){
      if (func(this.data[i])) {
        result.push(this.data[i])
      }
    }
    return result
  }

  push(item) {
    // Tu código aquí 👈
    this.data[this.length] = item
    this.length++
  }

  pop() {
    // Tu código aquí 👈
    this.length--
    let result = this.data[this.length]
    delete this.data[this.length]
    return result
  }

  join(character = ",") {
    // Tu código aquí 👈
    let result = ``
    for (let i = 0; i < this.length; i++){
      result += `${this.data[i]}`
      if (i !== this.length - 1) {
        result += `${character}`
      }
    }
    return result
  }

  shift() {
    let deleted = this.data[0];
    delete this.data[0];
    let copy = { ...this.data }, contador = 0;
    this.data = {};
    for (let prop in copy) {
      this.data[contador] = copy[prop];
      contador++;
    }
    this.length -= 1;
    return deleted;
  }

  unshift(item) {
    if (item != null) {
      let copy = { ...this.data };
      this.data = {};
      this.data[0] = item;
      for (let prop in copy) {
        this.data[this.length] = copy[prop];
      }
      return this.length += 1;
    }
  }
}

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

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

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios

Día 19