Essential CSS
JavaScript Roadmap
Learn JavaScript
Mastering Web Typography
Practical Astro
Understanding Async JS
Unorthodox Tailwind
API Masterclass
Build and Deploy
The Beginner Freelancer
Real World Node
Profile Billing Logout
Learn JavaScript
Lesson Plan
  1. JavaScript and its ecosystem
    1. Welcome to Learn JavaScript!
    2. What is JavaScript used for?
    3. The JavaScript ecosystem
    4. Varying versions of JavaScript
  2. JS Basics
    1. Linking your JavaScript file
    2. Preparing your text editor
    3. The Console
    4. Comments
    5. On semicolons
    6. Strings, numbers and booleans
    7. Understanding Variables
    8. Understanding Functions
    9. The Flow of a Function
    10. Arrow functions
    11. Intro to objects
    12. If/else statements
    13. Comparing Objects
    14. The NOT operator
    15. Null and Undefined
    16. The BOM and the DOM
    17. Selecting an Element
    18. Changing Classes
    19. Listening to events
    20. Callbacks
  3. Building simple components
    1. How to think like a developer
    2. Starter files and Source codes
    3. Do this for every component
    4. đź›  Off-canvas menu: Building an off-canvas menu
    5. đź›  Modal: Building a Modal
    6. Lessons from the building process
    7. Debugging errors
    8. How to use a linter
  4. Arrays and loops
    1. Introduction to Arrays
    2. Array methods
    3. For loops
    4. The forEach loop
    5. Selecting multiple elements
    6. Nodes vs Elements
    7. đź›  Accordion: Building an accordion
  5. Dom basics
    1. Id, classes, attributes, and tags
    2. Changing CSS with JavaScript
    3. Getting CSS with JavaScript
    4. Changing Attributes
    5. Finding an element's size and position
    6. DOM Traversals
    7. đź›  Tabby: Building Tabby (A Tabbed component)
    8. đź›  Carousel: HTML and CSS
    9. đź›  Carousel: Switching slides with JavaScript
    10. đź›  Carousel: Working the dots
    11. đź›  Carousel: Positioning slides with JavaScript
  6. Events deep dive
    1. The listening element
    2. Default Behaviors
    3. Event propagation
    4. Event delegation
    5. Removing Event Listeners
    6. đź›  Modal: Closing the modal
    7. đź›  Accordion: Event delegation
    8. đź›  Tabby: Event delegation
    9. đź›  Carousel: Event delegation
  7. Transitions and Animations
    1. CSS Transitions
    2. CSS Animations
    3. Silky-smooth animations
    4. Integrating CSS transitions and animations with JavaScript
    5. Animating with JavaScript
    6. GreenSock Animation API (GSAP)
    7. đź›  Off-canvas menu: Animations
    8. đź›  Modal: Animating the modal
    9. đź›  Modal: Animating the pointing hand
    10. đź›  Modal: Animating the waving hand
    11. đź›  Modal: Wave hand animation with JavaScript (using GSAP)
    12. đź›  Accordion: Animations
    13. đź›  Carousel: Animations
  8. Useful JS features
    1. Ternary operators
    2. AND and OR operators
    3. Early returns
    4. Template Literals
    5. Destructuring
    6. Default parameters
    7. Enhanced Object Literals
    8. Rest and Spread
    9. Useful array methods
    10. Looping through objects
    11. Returning objects with implicit return
    12. đź›  Accordion: Using useful JavaScript features
    13. đź›  Tabby: Using useful JavaScript features
    14. đź›  Carousel: Useful JavaScript features
  9. JS Best practices
    1. Write declarative code
    2. Functions with a purpose
    3. Manage scope
    4. Reduce state changes
    5. Don't reassign
    6. Don't mutate
    7. Preventing Objects from mutating
    8. Preventing Arrays from mutating
    9. Write pure functions
    10. đź›  Accordion: Refactor
    11. đź›  Carousel: First refactor
    12. đź›  Carousel: Refactoring the dots part
    13. đź›  Carousel: Previous and next buttons
    14. đź›  Carousel: Second refactor
  10. Manipulating text and content
    1. Changing Text and HTML
    2. Creating HTML Elements
    3. Adding multiple elements to the DOM
    4. Removing Elements from the DOM
    5. đź›  Carousel: Creating dots with JavaScript
    6. 🛠️ Calculator: HTML and CSS
    7. 🛠️ Calculator: Happy Path
    8. 🛠️ Calculator: Testing the Happy Path
    9. 🛠️ Calculator: Easy Edge Cases
    10. 🛠️ Calculator: Difficult Edge Cases
    11. 🛠️ Calculator: Refactoring
    12. The switch statement
    13. 🛠️ Calculator: Refactoring (Part 2)
    14. 🛠️ Popover: Making one popover
    15. 🛠️ Popover: Making four popovers
    16. 🛠️ Popover: Making popovers with JavaScript
  11. Handling Forms
    1. Intro to forms
    2. Selecting form fields with JavaScript
    3. Form fields and their events
    4. Sanitize your output
    5. Generating unique IDs
    6. 🛠️ Popover: Dynamic ID
    7. 🛠️ Todolist: The HTML and CSS
    8. 🛠️ Todolist: Creating tasks with JavaScript
    9. 🛠️ Todolist: Deleting tasks with JavaScript
    10. 🛠️ Typeahead: The HTML and CSS
    11. 🛠️ Typeahead: Displaying predictions
    12. 🛠️ Typeahead: Selecting a prediction
    13. 🛠️ Typeahead: Bolding search terms
  12. Handling Dates
    1. The Date object
    2. Getting a formatted date
    3. Getting the time
    4. Local time and UTC Time
    5. Setting a specific date
    6. Setting a date with Date methods
    7. Adding (or subtracting) date and time
    8. Comparing Dates and times
    9. 🛠️ Datepicker: HTML and CSS
    10. 🛠️ Datepicker: Building the calendar
    11. 🛠️ Datepicker: Building the datepicker with JavaScript
    12. 🛠️ Datepicker: Previous and Next buttons
    13. 🛠️ Datepicker: Selecting a date
    14. 🛠️ Datepicker: Positioning the datepicker
    15. 🛠️ Datepicker: Showing and hiding
    16. Formatting a date with toLocaleString
    17. setTimeout
    18. setInterval
    19. 🛠️ Countdown timer: HTML and CSS
    20. 🛠️ Countdown timer: JavaScript
    21. 🛠️ Countdown timer: Counting Months
    22. 🛠️ Countdown timer: Daylight Saving Time
    23. 🛠️ Countdown timer: Counting Years
  13. Async JS
    1. Introduction to Ajax
    2. Understanding JSON
    3. The Fetch API
    4. Possible data types
    5. JavaScript Promises
    6. Requests and responses
    7. Sending a POST request
    8. Authentication
    9. Handling errors
    10. Viewing response headers
    11. CORS and JSONP
    12. XHR vs Fetch
    13. Using an Ajax library
    14. Reading API documentation
    15. Understanding curl
    16. 🛠️ Todolist: The Todolist API
    17. 🛠️ Todolist: Fetching tasks
    18. 🛠️ Todolist: Creating tasks
    19. 🛠️ Todolist: Editing tasks
    20. 🛠️ Todolist: Deleting tasks
    21. 🛠️ Todolist: Creating tasks with Optimistic UI
    22. 🛠️ Todolist: Handling Optimistic UI errors
    23. 🛠️ Todolist: Editing tasks with Optimistic UI
    24. 🛠️ Todolist: Deleting tasks with Optimistic UI
    25. 🛠️ Todolist: Refactor
    26. 🛠️ Typeahead: How to add Ajax
    27. 🛠️ Typeahead: Adding Ajax
    28. 🛠️ Typeahead: Handling errors
    29. 🛠️ Google Maps Clone: Creating your first Google Map
    30. 🛠️ Google Maps Clone: Fetching JSONP via JavaScript
    31. 🛠️ Google Maps Clone: Drawing directions
    32. 🛠️ Google Maps Clone: Driving directions
    33. 🛠️ Google Maps Clone: Handling errors
    34. 🛠️ Google Maps Clone: Adding stopovers
    35. 🛠️ Google Maps Clone: Refactor
  14. Advanced Async JS
    1. Requesting many resources at once
    2. Asynchronous functions
    3. Handling multiple awaits
    4. Asynchronous loops
    5. 🛠️ Dota Heroes: Listing heroes
    6. 🛠️ Dota Heroes: Filtering heroes (Part 1)
    7. 🛠️ Dota Heroes: Filtering heroes (Part 2)
    8. 🛠️ Dota Heroes: Refactoring
    9. 🛠️ Dota Heroes: Hero Page
    10. 🛠️ Dota Heroes: Making the hero page robust
    11. 🛠️ Dota Heroes: Heroes page refactor
  15. Handling Keyboard Events
    1. Keyboard users
    2. Handling commonly used keys
    3. Keyboard events
    4. Understanding Tabindex
    5. Detecting the focused element
    6. Directing focus
    7. Preventing people from tabbing into elements
    8. How to choose keyboard shortcuts
    9. Creating single-key shortcuts
    10. 🛠️ Off-canvas: Adding keyboard interaction
    11. 🛠️ Modal: Adding keyboard interaction
    12. 🛠️ Accordion: Adding keyboard interaction
    13. 🛠️ Tabby: Adding keyboard interaction
    14. 🛠️ Tabby: Refactoring
    15. 🛠️ Carousel: Adding keyboard interaction
    16. 🛠️ Carousel: Displaying help text
    17. 🛠️ Calculator: Adding keyboard interaction
    18. 🛠️ Popover: Keyboard
    19. 🛠️ Popover: Refactor
    20. Keyboard shortcuts with Command and Control modifiers
    21. 🛠️ Todolist: Keyboard
    22. 🛠️ Typeahead: Keyboard
    23. 🛠️ Typeahead: Selecting a prediction with the keyboard
    24. 🛠️ Google Maps Clone: Keyboard
    25. 🛠️ Dota Heroes: Keyboard
    26. 🛠️ Datepicker: Tabbing in and out
    27. 🛠️ Datepicker: Keyboard shortcuts
  16. Screen reader accessibility
    1. What is accessibility?
    2. How to use a screen reader
    3. Using NVDA
    4. Using Voiceover
    5. Aria roles
    6. Landmark roles
    7. Document structure roles
    8. Live region roles
    9. Widget roles
    10. Window and Abstract roles
    11. Accessible names and descriptions
    12. Hiding content
    13. ARIA properties and ARIA states
    14. ARIA for expandable widgets
    15. 🛠️ Off-canvas: Accessibility
    16. ARIA for modal dialogs
    17. 🛠️ Modal: Screen reader accessibility
    18. 🛠️ Accordion: Screen reader accessibility
    19. ARIA for Tabbed components
    20. 🛠️ Tabby: Screen reader accessibility
    21. 🛠️ Tabby: Refactor
    22. 🛠️ Carousel: Screen reader accessibility
    23. Roles that trigger Forms and Application modes
    24. What's next for accessibility?
  17. Handling Scroll
    1. The Scroll event
    2. 🛠️ Auto-hiding Sticky-nav: HTML and CSS
    3. 🛠️ Auto-hiding Sticky-nav: JavaScript
    4. 🛠️ Auto-hiding Sticky-nav: Natural reveal
    5. Intersection Observer API
    6. Intersection Observer Options
    7. 🛠️ Slide & Reveal
    8. 🛠️ Slide & Reveal: Always fade-in when you scroll down
    9. 🛠️ Slide & Reveal: Fine-tuning the animation
    10. 🛠️ Infinite Scroll: Anatomy
    11. 🛠️ Infinite Scroll: Infinite load
    12. 🛠️ Infinite Scroll: Refactor
    13. 🛠️ Infinite Scroll: Implementing the Infinite Scroll
  18. Mouse, Touch, and Pointer events
    1. Mouse Events
    2. 🛠️ Spinning Pacman: HTML and CSS
    3. 🛠️ Spinning Pacman: JavaScript
    4. Touch events
    5. Pointer events
    6. Touch-action
    7. 🛠️ Spinning Pacman: Supporting Touch
    8. Cloning elements
    9. 🛠️ DragDrop: HTML and CSS
    10. 🛠️ DragDrop: JavaScript
    11. 🛠️ DragDrop: Creating a drop preview
    12. 🛠️ DragDrop: Sortable drop preview
    13. 🛠️ DragDrop: Robustness
    14. 🛠️ DragDrop: Refactor
  19. Object Oriented Programming
    1. Before we begin
    2. What is Object Oriented Programming?
    3. Four Flavours of Object Oriented Programming
    4. Inheritance
    5. This in JavaScript
    6. Call, bind, apply
    7. Creating Derivative Objects
    8. Composition vs Inheritance
    9. Polymorphism
    10. Encapsulation
    11. Closures
    12. Encapsulation in Object Oriented Programming
    13. Getters and Setters
    14. What OOP flavour to use
    15. When to use Object Oriented Programming
  20. Writing reusable code
    1. Creating reusable code by writing libraries
    2. Two Types of libraries
    3. Including libraries with Script tags
    4. Including libraries with ES6 Modules
    5. Dynamic imports
    6. 🛠️ Off Canvas: Building a Library
    7. 🛠️ Modal: Library setup
    8. 🛠️ Modal: Opening the Modal
    9. 🛠️ Modal: Closing the modal
    10. 🛠️ Modal: Inheritance and Polymorphism
    11. 🛠️ Modal: Resolving differences between subclasses
    12. 🛠️ Modal: Exposing properties and methods
    13. 🛠️ Accordion: Building a library
    14. 🛠️ Tabby: Building a library
    15. 🛠️ Carousel: Building a library
    16. 🛠️ Calculator: Library
    17. 🛠️ Calculator: Fixing the Clear Key
    18. 🛠️ Calculator: Handling other keys
    19. 🛠️ Calculator: State
    20. 🛠️ Popover: Library
    21. 🛠️ Popover: Adding event listeners
    22. 🛠️ Typeahead: Library
    23. 🛠️ DatePicker: Library
  21. Going from Vanilla JS to JS Frameworks
    1. 🛠️ Building a Tiny framework
    2. 🛠️ Tiny: Add event listeners
    3. 🛠️ Tiny: Updating state
    4. 🛠️ Tiny: Rendering Child Components
    5. 🛠️ Tiny: Changing Parent State
    6. 🛠️ Tiny: Passing Props
    7. 🛠️ Tiny: Multiple Props
    8. 🛠️ Tiny: Passing values from sibling components
    9. 🛠️ Tiny: Mounting
    10. 🛠️ Tiny: Passing props to descendants
    11. 🛠️ Tiny: A tiny refactor
  22. Single Page Apps
    1. What is a Single Page App?
    2. Simple SPA using only CSS
    3. The Location Interface
    4. The History Interface
    5. Minimum viable server for a SPA
    6. 🛠️ Dota SPA: Introduction
    7. 🛠️ Dota SPA: Building The Heroes List
    8. 🛠️ Dota SPA: Building the filters
    9. 🛠️ Dota SPA: Filtering heroes
    10. 🛠️ Dota SPA: Displaying filtered heroes
    11. 🛠️ Dota SPA: Getting Ready to build the Hero Page
    12. 🛠️ Dota SPA: Building the hero page
    13. 🛠️ Dota SPA: Lore and abilities
    14. 🛠️ Dota SPA: Routing for Single-page apps

