Contenido del curso
Playground - Crea tu propia implementación de un array
Santiago Arias
Estudiante
Leonardo de los angeles Espinoza Hernandez
Estudiante
HERNANDO RAMIREZ
Estudiante
Osvaldo Martinez Guillen
Estudiante
Santiago Andres Alvarez Cuadros
Estudiante
Carina Payleman
Estudiante
David Esteban Giraldo Duque
EstudianteHERNANDO RAMIREZ
Estudiante
Gabriel Luna
Estudiante
Joan Alexander Valerio Rodríguez
Estudiante
Rubén Hernández Hernández
Estudiante
Diego Herrera Prado
Estudiante
Ulises Serrano Pérez
Estudiante
David Ochoa
Estudiante
Victor Hernandez
Estudiante
Elias Rayas Gonzalez
Estudiante
Alexis Corrales
EstudianteFabrizio López
Estudiante
Pablo Pincay Alvarez
Estudiante
Alfonso Neil Jiménez Casallas
Estudiante
Angel Javier Sanchez Tenjo
Estudiante
Gilberto Espinoza Maciel
EstudianteEn 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.
Me llevo este feedback para ponerlo en la guía, mil gracias por tu comentario Santiago 💪
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
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; } } }
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 modificadopop devuelve el elemento que fue eliminadopush, shift y unshift devuelven la longitud del arreglo ya mutadojoin 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 } }
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; } } }
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 } }
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?
¿Cómo se entiende la guía cuando dice "No podrás usar los corchetes [], aquí entenderás porque los arrays se consideran objetos"?
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.
💚 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; } }
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; } } }
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; } } }
🛡️🛡️🛡️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; } }
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; } }
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; } }
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; } }
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; } }
. . . 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 } }
antes de resolver estos desafíos sobre estructuras de datos en JavaScript, les recomiendo revisar el curso de Diego De Granda
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; } }
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; } } }