Playground - Crea un organizador de tareas

Cursos Empresas Blog Live Conf Precios

Contenido del curso

¡Te damos la bienvenida a este reto!

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

Día 1

Día 2

Día 3

Día 4

Día 5 - Checkpoint

20
Playground - encuentra el palindromo más grande

Día 6

Día 7

Día 8

Día 9

Día 10 - Checkpoint

Día 11

Día 12

Día 13

Día 14

Día 15 - Checkpoint

50
Playground - Sistema de reservaciones de un hotel

Día 16

Día 17

Día 18

Día 19

Día 20 - Checkpoint

65
Playground - Agenda de vuelos

Día 21

Día 22

Día 23

Día 24 - Checkpoint

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

Día 25

Día 26

Día 27

Día 28

Día 29

Día 30

93
¡Lo lograste!
01:41 min

Live Class

Tomar examen

Playground - Crea un organizador de tareas

Comentarios

David Ochoa

student

Escudo anti-spoilers

!Nyan Cat Programming

Algo que no queda muy claro es que se debe generar un Set por cada tarea donde se contenga los tags.

Por lo demás un excelente reto.

Nunca pares de aprender

export function taskManager() {
  // Creo un nuevo Map
  let tasks = new Map();

  function addTask(task, tags) {
    // Se convierte el nombre de la tarea a lowercase para ser comparadad
    task = task.toLowerCase();

    // En caso de existir la tarea, agrega nuevos tags a su Set de tags
    if (tasks.has(task)) {
      const existingTags = tasks.get(task);
      console.log(existingTags);
      tags.forEach((tag) => existingTags.add(tag));
    }
    // De no existir la tarea crea un nuevo set que contenga sus tags y adicionalmente
    // agrega la tarea ale Map de tareas
    else {
      const newTags = new Set(tags);
      tasks.set(task, newTags);
    }
  }
  function printTasks() {
    // Retorno las tareas
    return tasks
  }
  return { addTask, printTasks };
}

Pablo Pincay Alvarez

student

Bonito escudo anti spoilers xd

Angel Javier Sanchez Tenjo

student

Hola, comparto la solución; me toco auto spoliarme... pero entendi que debia hacer.

✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅ ✅

export function taskManager() {
  const tasks = new Map();

  const addTask = function (task, tags) {
    task = task.toLowerCase();
    if (tasks.has(task)) {
      const existingTags = tasks.get(task);
      tags.forEach((tag) => existingTags.add(tag));
    } else {
      const newTags = new Set(tags);
      tasks.set(task, newTags);
    }
  };

  const printTasks = function () {
    return tasks;
  };
  return { addTask, printTasks };
}

Frandel Corporan Rodríguez

student

Me gusto este playground 💚

export function taskManager() {
  const tasks = new Map()
  function addTask(task, tags) {
    task = task.toLowerCase()
    if (tasks.has(task)) {
      const currentTags = tasks.get(task)
      const updateTags = [...currentTags,...tags]
      
      tasks.set(task, new Set(updateTags))
    }
    else {
      tasks.set(task, new Set(tags))
    }
    
  }
  function printTasks() {
    return tasks
  }
  return{addTask,printTasks}
}

Andres Eduardo Maneiro Antunez

student

Mi solucion . . . . . . . . . . . . . . . . . . .

ecport function taskManager() {
    let tasks = new Map()
    return {
        addTask(task, tags) {
            const newTask = task.toLowerCase()
            if (!tasks.has(newTask)) {
                tasks.set(newTask, new Set(tags))
            } else {                
                tags.forEach(tag => tasks.get(newTask).add(tag))
            }
        }, 
        printTasks() {
            return tasks
        }
    }
}

Alejandro Naranjo

student

Cuando ejecuto este código, el playground me genera errores en “Vista” y no me habilita el botón para correr pruebas. Sin embargo dentro de mi equipo el código hace lo que creo que se está solicitando.

<code> 
export function taskManager() {
    const taskMap = new Map();

    function addTask(task, tags) {
        const taskLowerCase = task.toLowerCase();
        
        if (taskMap.has(taskLowerCase)) {
            const tagging = taskMap.get(taskLowerCase);
            tags.forEach(tag => tagging.add(tag));
        } else {
            const tagging = new Set(tags);
            taskMap.set(taskLowerCase, tagging);
        }
    }
    
    function printTasks() {
        const result = new Map();

        for (const [task, tagging] of taskMap.entries()) {
            const tags = Array.from(tagging);
            result.set(task, tags);
        }
        
        return result;
    }

 
    this.addTask = addTask;
    this.printTasks = printTasks; 
}