🛠️ Todolist: Editing tasks

We want to allow users to edit two things:

  1. Check/uncheck the task
  2. Change the task name

Once again, anything with Ajax creates a set of interesting challenges. (You’ll see).

Checking/unchecking a task

When a user clicks on a checkbox, we want to check the checkbox. This completes the task. We also want to save the completed task to the server.

When the checkbox is checked (or unchecked), it fires a change event. We can listen for this change event to know if the user checks a checkbox. Since there are many checkboxes, we can use an event delegation pattern.

taskList.addEventListener('change', event => {
if (!event.target.matches('input[type="checkbox"]')) return
const checkbox = event.target
console.log(checkbox)
})
checkbox element logged into the console

The API lets us edit a task by sending a PUT request to /tasks/:id. This means we need to know the task id before we can send a request.

We can get the task id from the checkbox’s id attribute.

taskList.addEventListener('change', event => {
// ...
const checkbox = event.target
const id = checkbox.id
console.log(id)
})
ID of checkbox logged into the console.

We also need to know whether the task is done. If the task is done, the checkbox is checked. If the task is not done, the checkbox is unchecked.

taskList.addEventListener('change', event => {
// ...
const done = checkbox.checked
console.log(checked)
})
If the checkbox is checked, console logs true. Otherwise, console logs false.

