Playground - Crea un organizador de tareas

Escudo anti-spoilers

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

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

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

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

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

💚Mi Solución 💚

🛡️ESCUDO ANTI-SPOILERS🛡️

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

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

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

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

}

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

…
.
. SPOILERS ❤️
.
.
.
.
.
.
.
.
.
.
.
.

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

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

🛡️🛡️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()

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

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
  }

}

.
.
.
.
.
.

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

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() {
  const tasks = new Map();

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

  function printTasks() {
    return tasks;
  }

  return { addTask, printTasks };
}

Solución… 😄
.
.
.
.

.
.

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

  function addTask(task, tags) {
    task = task.toLowerCase();
    let previousTags = [];

    if (!tasks.has(task)) {
      tasks.set(task, new Set(tags));
    } else {
      previousTags = tasks.get(task);
      tags.forEach(tag => previousTags.add(tag));
      tasks.set(task, previousTags);
    }
  };

  function printTasks() {
    return tasks;
  }

  return {
    addTask,
    printTasks
  };
}

Mi solución
*
*
*
*
*
*
*
*
*
*
*
*
*

export function taskManager() {
  const tasks = new Map()
  const addTask = (task, tags) => {
    if (tasks.has(task)) {
      tasks.forEach((value, key) => {
        if (key === task) {
          tasks.set(key, new Set([...value, ...tags]));
        }
      });
    } else {
      tasks.set(task.toLowerCase(), new Set(tags))
    }
  }

  const printTasks = () => tasks

  return {
    addTask,
    printTasks
  }

}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

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

Y bueno aquí va mi solución a este último problema:

.
.
.
.
.
.
.
.
.
.
.
.

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

  const addTask = (task, tag) => {
    const taskMinuscule = task.toLowerCase()
    if (totalTasks.has(taskMinuscule)) totalTasks.set(taskMinuscule, new Set(Array.from(totalTasks.get(taskMinuscule)).concat(tag)))
    else {
      totalTasks.set(taskMinuscule, new Set(tag))
    }
  }

  const printTasks = () => {
    return totalTasks
  }

  return {
    addTask,
    printTasks
  }
}

Mi solución:
.
.
.
.
.
.
.
.
.
.

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

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

    if (!tasks.has(task)) {
      tasks.set(task, new Set(tags))
    } else {
      const uniqueTags = new Set([...tasks.get(task), ...tags])
      tasks.set(task, uniqueTags)
    }
  }

  const printTasks = () => tasks

  return { addTask, printTasks }
}

Les comparto mi solución. 😄
Perrito anti-spoilers

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

	function addTask (task, tags) {
		task = task.toLocaleLowerCase();

		if (!TASK_LIST.get(task)) {
			const TAGS = new Set(tags);

			TASK_LIST.set(task, TAGS);

			return;
		}

		const CURRENT_TAGS = TASK_LIST.get(task);

		for (let i = 0; i < tags.length; i++) {
			CURRENT_TAGS?.add(tags[i]);
		}
	}

	function printTasks () {
		return TASK_LIST;
	}

	return {
		addTask,
		printTasks
	};
}

Mi solución:
![](

export function taskManager() {
  let tasks = new Map();
  return {
    addTask: function (task, tags) {
      if (tasks.has(task.toLowerCase())) {
        let newTags = new Set((tasks.get(task.toLowerCase()) + "," + tags).split(','));
        tasks.delete(task.toLowerCase());
        tasks.set(task.toLowerCase(), newTags);
      }
      else {
        tasks.set(task.toLowerCase(), tags);
      }
    },
    printTasks: function () {
      return tasks;
    }
  }
}

mi versión de la solución:

export function taskManager() {
  // Tu código aquí 👈
  let tareasMap = new Map();

  return {
    addTask(task, tags) {

      let tareasSetNew = new Set(tags);
      if (tareasMap.has(task.toLowerCase()) === false) {
        tareasMap.set(task.toLowerCase(), tareasSetNew);

      } else {
        const setAct = tareasMap.get(task);
        tags.forEach((tag) => setAct.add(tag));

      }
    },

    printTasks() {
      return tareasMap;
    },
  };
} 

Aquí mi solución:
.
.
.
.
.
.
.
.
.
.
.

export function taskManager() {
  let tasks = new Map()
  return {
    addTask(task, tags) {
      let values;
      //convierte a minuscula
      task = task.toLowerCase();
      //verifica si existe 
      if (tasks.has(task)) {
        values = tasks.get(task);
        if (values) { tags.forEach(elem => values.add(elem)); }
      } else {
        let set = new Set(tags);
        tasks.set(task, set);
      }
    },
    printTasks() {
      return tasks;
    }
  }
}

Mi solución:

export function taskManager() {
  let map = new Map();
  function addTask(task, forset) {
    task = task.toLowerCase();
    if (map.has(task)) {
      return forset.forEach(x => map.get(task).add(x));
    }
    map.set(task, new Set(forset));
  }
    function printTasks() {
      return map;
  }
  return { addTask, printTasks }
}

Mi solución:
.
.
.
.
.
.
.

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