Leonardo de los angeles Espinoza Hernandez

student

¡Hola @alejonaranjo83!

Para que el ejercicio pueda correr y ejecutar las pruebas debes de regresar un closure, solamente el retornar las 2 funciones creadas y con ello deberás tener un resultado diferente

Me avisas si esto te es de ayuda, cualquier cosa siempre me la puedes hacer saber :D

Joan Alexander Valerio Rodríguez

student

Jacobo Burbano

student

Crei que seria facil y dure casi tres horas xD, pero bueno aqui dejo mi ejercicio . . . . . . . . . . . . . . . .

function abstractLowerCase(string) {
  return string.toLowerCase()
}
export function taskManager() {
  let objetoMap = new Map()
  return {
    addTask: (task, tags) => {
      if (!objetoMap.has(abstractLowerCase(task))) {
        objetoMap.set(abstractLowerCase(task), new Set(tags))
      }
      else {
        for (let i = 0; i < tags.length; i++) {
           objetoMap.get(abstractLowerCase(task)).add(tags[i])
        }
      }
    },
    printTasks: () => {
      return objetoMap
    }
  }
}

Rubén Hernández Hernández

student

💚Mi Solución 💚

🛡️ESCUDO ANTI-SPOILERS🛡️

!cats

👾Código

export function taskManager() {
  const tasksMap = new Map()

  const addTask = (task, tags) => {
    const taskLowerCase = task.toLowerCase()

    if (tasksMap.has(taskLowerCase)) {
      const taskTags = tasksMap.get(taskLowerCase)
      tags.forEach(tag => taskTags.add(tag))
    } else {
      tasksMap.set(taskLowerCase,new Set(tags))
    }
  }

  const printTasks = () => {
    return tasksMap
  }

  return {
    addTask,
    printTasks
  }
}

Gonzalo Gutiérrez Castillo

student

Mi solucion: . . . . . . .

function taskManager() {
  const tasks = new Map()

  const addTask = (task, tags) => {
    const newTask = task.toLowerCase()
    const hasTask = tasks.has(task)
    if (!hasTask) {
      tasks.set(newTask, new Set(tags))
    } else {
      let current = tasks.get(newTask)
      tasks.set(newTask, new Set([...current,...tags]))
    }
  }
  const printTasks = () => {
    return tasks
  }
  return { addTask, printTasks }
}

Elias Rayas Gonzalez

student

Solución

function taskManager() {
  // Tu código aquí 👈

  const tasks = new Map()

  function addTask(task, tag) {
    
    task = task.toLowerCase()

    // Check for existing tasks in map
    if (tasks.has(task)) {
      tag.forEach(item => tasks.get(task).add(item))
      return
    }

    // If it does not exists we create a new task
    tasks.set(
      task,
      new Set([...tag])
    )
  }
  function printTask() {
    return tasks
  }

  return {
    addTask,
    printTask
  }
}

Victor Hernandez

student

export function taskManager() {
  const map = new Map();

  const addTask = (task, tags) => {
    task = task.toLowerCase();
    if (!map.get(task)) {
      map.set(task, new Set(tags));
    } else {
      const tag = map.get(task);
      for (let t of tags) {
        tag.add(t);  
      }
      map.set(task, tag);
    }
  };

  const printTasks = () => {
    return map;
  };

  return { addTask, printTasks };

}

Esteban Alzate Atehortua

student

Mi solución! . . . . . . . . . . . . . . . . . . . . .

export function taskManager() {
    let map = new Map();
    return {
        "addTask": (task, tags) => {
            task = task.toLowerCase();
            if (!map.has(task)) {
              map.set(task, new Set(tags));
            } else {
              const tagSet = map.get(task);
              for (const tag of tags) {
                tagSet.add(tag);
              }
              map.set(task, tagSet);
            }
          },
      "printTasks":() =>{
        return map;
      }
    }
  }

Pablo Pincay Alvarez

student

.. . . SPOILERS <3 . . . . . . . . . . . .