We’ve fulfilled the requirements to send the PUT request. Let’s send it now.

taskList.addEventListener('change', event => {
// ...
const checkbox = event.target
const id = checkbox.id
const done = checkbox.checked
zlFetch
.put(`${rootendpoint}/tasks/${id}`, {
auth,
body: {
done,
},
})
.then(response => {
console.log(response.body)
})
.catch(error => console.error(error))
})

If the PUT request is successful, we should get a response from the server that contains the updated task.

Response from server contains updated task. It has the 'id', 'name' and 'done' properties.

Fetching done tasks

If you refresh the Todolist, you’ll notice the task you completed remains unchecked.

Check first task. Refresh page. First task remains unchecked.

This happens because we did not use the done property from the fetched tasks when we make task elements.

To ensure the completed task remains checked, we need to use the done. If done is true, we set the checkbox to checked.

function makeTaskElement({ id, name, done }) {
taskElement.innerHTML = DOMPurify.sanitize(`
<input
type="checkbox"
id="${id}"
${done ? 'checked' : ''}
/>
...
`)
}

The checkbox should remain checked now.

Check task. Refresh page. Task remains checked.

And if you uncheck the checkbox and refresh the page, the task should be unchecked.

Uncheck task. Refresh page. Task remains unchecked.

Editing the task name

