Playground - Task planner

Leonardo de los angeles Espinoza Hernandez

student•

🛡️🛡️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?

Daniel Sebastián Rodríguez

student•

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)
    },

Elian Sumalave

student•

Yo hice así mi método removeTask:

removeTask: function (value) {
      tasks = tasks.filter(a => a.id !== parseInt(value) && a.name !== value)
    },

Salvador Gonzalez Blanco

student•

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/

Leonardo de los angeles Espinoza Hernandez

student•

Tu solución amerita que la presumas en alguna red social 💪

Me encantó

Harold Zurita Simon

student•

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
  }
}

Isabelle de Souza

student•

genial Harold.

Santiago Sabogal

student•

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)
            }
        })}
    }
}>

Daniel Sebastián Rodríguez

student•

Gracias, sin este comentario no me habría dado cuenta, no sabía qué estaba fallando

Leonardo de los angeles Espinoza Hernandez

student•

Ya está corregida la descripción :D

Gabriel Luna

student•

Aquí está mi solución, en este ejercicio aumentó la dificultad, excelente el reto!!! . . . . . . . . . . . . . . . . .

Daniel André Amaya López

student•

👾 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
      })
    },
  }
}

Andres Roca

student•

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];
    },
  }
}

Carina Payleman

student•

. . . . . .

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}
}

Jhony Ardila

student•

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);
  }
}

Joan Alexander Valerio Rodríguez

student•

Stevenson Grajales

student•

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

Leonardo de los angeles Espinoza Hernandez

student•

¡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!

Julian Roa Villamil

student•

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?

Julian Roa Villamil

student•

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??

Leonardo de los angeles Espinoza Hernandez

student•

¡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 💪

Marco Antonio Urquidi Espada

student•

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

Leonardo de los angeles Espinoza Hernandez

student•

¡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 💪

Gustavo Alonso Aguilar Acuña

student•

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

Leonardo de los angeles Espinoza Hernandez

student•

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 💪

Gustavo Alonso Aguilar Acuña

student•

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;
          }
        }) 
      }

Fernando Velasco

student•

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];
    },
  };
}

Ricardo Alfonso Chavez Vilcapoma

student•

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");

IRIDIAN GUADALUPE CARRERA MONDRAGÓN

student•

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());

Francisco Javier Solis Martinez

student•

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
      }
    }

  }
}

David Ochoa

student•

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

Harrison Steve Pinzón Neira

student•

Solución!

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 };
    },
  };
}

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
  }
}

<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)
            }
        })}
    }
}> 

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
      })
    },
  }
}

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}
}  

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);
  }
}

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",
],
},
]

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

      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];
    },
  };
}

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");

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
      }
    }

  }
}

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,
  };
}

Playground - Task planner

¡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