export function taskManager() {
  const tasks = new Map()
  return {
    addTask: (task, tags) => {
      task = task.toLowerCase()
      if (tasks.has(task)) {
        const newTags = [...tasks.get(task), ...tags]
        tasks.set(task, new Set(newTags))
      }
      else {
        tasks.set(task, new Set(tags))
      }
    },
    printTasks: () => tasks
  }
}

Alexis Corrales

student

export function taskManager() {
  const tasks = new Map();

  const addTask = function (task, tags) {
    const result = task.toLowerCase();
    const existingTask = tasks.get(result);
    if (existingTask) {
      tags.forEach(tag => existingTask.add(tag));
    } else {
      tasks.set(result, new Set(tags));
    }
  };

  const printTasks = function () {
    return tasks;
  };
  return { addTask, printTasks };
}

Hiver Tapia

student

aquí mi versión

export function taskManager() {
  const tasks = new Map()
  return {
    addTask(task, tags) {
      task = task.toLowerCase()
      if (!tasks.has(task)) tasks.set(task, new Set(tags))
      else tags.forEach(tag => tasks.get(task).add(tag))
    },
    printTasks() { return tasks }
  }
}

Alejandro Anaya

student

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

Personalmente me gusta más como se organiza el código con el azúcar sintáctico de JS usando 'class' en vez de usar closures, al final el código puede hacer lo mismo, son solo gustos...

class Tasks{

  constructor() {
    this.tasks = new Map()
  }

  addTask(task, tags) {
    task = task.toLowerCase()
    if (this.tasks.has(task)) {
      this.tasks.set(task, new Set([...this.tasks.get(task), ...tags]))
    } else {
      this.tasks.set(task, new Set(tags))
    }
  }

  printTasks() {
    return this.tasks
  }
}

export const taskManager = () => new Tasks()

Abril Darynka Tapia Sosa

student

Hola, dejo mi solución: . . . . . . . . . .

export function taskManager() {
  // Tu código aquí 👈
  let tasks = new Map();
  const addTask = (task, tags) => {
    const taskLowerCase = task.toLowerCase();
    const existTask = tasks.has(taskLowerCase);
    if(existTask){
      tasks.get(taskLowerCase)
      tags.forEach(item => tasks.get(taskLowerCase).add(item));
    }else{
      tasks.set(taskLowerCase, new Set(tags));
    }
  }; 
  const printTasks = ()  => tasks;
  
  return {
    addTask, 
    printTasks
  }
}

Jose Carlos Machado

student

En las pruebas se llama directamente las funciones y no desde la variable que contiene el closure. Aquí dejo mi aporte... :)

export function taskManager() {
  // Tu código aquí 👈

  let org = new Map();

  function addTask(task, tags) {
    let lowertask = task.toLowerCase()
    if (org.has(lowertask)) {
      for (let tag of tags) {
        org.get(lowertask).add(tag)
      }

    } else {
      org.set(lowertask, new Set(tags))
    }
  }
  function printTasks() {
    return org
  }

  return {
    addTask,
    printTasks
  }

}

Carina Payleman

student

. . . . . .

export function taskManager() {
  let tasks = new Map();

  function addTask(task, tags) {
    let duplicatedTask = task.toLowerCase();
    if (!tasks.has(duplicatedTask)) {
      tasks.set(duplicatedTask, new Set(tags));
    } else {
      tags.forEach(tag => tasks.get(duplicatedTask).add(tag));
    }
  }
  
  function printTasks() {
    return tasks; 
  }
  return { addTask, printTasks }
}

Victor Ortiz

student

Mi solución, me quedo buena: . . . . . . . . . . . . . . . . . . . . .

export function taskManager() {
  // Tu código aquí 👈
  let map = new Map();
  return {
    addTask(task, tags) {
      if (map.has(task.toLowerCase())) {
        tags.forEach(tag => map.get(task.toLowerCase()).add(tag));
      } else {
        map.set(task.toLowerCase(), new Set(tags));
      }
    },
    printTasks() {
      console.log(map)
      return map;
    }
  }
}