The Todolist API lets us change the name of the task as well. If we want to allow users to change the name of the task, we need to let them edit the task in the UI first.

Allowing users to edit the task name

We can do this by changing the .task__name from a <span> element to an <input> element. (You have to style the <span> and <input> elements accordingly, but I did it for you already).

// Change this
function makeTaskElement ({ id, name, done }) {
task.innerHTML = DOMPurify.sanitize(`
...
<span class="task__name">${name}</span>
...
`)
})
// To this
function makeTaskElement ({ id, name, done }) {
// ...
task.innerHTML = DOMPurify.sanitize(`
...
<input class="task__name" value="${name}" />
...
`)
})

With this change, users should be able to edit a task.

Click on task name. Task becomes editable.

Choosing an event to listen to

We have two options here. We can either update the database when

  1. The user types into the input field
  2. The user removes focus from the input field

The option you choose determines the event you’ll listen for:

  1. Option 1: listen for input event
  2. Option 2: listen for blur event

Both options have their pros and cons.

If you choose option 1, you might send too many requests to the server. (Because you’ll trigger a PUT request whenever a user types into the input field).

If you choose option 2, there’s a chance you don’t send anything to the server. (If the user types into the input field, but closes the tab immediately, the input field doesn’t lose focus, and the request doesn’t get sent).

