Contenido del curso
Playground - Task planner
Leonardo de los angeles Espinoza Hernandez
Estudiante
Daniel Sebastián Rodríguez
Estudiante
Elian Sumalave
Estudiante
Salvador Gonzalez Blanco
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Harold Zurita Simon
Estudiante
Isabelle de Souza
Estudiante
Santiago Sabogal
EstudianteDaniel Sebastián Rodríguez
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Gabriel Luna
Estudiante
Daniel André Amaya López
Estudiante
Andres Roca
Estudiante
Carina Payleman
Estudiante
Jhony Ardila
Estudiante
Joan Alexander Valerio Rodríguez
Estudiante
Stevenson Grajales
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Julian Roa Villamil
EstudianteJulian Roa Villamil
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Marco Antonio Urquidi Espada
EstudianteLeonardo de los angeles Espinoza Hernandez
Estudiante
Gustavo Alonso Aguilar Acuña
EstudianteLeonardo de los angeles Espinoza Hernandez
EstudianteGustavo Alonso Aguilar Acuña
Estudiante
Fernando Velasco
Estudiante
Ricardo Alfonso Chavez Vilcapoma
Estudiante
IRIDIAN GUADALUPE CARRERA MONDRAGÓN
Estudiante
Francisco Javier Solis Martinez
Estudiante
David Ochoa
Estudiante
Harrison Steve Pinzón Neira
Estudiante🛡️🛡️Escudo anti-spoiler🛡️🛡️
/ Quiero darte la bienvenida a tu segundo checkpoint, este desafío que incluye un grado más alto de dificultad. Al ser una semana relativamente teórica hemos preparado un ejercicio no tan difícil 😉 / Esperamos que lo disfrutes y pongas a prueba tus conocimientos, sin más, te dejo con un gif aleatorio para después explicarte la solución propuesta ¡Buena suerte! / !bird dancing / Esta explicación va a llevar un rato, espero no te pierdas
export function createTaskPlanner() { // Empezamos con un array vacío // aquí almacenaremos las tareas let tasks = []; // retornamos las funciones // que servirán para manipular el array return { // La función de agregar tareas debe recibir una tarea addTask(task) { // Por lógica al añadir una nueva tarea inicia sin estar completada task.completed = false; // Una vez modificada la enviamos al array tasks.push(task); }, // Ahora la función para remover tareas removeTask(value) { // Dependiendo si el valor es un número o un string if (typeof value === "number") { // Si es un número, filtramos todas las tareas que no tengan el mismo valor // y luego lo reasignamos al array de tareas tasks = tasks.filter((task) => task.id !== value); } else { // En caso de ser un string, hacemos lo mismo pero con la propiedad de .name tasks = tasks.filter((task) => task.name !== value); } }, // Para obtener las tareas simplemente las retornamos getTasks() { return tasks; }, // Para obtener las tareas pendientes o completadas simplemente las filtramos // y retornamos el resultado getPendingTasks() { return tasks.filter((task) => !task.completed); }, getCompletedTasks() { return tasks.filter((task) => task.completed); }, // Para marcar una tarea dependiendo el valor recibido markTaskAsCompleted(value) { // primero declaramos la variable de index // la cual tendrá el indice de la posición del elemento let index; // buscamos el indice dependiendo el valor if (typeof value === "number") { // buscamos por index dependiendo si es por id index = tasks.findIndex((task) => task.id === value); } else { // O por name index = tasks.findIndex((task) => task.name === value); } // Al final con ese indice modificamos la propiedad de completed a true tasks[index].completed = true; }, getSortedTasksByPriority() { // Para ordenar las tareas sin modificar el array original // solamente hacemos una copia del array y ejecutamos sort sobre este const sortedTasks = [...tasks].sort((a, b) => a.priority - b.priority); // Al final lo retornamos return sortedTasks; }, filterTasksByTag(tag) { // Filtramos las tareas que incluyan cierto tag return tasks.filter((task) => task.tags.includes(tag)); }, updateTask(taskId, updates) { // obtenemos el id como lo hicimos previamente const index = tasks.findIndex((task) => task.id === taskId); // agregamos las propiedades extras destructurando ambos objetos tasks[index] = { ...tasks[index], ...updates }; }, }; }
Un checkpoint un tanto más amplio para seguir practicando 💪 ¿Y tu? ¿Cómo lo hiciste?
Hola, al menos en mi caso nunca recibí un typeof number en value, ya que el input es de type="text"
**En mi caso **no me funciona el tremoveTask de tu código
Yo lo que hice fue una comparación no estricta con ['name'] y ['id']. Con el primero que coincidía lo eliminaba. Así me funcionó
También noté que cada vez que agrego, elimino o completo una tarea, se restablecen todas y se marcan como no completadas.
En mi caso lo solucioné con esto
addTask: function (task) { if (task['completed'] === undefined) { task['completed'] = false } tareas.push(task) },
Yo hice así mi método removeTask:
removeTask: function (value) { tasks = tasks.filter(a => a.id !== parseInt(value) && a.name !== value) },
Sentí que ameritaba subirlo a gitlab https://gitlab.com/sgb004/task-planner-js/-/blob/main/task-planner.js https://gitlab.com/sgb004/task-planner-js/
Tu solución amerita que la presumas en alguna red social 💪
Me encantó
Solución… 😄 . Para comenzar, creamos un array de tareas vacía. Posteriormente realizamos las función correspondientes del reto. . En 'addTask' simplemente agregamos la propiedad completed al hacer: .
task.completed = false;
. Puesto que si la propiedad no existe, al asignarla de esa manera se le añade dinámicamente. Luego añadimos la tarea al array de tarea. . En 'removeTask' utilizamos la función splice: .
tasks.splice( tasks.findIndex((task) => task.id == value || task.name === value), 1);
. Esta función recibe 2 parámetro, la primera es la posición desde donde queremos eliminar elementos de un array, y la segunda es la cantidad de elementos que queremos eliminar, en este caso 1. . Es por ello que utilizamos la función findIndex() para encontrar la tarea que tenga el value igual al id o al name de la tarea. .
tasks.findIndex((task) => task.id == value || task.name === value), 1);
. 'getTask' solo retorna el array de tareas. 'getPendingTask' y 'getCompletedTask' utilizan la función filter() para devolver las tareas que tengan la propiedad completed en el estado correspondiente. . Para 'markTaskAsCompleted' guardamos en una variable el resultado de buscar la tarea por su id o name mediante la función find(). Si la tarea existe lo marcamos como completado accediendo a la propiedad completed cambiandolo a true. . 'getSortedTasksByPriority' utiliza la función sort() en el cual ordenamos las tareas según su prioridad, de menor a mayor. Es importante hacer una copia del array para no alterar al array original, por lo que utilizamos [...NombreDelArray] para ello. . 'filterTasksByTag(tag)' utiliza filter() donde accedemos a la propiedad tags para encontrar una coincidencia, (siendo tags un array) mediante la función include() . . 'updateTask' actuamos de forma similar a 'markTaskAsCompleted' pero para pasar las propiedades que queremos cambiar 'updates' a la tarea encontrada, debemos utilizar Object.assign(). . Object.assign() tiene 2 parametro, el primero es el objeto al que queremos cambiar sus propiedades, y el segundo son las propiedades que queremos cambiar. . Por ejemplo si update fuera {id: 4, name: "Pedro"} en task o la tarea solo se cambiarían esas propiedades, las demás (priority, tags y completed) no cambian. . Finalmente, retornamos un objeto con el nombre de las funciones implementadas. . Código: .
export function createTaskPlanner() { // Array de todas las tareas let tasks = []; // Añadimos una tarea al array de tareas function addTask(task) { task.completed = false; tasks.push(task); } /* Removemos una tarea a partir del índice del elemento que coincida en name o id con value */ function removeTask(value) { tasks.splice( tasks.findIndex((task) => task.id == value || task.name === value), 1 ); } // Retornamos el array de tareas function getTasks() { return tasks; } /* Filtramos y retornamos las tareas que tengan la propiedad completed false */ function getPendingTasks() { return tasks.filter((task) => !task.completed); } /* Filtramos y retornamos las tareas que tengan la propiedad completed true */ function getCompletedTasks() { return tasks.filter((task) => task.completed); } /* Encontramos la tarea que queremos marcar como competado, si existe la propiedad completed será igual a true */ function markTaskAsCompleted(value) { let task = tasks.find((task) => task.id == value || task.name === value); if (task) { task.completed = true; } } // Ordenamos y retornamos el array de tareas ordenado function getSortedTasksByPriority() { return [...tasks].sort((a, b) => a.priority - b.priority); } // Filtramos las tareas por tag function filterTasksByTag(tag) { return tasks.filter((task) => task.tags.includes(tag)); } /* Actualizamos las propiedades de updates con la tarea que coincida con taskId */ function updateTask(taskId, updates) { let task = tasks.find((task) => task.id == taskId); if (task) { Object.assign(task, updates); } } return { addTask, removeTask, getTasks, getPendingTasks, getCompletedTasks, markTaskAsCompleted, getSortedTasksByPriority, filterTasksByTag, updateTask } }
genial Harold.
Uno difícil, estuvo largo pero interesante. Al momento de hacer la prueba, sortTasksByPriority() es en realidad getSortedTasksByPriority(), ya lo están corrigiendo. . . . . . . . spoilers:
<export function createTaskPlanner() { let taskArray = []; return { addTask: (task) => { task.completed = false, taskArray.push(task) }, removeTask: (value) => {taskArray.forEach((ele, ind) => { if(ele.id === value || ele.name === value){ taskArray.splice(ind, 1) } })}, getTasks: () => {return taskArray}, getPendingTasks: () => { return taskArray.filter((ele) => !ele.completed) }, getCompletedTasks: () => { return taskArray.filter((ele) => ele.completed) }, markTaskAsCompleted: (value) => {taskArray.forEach((ele, ind) => { if(ele.id === value || ele.name === value){ return ele.completed = true } })}, //sortTasksByPriority() getSortedTasksByPriority: () => { const sortedArray = [...taskArray] .sort((a, b) => a.priority - b.priority); return sortedArray }, filterTasksByTag: (tag) => { return taskArray.filter((ele) => ele.tags.includes(tag)) }, updateTask: (taskId, updates) => {taskArray.forEach((ele, ind) => { if(ele.id === taskId){ const newTask = Object.assign({}, ele, updates); taskArray.splice(taskArray[ind], 1, newTask) } })} } }>
Gracias, sin este comentario no me habría dado cuenta, no sabía qué estaba fallando
Ya está corregida la descripción :D
Aquí está mi solución, en este ejercicio aumentó la dificultad, excelente el reto!!! . . . . . . . . . . . . . . . . .
👾 Mi solución
🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧 🚧
export function createTaskPlanner() { // Tu código aquí 👈 let tasksList = [] return { // crear tarea addTask: (task) => { task.completed = false tasksList.push(task) //console.log(task) }, // eliminar tarea removeTask: (value) => { tasksList = tasksList.filter((task) => { if (task.id !== parseInt(value) && task.name !== value) return task console.log(task) }) }, // listar todas las tareas getTasks: () => tasksList, // listar las tareas pendientes getPendingTasks: () => tasksList.filter((task) => !task.completed), // listar las tareas completadas getCompletedTasks: () => tasksList.filter((task) => task.completed), // marcar una tarea como completada markTaskAsCompleted: (value) => { const index = tasksList.findIndex( (task) => task.id === parseInt(value) || task.name === value ) tasksList[index].completed = true console.log(tasksList) }, // listar las tareas por prioridad getSortedTasksByPriority: () => [...tasksList].sort((a, b) => a.priority - b.priority), // filtrar las tareas por etiqueta filterTasksByTag: (tag) => tasksList.filter((task) => task.tags.includes(tag)), // actualizar una tarea updateTask: (taskId, updates) => { tasksList = tasksList.map((task) => { if (task.id !== taskId) return task const taskUpdated = { ...task, ...updates, } console.log(taskUpdated) return taskUpdated }) }, } }
Hola!. Muy buen ejercicio, gracias. Comparto mi solución comentada . . . Antes un par de aportes de mejora: -Creo que las getCompleted y getPending no corren bien en el simulador; traen todo o nada -El mark completed sólo deja marcar una task a la vez -Sería bueno poner explícito el orden del sorting ascendente/descendente porNumero/porDificultad . . .
export function createTaskPlanner() { let tasks = [] return{ // spread el objeto entrante, agrega la key completed y conforma el nuevo objeto addTask(task){tasks.push({...task, completed: false})}, // filtra para True cuando el id o el name NO coinciden removeTask(val){ tasks = tasks.filter(t=> !(val == t.id || val == t.name)); }, getTasks(){ return tasks; }, getPendingTasks(){ return tasks.filter(t=> t.completed == false); }, getCompletedTasks(){ return tasks.filter(t=> t.completed == true); }, // trae el elemento que tiene id o tiene name y le pone true a su 'completed' markTaskAsCompleted(val){ tasks.find(t=> val == t.id || val == t.name).completed = true; }, // reconstruye un arreglo desde el original y lo organiza descendentemente getSortedTasksByPriority(){ return [...tasks].sort((a,b)=>a.priority - b.priority); }, // filtra con True para cuando alguno (some) de los elementos en los tags de la task cumple la condición filterTasksByTag(tag){ return tasks.filter(tk=> tk.tags.some(tg=>tg == tag)); }, // toma la task que coincide con el id. Itera sobre el objeto update y actualiza las propiedades updateTask(taskId, updates){ let task = tasks.find(t=>t.id == taskId); for(let key in updates) task[key] = updates[key]; }, } }
export function createTaskPlanner() { let taskList = []; const addTask = (task) => { task.completed = false; taskList.push(task); } const removeTask = (value) => taskList.splice(taskList.findIndex((task) => task.id == value || task.name === value), 1); const getTasks = () => taskList; const getPendingTasks = () => taskList.filter((task) => !task.completed); const getCompletedTasks = () => taskList.filter((task) => task.completed); const markTaskAsCompleted = (value) => { const i = taskList.findIndex((task) => task.id == value || task.name === value); taskList[i].completed = true; } const getSortedTasksByPriority = () => [...taskList].sort((a, b) => a.priority - b.priority); const filterTasksByTag = (tag) => taskList.filter((task) => task.tags.includes(tag)); const updateTask = (taskId, updates) => { const i = taskList.findIndex((task) => task.id === taskId); taskList[i] = {...taskList[i], ...updates}; } return { addTask, removeTask, getTasks, getPendingTasks, getCompletedTasks, markTaskAsCompleted, getSortedTasksByPriority, filterTasksByTag, updateTask} }
Les comparto la solución usando clases y reutilizando el metodo de buscar clases, tratando de usar RORO
🥵
🥵
🥵
export function createTaskPlanner() { return new TaskPlanner(); } class TaskPlanner { tasks = []; addTask(task = { id, name, priority, tags }) { let newTask = { ...task }; newTask.completed = false; this.tasks.push(newTask); } removeTask(needle) { let task = this.getTasks({ needle }); if (task >= 0) { this.tasks.splice(task,1); } } getTasks(params = { completed: undefined, order: undefined, tag: undefined, needle: undefined }) { switch (true) { case params.completed === true: return this.tasks.filter(task => task.completed); break; case params.order != undefined && params.order != "": let tasksOrdered = [ ...this.tasks ]; return tasksOrdered.sort((a, b) => a[params.order] - b[params.order]) break; case typeof params.tag === "string" && params.tag.length != "": return this.tasks.filter(task => task.tags.some(tag => tag === params.tag) ); break; case typeof params.needle === "number" || (typeof params.needle === "string" && params.needle != ""): return this.tasks.findIndex((value) => { return value.id == params.needle || value.name === params.needle; }); break; default: return this.tasks; break; } } getCompletedTasks() { return this.getTasks({ completed: true }); } getSortedTasksByPriority() { return this.getTasks({ order: "priority" }); } filterTasksByTag(tag) { return this.getTasks({ tag: tag }); } markTaskAsCompleted(needle) { let task = this.getTasks({ needle }); if (task >= 0) { this.tasks[task].completed = true; return this.tasks; } } updateTask(taskId, updates) { let task = this.getTasks({ needle: taskId }); let newTask = { ...this.tasks[task], ...updates }; this.tasks.splice(task, 1, newTask); } }
Hola! No hay posibilidad de guardar el progreso en esos "Playground"? es muy molesto que donde llegue a equivocarme con darle f5, con clickear en volver página o hacer el gesto con el touchpad se borra todo y quedo .-. Y más con un ejercicio largo como este, opté por copiar y pegar el código en otra parte para guardarlo, pero es muy molesto y se me ha perdido el código varias veces, desmotiva un poco hacer el ejercicio con eso
¡Hola @stevenson-grajales!
De entrada mil disculpas por esa mala experiencia, voy a llevar este feedback con el equipo para que en un futuro cercano tengamos esa implementación y no tengas problemas similares 💪
Gracias por hacernos llegar este comentario 💚
Cualquier otro detalle lo puede dejar dentro las clases del curso o llevarlo directamente a nuestro canal oficial de Discord
Un abrazo!
Hola, tengo un problema con la última función, la que actualiza una tarea por el id, la cosa es que no entiendo lo que el error me está tratando de decir, creo que tiene que ver con la forma como viene el nuevo objeto updates, el error es este:
expect(received).toEqual(expected) // deep equality - Expected - 10 + Received + 5 Array [ Object { - "completed": true, - "id": 1, - "name": "Comprar leche", - "notes": "Leche deslactosada", - "place": "supermercado", - "priority": 3, - "tags": Array [ - "shopping", - "home", - ], + "completed": undefined, + "id": undefined, + "name": undefined, + "priority": undefined, + "tags": undefined, }, Object { "completed": true, "id": 2, "name": "Llamar a Juan", "priority": 1, "tags": Array [ "personal", ], }, ]
Mi código es el siguiente:
const updateTask = (taskId, updates) => { console.log(updates); for (let idx = 0; idx < tasks.length; idx++) { //console.log(tasks[idx]); if (tasks[idx].id == taskId) { //console.log(tasks[idx]); tasks[idx].id = updates.id; tasks[idx].name = updates.name; tasks[idx].priority = updates.priority; tasks[idx].tags = updates.tags; tasks[idx].completed = updates.completed; } } //console.log('PT: ',pendingTasks); return tasks; };
me podrían ayudar por favor explicándome el problema que me está arrojando?
ok, viendo el error desde los comentarios, ya con colorsitos y un poco mejor organizado, entiendo que me están pasando un objeto con propiedades extra??
¡Hola!
Lo que pasa es que a la tarea se le está agregando más atributos al objeto por lo que debes asegurarte que estés agregando lo que ya trae consigo la tarea junto con sus actualizaciones
Si necesitas más inspiración te dejo aquí la grabación con nicobytes que resuelve este mismo problema 💪
Vaya iba muy bien hasta el dia 9, de aqui me perdi espectacularmente, alguien podria decirme donde aprendo este uso de codigo y demas, estoy siguiendo la ruta de aprendizaje de JS y no vi nada parecido.. gracias
¡Hola Marco!
Hay algún aspecto en particular el cual te haga sentir complejo este ejercicio? De esta manera te puedo recomendar una serie de cursos que te ayudarán a entenderlo y pasar el desafío más fácil 💪
Alguien sabe cual es el requerimiento que me falta? porque ya agrego el atributo completed al crear una tarea... Por ende, no deberían haber tareas sin el atributo completed definido
Esa prueba tiene que ver con el método
updateTask(taskId, updates)
Puedes compartirnos tu código para darle una revisada por aquí o por discord 💪
Mil gracias! Ya pude solucionar el reto... solo por los memes, muestro como lo estaba haciendo antes x"D
Tuve que verme la ultima clase de manipulacion de arrays para ver como era~
updateTask: function(taskId, updates){ tareas.forEach(function (tarea){ if(tarea.id == taskId){ updates.id?tarea.id=updates.id:tarea.id; updates.name?tarea.name=updates.name:tarea.name; updates.priority?tarea.priority=updates.priority:tarea.priority; updates.tags?tarea.tags=updates.tags:tarea.tags; updates.completed?tarea.completed=updates.completed:tareascompleted; } }) }
export function createTaskPlanner() { let tasks = []; return { addTask: task => { task.completed = false; tasks.push(task); }, removeTask: value => { tasks.splice(tasks.findIndex(task => task.id === value || task.name === value), 1); }, getTasks: () => tasks, getPendingTasks: () => { tasks.filter(task => !task.completed); }, getCompletedTasks: () => { return tasks.filter(task => task.completed); }, markTaskAsCompleted: value => { tasks.find(task => task.id === value || task.name === value).completed = true; }, getSortedTasksByPriority: () => { return [...tasks].sort((a, b) => a.priority - b.priority); }, filterTasksByTag: tag => { return tasks.filter(task => task.tags.includes(tag)); }, updateTask: (taskId, updates) => { let taskToUpdate = tasks.find(task => task.id === taskId); if(taskToUpdate) for(const key in updates) taskToUpdate[key] = updates[key]; }, }; }
HEY! NO TE RINDAS!
PERO SI YA NO TIENES TIEMPO TE PASO MI SOLUCIÓN:
function createTaskPlanner() { let arrayTasks = []; function addTask(task) { task.completed = false; arrayTasks.push(task); } function removeTask(value) { let eraseTask = arrayTasks.find(element => element.id == value || element.name == value); arrayTasks.splice(arrayTasks.indexOf(eraseTask), 1); } function getTasks() { return arrayTasks; } function getPendingTasks() { return arrayTasks.filter(element => element.completed == false); } function getCompletedTasks() { return arrayTasks.filter(element => element.completed == true); } function markTaskAsCompleted(value) { let searchTask = arrayTasks.find(element => element.id == value || element.name == value); searchTask.completed = true; } function getSortedTasksByPriority() { let copyTasks = [...arrayTasks]; return copyTasks.sort((a, b) => a.priority - b.priority); } function filterTasksByTag(tag) { return arrayTasks.filter(element => element.tags.some(elem => elem == tag)); } function updateTask(taskId, updates) { let modifyTask = arrayTasks.find(element => element.id == taskId); Object.assign(modifyTask, updates); } return { addTask, removeTask, getTasks, getPendingTasks, getCompletedTasks, markTaskAsCompleted, getSortedTasksByPriority, filterTasksByTag, updateTask } } const planner = createTaskPlanner(); planner.addTask({ id: 1, name: "Comprar leche", priority: 1, tags: ["shopping", "home"] }); planner.addTask({ id: 2, name: "Llamar a Juan", priority: 3, tags: ["personal"] }); planner.markTaskAsCompleted("Llamar a Juan");
De la solución debuggee y puse console.logs para que puedan ir probando que devuelve cada método.
function createTaskPlanner() { let tasks = []; return { addTask(task) { task.completed = false; tasks.push(task); //console.log(tasks); }, removeTask(value){ if(typeof value === "number"){ tasks = tasks.filter((task) => task.id !== value); console.log("RemoveTaskPlannerFilter", tasks); } else { tasks = tasks.filter((task) => task.name !== value); console.log("RemoveTaskPlannerElse", tasks); } }, getTasks() { return tasks; }, getPendingTasks() { return tasks.filter((task)=> !task.completed); }, getCompletedTask() { return tasks.filter((task)=> task.completed); }, markTaskAsCompleted(value) { let index; if(typeof value === "number"){ index = tasks.findIndex((task) => task.id === value); } else { index = tasks.findIndex((task) => task.name === value); } tasks[index].completed = true; console.log('Modified position: ', tasks[index]); }, getSortedTasksByPriority () { const sortedTasks = [...tasks].sort((a, b) => a.priority - b.priority); return sortedTasks; }, filterTasksByTag(tag) { return tasks.filter((task) => task?.tags?.includes(tag)); }, updateTask(taskId, updates) { const i = tasks.findIndex((task) => task.id === taskId); tasks[i] = {...tasks[i], ...updates}; }, }; } const planner = createTaskPlanner(); // Adding values to tasks array planner.addTask({ id: 1, name: "Comprar leche", priority: 3, tags: ["shopping", "home"], completed: true, }); planner.addTask({ id: 2, name: "Llamar a Juan", priority: 1, tags: ["personal"], completed: false, }); planner.addTask({ id: 3, name: "Llamar a Belinda", priority: 2, tags: ["personal, introvert"], completed: true, }); // Results // console.log('AddTaskPlanner', planner.tasks); // console.log('RemoveTaskPlanner', planner.removeTask('Comprar leche')); // console.log(planner.removeTask(1)); // console.log('GetTaskPlanner', planner.getTasks()); // console.log('GetPendingTaskPlanner', planner.getPendingTasks()); // console.log('GetCompletedTaskPlanner', planner.getCompletedTask()); // planner.markTaskAsCompleted("Llamar a Juan") // console.log(planner.getSortedTasksByPriority()); // console.log('FilterTaskByTagPlanner', planner.filterTasksByTag('personal')); // planner.updateTask(2, {anotherPropierty: true}) // console.log('UpdateTagPlanner', planner.getTasks());
export function createTaskPlanner() { // Tu código aquí 👈 const tasks = [] return { addTask: (task) => { task.completed = false; tasks.push(task) }, removeTask: function (value) { const taskIndex = this.getTaskIndexByIdOrName(value) if (taskIndex == null) return; tasks.splice(taskIndex, 1) }, getTaskIndexByIdOrName: (value) => { return tasks.findIndex(task => task.id === value || task.name === value) }, getTasks: () => { return tasks; }, getPendingTasks: () => { return tasks.filter(task => !task.completed); }, getCompletedTasks: () => { return tasks.filter(task => task.completed); }, filterTasksByTag: (tag) => { return tasks.filter(task => task.tags.includes(tag)); }, markTaskAsCompleted: function (value) { const taskIndex = this.getTaskIndexByIdOrName(value) if (taskIndex == null) return; tasks[taskIndex].completed = true; }, getSortedTasksByPriority: function () { return [...tasks].sort((a, b) => a.priority - b.priority) }, updateTask: (taskId, updates) => { const taskIndex = tasks.findIndex(task => task.id === taskId) // Update tasks[taskIndex] = { ...tasks[taskIndex], ...updates } } } }
🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️
Task Planner
!Spoiler Shield
export function createTaskPlanner() { // Tu código aquí 👈 const tasks = []; function addTask(task) { task.completed = false; tasks.push(task); } function removeTask(value) { tasks.forEach((task, it) => { if (task.name == value || task.id == value) { tasks.splice(it, 1); } }); } function getTasks() { return tasks; } function getPendingTasks() { const result = []; tasks.forEach((task) => { if (!task.completed) { result.push(task); } }); return result; } function getCompletedTasks() { const result = []; tasks.forEach((task) => { if (task.completed) { result.push(task); } }); return result; } function markTaskAsCompleted(value) { tasks.forEach((task) => { if (task.name == value || task.id == value) { task.completed = true; } }); } function getSortedTasksByPriority() { const result = []; for (let i = 1; i <= 3; i++) { tasks.forEach((task) => { if (task.priority == i) { result.push(task); } }); } return result; } function filterTasksByTag(tag) { const result = []; tasks.forEach((task) => { task.tags.forEach((t) => { if (t == tag) { result.push(task); } }); }); return result; } function updateTask(taskId, updates) { tasks.forEach((task) => { if (task.id == taskId) { Object.entries(updates).forEach((up) => { task[up[0]] = up[1]; }); } }); } return { addTask, removeTask, getTasks, getPendingTasks, getCompletedTasks, markTaskAsCompleted, getSortedTasksByPriority, filterTasksByTag, updateTask, }; }
Solución!