export function taskManager() {
  // Creo un nuevo Map
  let tasks = new Map();

  function addTask(task, tags) {
    // Se convierte el nombre de la tarea a lowercase para ser comparadad
    task = task.toLowerCase();

    // En caso de existir la tarea, agrega nuevos tags a su Set de tags
    if (tasks.has(task)) {
      const existingTags = tasks.get(task);
      console.log(existingTags);
      tags.forEach((tag) => existingTags.add(tag));
    }
    // De no existir la tarea crea un nuevo set que contenga sus tags y adicionalmente
    // agrega la tarea ale Map de tareas
    else {
      const newTags = new Set(tags);
      tasks.set(task, newTags);
    }
  }
  function printTasks() {
    // Retorno las tareas
    return tasks
  }
  return { addTask, printTasks };
}

export function taskManager() {
  const tasks = new Map();

  const addTask = function (task, tags) {
    task = task.toLowerCase();
    if (tasks.has(task)) {
      const existingTags = tasks.get(task);
      tags.forEach((tag) => existingTags.add(tag));
    } else {
      const newTags = new Set(tags);
      tasks.set(task, newTags);
    }
  };

  const printTasks = function () {
    return tasks;
  };
  return { addTask, printTasks };
}

export function taskManager() {
  const tasks = new Map()
  function addTask(task, tags) {
    task = task.toLowerCase()
    if (tasks.has(task)) {
      const currentTags = tasks.get(task)
      const updateTags = [...currentTags,...tags]
      
      tasks.set(task, new Set(updateTags))
    }
    else {
      tasks.set(task, new Set(tags))
    }
    
  }
  function printTasks() {
    return tasks
  }
  return{addTask,printTasks}
}

ecport function taskManager() {
    let tasks = new Map()
    return {
        addTask(task, tags) {
            const newTask = task.toLowerCase()
            if (!tasks.has(newTask)) {
                tasks.set(newTask, new Set(tags))
            } else {                
                tags.forEach(tag => tasks.get(newTask).add(tag))
            }
        }, 
        printTasks() {
            return tasks
        }
    }
}

<code> 
export function taskManager() {
    const taskMap = new Map();

    function addTask(task, tags) {
        const taskLowerCase = task.toLowerCase();
        
        if (taskMap.has(taskLowerCase)) {
            const tagging = taskMap.get(taskLowerCase);
            tags.forEach(tag => tagging.add(tag));
        } else {
            const tagging = new Set(tags);
            taskMap.set(taskLowerCase, tagging);
        }
    }
    
    function printTasks() {
        const result = new Map();

        for (const [task, tagging] of taskMap.entries()) {
            const tags = Array.from(tagging);
            result.set(task, tags);
        }
        
        return result;
    }

 
    this.addTask = addTask;
    this.printTasks = printTasks; 
}

function abstractLowerCase(string) {
  return string.toLowerCase()
}
export function taskManager() {
  let objetoMap = new Map()
  return {
    addTask: (task, tags) => {
      if (!objetoMap.has(abstractLowerCase(task))) {
        objetoMap.set(abstractLowerCase(task), new Set(tags))
      }
      else {
        for (let i = 0; i < tags.length; i++) {
           objetoMap.get(abstractLowerCase(task)).add(tags[i])
        }
      }
    },
    printTasks: () => {
      return objetoMap
    }
  }
}

export function taskManager() {
  const tasksMap = new Map()

  const addTask = (task, tags) => {
    const taskLowerCase = task.toLowerCase()

    if (tasksMap.has(taskLowerCase)) {
      const taskTags = tasksMap.get(taskLowerCase)
      tags.forEach(tag => taskTags.add(tag))
    } else {
      tasksMap.set(taskLowerCase,new Set(tags))
    }
  }

  const printTasks = () => {
    return tasksMap
  }

  return {
    addTask,
    printTasks
  }
}

function taskManager() {
  const tasks = new Map()

  const addTask = (task, tags) => {
    const newTask = task.toLowerCase()
    const hasTask = tasks.has(task)
    if (!hasTask) {
      tasks.set(newTask, new Set(tags))
    } else {
      let current = tasks.get(newTask)
      tasks.set(newTask, new Set([...current,...tags]))
    }
  }
  const printTasks = () => {
    return tasks
  }
  return { addTask, printTasks }
}

function taskManager() {
  // Tu código aquí 👈

  const tasks = new Map()

  function addTask(task, tag) {
    
    task = task.toLowerCase()

    // Check for existing tasks in map
    if (tasks.has(task)) {
      tag.forEach(item => tasks.get(task).add(item))
      return
    }

    // If it does not exists we create a new task
    tasks.set(
      task,
      new Set([...tag])
    )
  }
  function printTask() {
    return tasks
  }

  return {
    addTask,
    printTask
  }
}