Which should you choose?

Here, we’ll choose option 1 because sending too many requests beats not updating the database according to our users’ actions. (Also, because there’s a way to reduce the number of requests we send).

Saving the task name to the database

As before, because there are many tasks in the DOM, the best way is to use an event delegation pattern.

taskList.addEventListener('input', event => {
if (!event.target.matches('.task__name')) return
// Do something
})

First, we need to find the input value:

taskList.addEventListener('input', event => {
if (!event.target.matches('.task__name')) return
const input = event.target
const inputValue = DOMPurify.sanitize(input.value.trim())
console.log(inputValue)
})
Editing task. Console shows task name on each keystroke

To update the Todolist API, we need to know the id of the task. We can find the id from the checkbox. And we can find the checkbox by traversing upwards to the task.

taskList.addEventListener('input', event => {
// ...
const taskElement = input.parentElement
const checkbox = taskElement.querySelector('input[type="checkbox"]')
const id = checkbox.id
console.log(id)
})
id from the checkbox of the edited task.

Once we know the checkbox’s id, we can update the task.

taskList.addEventListener('input', event => {
if (!event.target.matches('.task__name')) return
// ...
zlFetch
.put(`${rootendpoint}/tasks/${id}`, {
auth,
body: {
name: inputValue,
},
})
.then(response => {
console.log(response.body)
})
.catch(error => console.error(error))
})

The task should remain updated if you refresh the DOM.

Edited task remains updated after a refresh.

Updating task name and done at the same time

Did you know the input event fires whenever the checkbox checked state changes?

taskList.addEventListener('input', event => {
console.log(event.target)
// ...
})
Clicking on checkbox triggers a input event.

This means we can update done and name at the same time—with the input event. We don’t need two event listeners. (Less code, easier to read!).

We’ll work on this.

You can comment out (or delete) the change event listener now.

Updating the input event listener

First, we need to know we’re listening for two elements:

  1. A change in the checkbox’s checked state
  2. A change in the text value

This means event.target can either be the checkbox or the text field.

We need to find BOTH the checkbox and the text field with each event. The best way is to traverse up to the task element.

taskList.addEventListener('input', event => {
const taskElement = event.target.parentElement
const checkbox = taskElement.querySelector('input[type="checkbox"]')
const taskInput = taskElement.querySelector('.task__name')
console.log(checkbox)
console.log(taskInput)
})
Doesn't matter whether the user clicks the checkbox or edits the task. We get the checkbox and the text field for both events.

To update the task, we need three things—the checked state, the id, and the task name.

taskList.addEventListener('input', event => {
// ...
const id = checkbox.id
const done = checkbox.checked
const name = DOMPurify.sanitize(taskInput.value.trim())
})

