Adding an edit task feature is a nice enhancement and builds directly on the structure we’ve already created using addEventListener and saving our tasks to local storage. Let’s walk through how to do add an “edit” button step-by-step, keeping everything consistent with the rest of our app.
However, we had to change the code a bit, we had to replace the firstChild and add span instead input and a few more things. Let’s take a look.

1. addTask() function

This function from the previous project needs to be modified with span instead item and key things happening:

let li = document.createElement("li");
let span = document.createElement("span");
span.textContent = taskInput.value;
li.appendChild(span);

What’s going on?

A new list item (<li>) is created.
A <span> is created to hold the task’s text, and then the <span> is appended inside the <li>. BUt why do we need to use <span>?

Because it gives you a dedicated, consistent place to store and edit the task text.

Without it, the buttons and text are all siblings inside <li>, and targeting “just the task text” becomes messy. A <span> is easily replaceable and queryable (e.g., li.querySelector(“span”)).

2. Buttons (Edit, Complete, Delete)

We need to add the edit button and each button is appended to the <li>, and all buttons use addEventListener().
The same as with the earlier project we use the toggles approach for the complete button with the .completed class
Delete button removes the task and the edit button triggers the editTask(li) function

3. saveTasks()

This function saves the entire to-do list to local storage, but we changed it a bit compared to the previous project.

tasks.push({
    text: li.querySelector("span").textContent.trim(),
    completed: li.classList.contains("completed")
});

This works well because li.querySelector(“span”) reliably gives you the task text, no matter what else is in the <li>. The completed status is stored as a Boolean, and everything is stored as a JSON string in local storage.

4. loadTasks()

This function rebuilds the saved tasks from local storage and you’re recreating:

• The <li>
• The <span> containing the text
• The buttons (edit, complete, delete)
• Re-attaching all behaviors (via addEventListener)

5. editTask()

In the editTask function we replace the <span> with an <input> element, and this is where we let the user edit the task, and on blur or Enter, you walidate the input. We put the updated text back into a <span>, this is why we need to replace the <input> with the new <span>. This approach avoids bugs that came from manipulating li.firstChild, because now you’re explicitly working with the <span>, not guessing which node is the text.

We needed to replace First Child with using <span>
Old approach (what went wrong):

li.firstChild.textContent = "";
li.insertBefore(input, li.firstChild);

Why this was fragile:

li.firstChild might not be the text you think it is. Depending on how the browser builds the DOM, it could be a text node, button, input. And after replacing it, the structure becomes messy and unpredictable, buttons might stop working or the text might be gone or hard to re-target.

For this reason we used a new approach with <span>:

let span = li.querySelector("span");
li.replaceChild(input, span);
...
li.replaceChild(span, input); // After editing

This approach is better because you always know exactly where the text lives and editing is just a clean swap between span and input. Now, there is no weird child node index guessing or fragile assumptions, and above all much easier to maintain and expand.

The final code looks like this:

document.getElementById("addButton").addEventListener("click", addTask);

function addTask() {
    let taskInput = document.getElementById("taskInput");
    let taskList = document.getElementById("taskList");

    if (taskInput.value === "") {
        alert("Please enter a task!");
        return;
    }

    let li = document.createElement("li");
    let span = document.createElement("span");
    span.textContent = taskInput.value;
    li.appendChild(span);

    // Add a complete button
    let completeButton = document.createElement("button");
    completeButton.textContent = "✓";
    completeButton.style.marginLeft = "10px";
    completeButton.onclick = function () {
        li.classList.toggle("completed");
        saveTasks(); 
    };

    // Add a delete button
    let deleteButton = document.createElement("button");
    deleteButton.textContent = "❌";
    deleteButton.style.marginLeft = "10px";
    deleteButton.onclick = function () {
        taskList.removeChild(li);
        saveTasks(); 
    };

    // Add an edit button
    let editButton = document.createElement("button");
    editButton.textContent = "✏️";
    editButton.style.marginLeft = "10px";
    editButton.addEventListener("click", function () {
    editTask(li);
    });


    li.appendChild(editButton);
    li.appendChild(completeButton);
    li.appendChild(deleteButton);
    taskList.appendChild(li);

    taskInput.value = ""; // Clear input after adding

    saveTasks(); 
}

function saveTasks() {
    let tasks = [];
    let items = document.querySelectorAll("#taskList li");
    items.forEach((li) => {
        tasks.push({
            text: li.querySelector("span").textContent.trim(),
            completed: li.classList.contains("completed")
        });
    });
    localStorage.setItem("tasks", JSON.stringify(tasks));
}