export function taskManager() {
  const map = new Map();

  const addTask = (task, tags) => {
    task = task.toLowerCase();
    if (!map.get(task)) {
      map.set(task, new Set(tags));
    } else {
      const tag = map.get(task);
      for (let t of tags) {
        tag.add(t);  
      }
      map.set(task, tag);
    }
  };

  const printTasks = () => {
    return map;
  };

  return { addTask, printTasks };

}

export function taskManager() {
    let map = new Map();
    return {
        "addTask": (task, tags) => {
            task = task.toLowerCase();
            if (!map.has(task)) {
              map.set(task, new Set(tags));
            } else {
              const tagSet = map.get(task);
              for (const tag of tags) {
                tagSet.add(tag);
              }
              map.set(task, tagSet);
            }
          },
      "printTasks":() =>{
        return map;
      }
    }
  }

export function taskManager() {
  const tasks = new Map()
  return {
    addTask: (task, tags) => {
      task = task.toLowerCase()
      if (tasks.has(task)) {
        const newTags = [...tasks.get(task), ...tags]
        tasks.set(task, new Set(newTags))
      }
      else {
        tasks.set(task, new Set(tags))
      }
    },
    printTasks: () => tasks
  }
}

export function taskManager() {
  const tasks = new Map();

  const addTask = function (task, tags) {
    const result = task.toLowerCase();
    const existingTask = tasks.get(result);
    if (existingTask) {
      tags.forEach(tag => existingTask.add(tag));
    } else {
      tasks.set(result, new Set(tags));
    }
  };

  const printTasks = function () {
    return tasks;
  };
  return { addTask, printTasks };
}

export function taskManager() {
  const tasks = new Map()
  return {
    addTask(task, tags) {
      task = task.toLowerCase()
      if (!tasks.has(task)) tasks.set(task, new Set(tags))
      else tags.forEach(tag => tasks.get(task).add(tag))
    },
    printTasks() { return tasks }
  }
} 

class Tasks{

  constructor() {
    this.tasks = new Map()
  }

  addTask(task, tags) {
    task = task.toLowerCase()
    if (this.tasks.has(task)) {
      this.tasks.set(task, new Set([...this.tasks.get(task), ...tags]))
    } else {
      this.tasks.set(task, new Set(tags))
    }
  }

  printTasks() {
    return this.tasks
  }
}

export const taskManager = () => new Tasks()

export function taskManager() {
  // Tu código aquí 👈
  let tasks = new Map();
  const addTask = (task, tags) => {
    const taskLowerCase = task.toLowerCase();
    const existTask = tasks.has(taskLowerCase);
    if(existTask){
      tasks.get(taskLowerCase)
      tags.forEach(item => tasks.get(taskLowerCase).add(item));
    }else{
      tasks.set(taskLowerCase, new Set(tags));
    }
  }; 
  const printTasks = ()  => tasks;
  
  return {
    addTask, 
    printTasks
  }
}

export function taskManager() {
  // Tu código aquí 👈

  let org = new Map();

  function addTask(task, tags) {
    let lowertask = task.toLowerCase()
    if (org.has(lowertask)) {
      for (let tag of tags) {
        org.get(lowertask).add(tag)
      }

    } else {
      org.set(lowertask, new Set(tags))
    }
  }
  function printTasks() {
    return org
  }

  return {
    addTask,
    printTasks
  }

}

export function taskManager() {
  let tasks = new Map();

  function addTask(task, tags) {
    let duplicatedTask = task.toLowerCase();
    if (!tasks.has(duplicatedTask)) {
      tasks.set(duplicatedTask, new Set(tags));
    } else {
      tags.forEach(tag => tasks.get(duplicatedTask).add(tag));
    }
  }
  
  function printTasks() {
    return tasks; 
  }
  return { addTask, printTasks }
}

export function taskManager() {
  // Tu código aquí 👈
  let map = new Map();
  return {
    addTask(task, tags) {
      if (map.has(task.toLowerCase())) {
        tags.forEach(tag => map.get(task.toLowerCase()).add(tag));
      } else {
        map.set(task.toLowerCase(), new Set(tags));
      }
    },
    printTasks() {
      console.log(map)
      return map;
    }
  }
}

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

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

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios

Día 19