Once we know these three values, we can send a PUT request to update the task.

taskList.addEventListener('input', event => {
// ...
zlFetch
.put(`${rootendpoint}/tasks/${id}`, {
auth,
body: {
name,
done,
},
})
.then(response => {
console.log(response.body)
})
.catch(error => console.error(error))
})
Both checkbox and task name are updated on refresh.

Sending fewer requests

Since we used the input event, we send one request every time a user edits a task. That’s a lot of requests!

Sends one PUT request per input key

We want to reduce the number of requests we send because of two reasons.

First, each request cost money for the user. Requests and responses require data. More usage of data means we make users spend more money (especially if they don’t have an unlimited data plan).

Second, each request means work for the server. If we reduce requests, servers do less work. This is why many APIs have rate-limits.

How to send fewer requests

Did you notice that requests that are sent earlier get overwritten by requests that are sent later?

Since requests that are sent earlier get overwritten, it means we only need to send out the final request. (The request when a user finished editing the task).

We know the user finished editing the task when they stop typing. The best way to tell when they stop typing is use the amount of time between keystrokes as a proxy. If the user does not type anything for an amount of time, we can assume they have stopped typing.

In code, here’s what we’ll do:

  1. Set a timeout when a user begins typing. Let’s say we set the timeout for 1 second (1000ms).
  2. If the user types something in the next second, we restart the timeout for another second.
  3. If the user doesn’t type anything in the next second, we assume they stopped typing. At this point, we send the request.

The actual implementation of this timeout function is called debounce. It looks like this:

function debounce(callback, wait, immediate) {
let timeout
return function () {
const context = this
const args = arguments
const later = function () {
timeout = null
if (!immediate) callback.apply(context, args)
}
const callNow = immediate && !timeout
clearTimeout(timeout)
timeout = setTimeout(later, wait)
if (callNow) callback.apply(context, args)
}
}

Basically, debounce lets you:

  1. Set a timer for X milliseconds.
  2. If the debounced function gets called again within X milliseconds, restart the timer.
  3. If X milliseconds passed and debounced function did not get called, trigger the callback.

(I won’t be explaining how to build debounce in this course. You will be able to figure it out after learning about apply and other advanced JavaScript features later).

Here’s how you use debounce:

const debouncedFunction = debounce(callback, wait)

If you want to wait for 1 second (1000ms), you set wait to 1000.

const debouncedFunction = debounce(callback, 1000)

callback is the function we want to call. In this case, it’s the callback for the event listener.

const debouncedFunction = debounce(event => {
const taskElement = event.target.parentElement
const checkbox = taskElement.querySelector('input[type="checkbox"]')
const taskInput = taskElement.querySelector('.task__name')
const id = checkbox.id
const done = checkbox.checked
const name = DOMPurify.sanitize(taskInput.value.trim())
zlFetch
.put(`${rootendpoint}/tasks/${id}`, {
auth,
body: {
name,
done,
},
})
.then(response => {
console.log(response.body)
})
.catch(error => console.error(error))
}, 1000)

Finally, we want to trigger debouncedFunction when the user edits a task.

taskList.addEventListener('input', debouncedFunction)
Task debounced for one second.

Putting it together in one step:

taskList.addEventListener(
'input',
debounce(event => {
const taskElement = event.target.parentElement
const checkbox = taskElement.querySelector('input[type="checkbox"]')
const taskInput = taskElement.querySelector('.task__name')
const id = checkbox.id
const done = checkbox.checked
const name = DOMPurify.sanitize(taskInput.value.trim())
zlFetch
.put(`${rootendpoint}/tasks/${id}`, {
auth,
body: {
name,
done,
},
})
.then(response => {
console.log(response.body)
})
.catch(error => console.error(error))
}, 1000),
)

Don’t wait for too long

Debounce can introduce a problem if you wait too long. In the example below, one request was sent even though three tasks were changed.

Task 1 and task 2 did not get saved. Task 3 did.

This happened because we debounced all input events on <ul>.

One way to fix the problem is to listen (and debounce) input events for each task (which means we don’t use the event delegation pattern). The downside to this approach is we have lots of event listeners.

Another way to fix the debounce problem is simply to reduce the debounce duration. In this example, I reduced the debounced duration to 250ms and all three tasks got saved.

taskList.addEventListener('input', debounce(/*...*/, 250))
Changed three tasks quickly. All tasks were saved.

What you choose depends on your situation. In this case, I’d say setting a debounce to 250ms works.