function loadTasks() {
    let tasks = JSON.parse(localStorage.getItem("tasks")) || [];
    let taskList = document.getElementById("taskList");

    tasks.forEach(task => {
        let li = document.createElement("li");
        let span = document.createElement("span");
        span.textContent = task.text;
        li.appendChild(span);

        if (task.completed) {
            li.classList.add("completed");
        }

        let completeButton = document.createElement("button");
        completeButton.textContent = "✓";
        completeButton.style.marginLeft = "10px";
        completeButton.onclick = function () {
            li.classList.toggle("completed");
            saveTasks();
        };

        let deleteButton = document.createElement("button");
        deleteButton.textContent = "❌";
        deleteButton.style.marginLeft = "10px";
        deleteButton.onclick = function () {
            taskList.removeChild(li);
            saveTasks();
        };

        let editButton = document.createElement("button");
        editButton.textContent = "✏️";
        editButton.style.marginLeft = "10px";
        editButton.addEventListener("click", function () {
            editTask(li);
        });
        
        li.appendChild(editButton);        
        li.appendChild(completeButton);
        li.appendChild(deleteButton);
        taskList.appendChild(li);
    });
}

function editTask(li) {
    let span = li.querySelector("span");
    let currentText = span.textContent.trim();

    let input = document.createElement("input");
    input.type = "text";
    input.value = currentText;
    input.style.marginRight = "10px";

    li.replaceChild(input, span);

    input.focus();
    input.select();

    function saveEdit() {
        if (input.value.trim() === "") {
            alert("Task cannot be empty.");
            return;
        }

        span.textContent = input.value.trim();
        li.replaceChild(span, input); // Replace input back with span
        saveTasks();
    }

    input.addEventListener("blur", saveEdit);
    input.addEventListener("keydown", function (e) {
        if (e.key === "Enter") {
            saveEdit();
        }
    });
}

// Call loadTasks ONCE when page loads
loadTasks();

In conclusion

So, in this project we’ve built a full-featured to-do list that supports:

• Adding tasks
• Completing tasks
• Deleting tasks
• Editing tasks inline (with live updates to localStorage)

And by introducing the <span>, you’ve structured your DOM in a way that’s easy to read, modify, and interact with — avoiding common pitfalls like unreliable firstChild access.

In this article we are going to work on JS version that uses “addEventListener” method instead of the “onclick” in HTML, which is perhaps considered more primitive and suitable for complete beginners. The code bellow already has the possibility to adds tasks to the list, and a complete and delete button. What we’ll now add is:

• A saveTasks() function to store the tasks in local storage.
• A loadTasks() function to load saved tasks when the page loads.

This means we will update the existing code to save changes whenever a task is added, completed, or deleted, even after the browser window is closed or refreshed.

…

In this article we’re going to build on our previous project: 3 JavaScript versions of simple to-do list. Let’s try adding a new useful feature – let’s save the task we add to local storage. Local Storage is a feature in your browser that lets you save data, in our case — tasks — even after the page is refreshed or the browser is closed and reopened.

In this article we will be using onclick in HTML, which is probably the easiest method to understand for complete beginners. You simply attach the addTask() function directly to the button using the onclick attribute inside the HTML. While this works fine for small projects, it’s not considered best practice because it mixes your structure (HTML) with your behavior (JavaScript), which can make your code harder to manage in the long run. We will focus on better practices
in our next article.
…

Creating a simple to-do list is one of the best beginner-friendly JavaScript projects. It helps you practice how to connect HTML structure, CSS styling, and JavaScript functionality.

In this article, I’ll walk you through four different ways to create a to-do list using JavaScript. Each method starts with the same HTML and CSS, but the JavaScript code will vary slightly. This way, you’ll learn different techniques and understand the pros and cons of each.

…

Distortions in AI-generated videos can be technically referred to as artifacts or generative artifacts. These are unintended visual or auditory anomalies that occur due to limitations in the AI model, training data, or generation process. Common types of distortions include:

Standardizing data is a vital part of the data cleaning process. It guarantees consistency and uniformity within the dataset, which is essential for precise analysis, reporting, and machine learning models, leading to optimal data integrity. Depending on the data’s nature and the analysis requirements, standardizing data can involve a variety of transformations and operations. The main aspects of data standardization include:
…

Removing duplicates in MySQL involves identifying and deleting rows with duplicate data to ensure the integrity and accuracy of your database. This article will serve as a step-by-step guide on how to remove duplicates in MySQL.
…

Handling missing values is a critical step in data preprocessing, particularly in data science and machine learning projects, because many algorithms do not function properly or may produce misleading results if the data contains missing or null values. Let’s take a look at the key strategies and considerations for handling missing data.
…

Data cleaning is an essential step in the data analysis process. It involves preparing and transforming raw data into a more useful and accurate format. SQL (Structured Query Language) is a powerful tool for data cleaning because it can handle large datasets efficiently and provides various functions and operations to manipulate data.
…

Choosing between Retrieval-Augmented Generation (RAG) and fine-tuning depends on the specific requirements, resources, and goals of your application. Here are scenarios when each approach is more sensible.

…