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

๐Ÿ› ๏ธ Calculator: Handling other keys

We have three more types of keys to handle:

  1. Decimal
  2. Operator
  3. Equal

Letโ€™s work on Decimal keys first.

Handling Decimal keys

First, we include tests that include Decimal keys into test.calculator.js.

const tests = [
{
message: 'Number key',
keys: ['2'],
result: '2',
},
{
message: 'Number Number',
keys: ['3', '5'],
result: '35',
},
{
message: 'Number Decimal',
keys: ['4', 'decimal'],
result: '4.',
},
{
message: 'Number Decimal Number',
keys: ['4', 'decimal', '5'],
result: '4.5',
},
]

Errors should show up since we havenโ€™t handled decimal keys yet.

Tests fail when they include decimal key.

Weโ€™ll handle Decimal keys by uncommenting the decimal part in handleClick.

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'decimal':
handleDecimalKey(calculator)
break
// case 'operator': handleOperatorKeys(calculator, button); break
// case 'equal': handleEqualKey(calculator); break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

This is the code we wrote to handle decimal keys previously:

function handleDecimalKey(calculator) {
const displayValue = getDisplayValue()
const { previousButtonType } = calculator.dataset
if (!displayValue.includes('.')) {
display.textContent = displayValue + '.'
}
if (previousButtonType === 'equal') {
resetCalculator()
display.textContent = '0.'
}
if (previousButtonType === 'operator') {
display.textContent = '0.'
}
}

We will copy this code into Calculator as a method.

export default function Calculator() {
// Variables
const calculator = {
// ...
handleDecimalKey(calculator) {
const displayValue = getDisplayValue()
const { previousButtonType } = calculator.dataset
if (!displayValue.includes('.')) {
display.textContent = displayValue + '.'
}
if (previousButtonType === 'equal') {
resetCalculator()
display.textContent = '0.'
}
if (previousButtonType === 'operator') {
display.textContent = '0.'
}
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

Weโ€™ll make the changes we did for other methods:

  1. Change calculator to calculatorElement
  2. Omit calculatorElement from parameters
  3. Use calculator.displayValue getters and setters
  4. Change resetCalculator to calculator.resetCalculator
export default function Calculator() {
// Variables
const calculator = {
// ...
handleDecimalKey() {
const displayValue = calculator.displayValue
const { previousButtonType } = calculatorElement.dataset
if (!displayValue.includes('.')) {
calculator.displayValue = displayValue + '.'
}
if (previousButtonType === 'operator') {
calculator.displayValue = '0.'
}
if (previousButtonType === 'equal') {
calculator.resetCalculator()
calculator.displayValue = '0.'
}
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

We use handleDecimalKey like this:

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'decimal':
calculator.handleDecimalKeys()
break
// case 'operator': handleOperatorKeys(calculator, button); break
// case 'equal': handleEqualKey(calculator); break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

Errors related to decimal keys should now be gone.

Errors related to decimal keys are gone.

Weโ€™ll handle operator keys next.

Handling Operator Keys

First, we uncomment the part we use to handle operator keys.

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'operator':
handleOperatorKeys(calculator, button)
break
// case 'equal': handleEqualKey(calculator); break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

Hereโ€™s the code we wrote to handle operator keys:

function handleOperatorKeys(calculator, button) {
const displayValue = getDisplayValue()
const { previousButtonType, firstValue, operator } = calculator.dataset
const secondValue = displayValue
button.classList.add('is-pressed')
if (
previousButtonType !== 'operator' &&
previousButtonType !== 'equal' &&
firstValue &&
operator
) {
const result = calculate(firstValue, operator, secondValue)
display.textContent = result
calculator.dataset.firstValue = result
} else {
calculator.dataset.firstValue = displayValue
}
calculator.dataset.operator = button.dataset.key
}

Weโ€™ll copy this code into Calculator as a method.

export default function Calculator() {
// Variables
const calculator = {
// ...
handleOperatorKeys(calculator, button) {
const displayValue = getDisplayValue()
const { previousButtonType, firstValue, operator } = calculator.dataset
const secondValue = displayValue
button.classList.add('is-pressed')
if (
previousButtonType !== 'operator' &&
previousButtonType !== 'equal' &&
firstValue &&
operator
) {
const result = calculate(firstValue, operator, secondValue)
display.textContent = result
calculator.dataset.firstValue = result
} else {
calculator.dataset.firstValue = displayValue
}
calculator.dataset.operator = button.dataset.key
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

Weโ€™ll make the same treatments:

  1. Change calculator to calculatorElement
  2. Omit calculatorElement from parameters
  3. Use calculator.displayValue getters and setters
export default function Calculator() {
// Variables
const calculator = {
// ...
handleOperatorKeys(button) {
const displayValue = calculator.displayValue
const { previousButtonType, firstValue, operator } =
calculatorElement.dataset
const secondValue = displayValue
button.classList.add('is-pressed')
if (
previousButtonType !== 'operator' &&
previousButtonType !== 'equal' &&
firstValue &&
operator
) {
const result = calculate(firstValue, operator, secondValue)
display.textContent = result
calculatorElement.dataset.firstValue = result
} else {
calculatorElement.dataset.firstValue = displayValue
}
calculatorElement.dataset.operator = button.dataset.key
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

handleOperatorKeys need a calculate function to work. Hereโ€™s what we wrote for calculate previously.

function calculate(firstValue, operator, secondValue) {
firstValue = parseFloat(firstValue)
secondValue = parseFloat(secondValue)
if (operator === 'plus') return firstValue + secondValue
if (operator === 'minus') return firstValue - secondValue
if (operator === 'times') return firstValue * secondValue
if (operator === 'divide') return firstValue / secondValue
}

Weโ€™ll create a calculate method in Calculator and paste the code in.

export default function Calculator() {
// Variables
const calculator = {
// ...
calculate(firstValue, operator, secondValue) {
firstValue = parseFloat(firstValue)
secondValue = parseFloat(secondValue)
if (operator === 'plus') return firstValue + secondValue
if (operator === 'minus') return firstValue - secondValue
if (operator === 'times') return firstValue * secondValue
if (operator === 'divide') return firstValue / secondValue
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

We use calculate like this:

export default function Calculator() {
// Variables
const calculator = {
// ...
handleOperatorKeys(button) {
// ...
if (
previousButtonType !== 'operator' &&
previousButtonType !== 'equal' &&
firstValue &&
operator
) {
const result = calculator.calculate(firstValue, operator, secondValue)
// ...
} else {
// ...
}
// ...
},
// Other methods
// Listeners
}
// Add Event Listeners
// Return the calculator
}

Weโ€™ll use handleOperatorKeys like this

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'operator':
calculator.handleOperatorKeys(button)
break
// case 'equal': handleEqualKey(calculator); break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

Errors related to testClearAfterCalculation should now be gone since we have firstValue and operator in the calculatorโ€™s dataset.

At this point, we can include every test we created for the calculator into calculator.test.js.

const tests = [
// Initial Expressions
{
message: 'Number key',
keys: ['2'],
result: '2',
},
{
message: 'Number Number',
keys: ['3', '5'],
result: '35',
},
{
message: 'Number Decimal',
keys: ['4', 'decimal'],
result: '4.',
},
{
message: 'Number Decimal Number',
keys: ['4', 'decimal', '5'],
result: '4.5',
},
// Calculations
{
message: 'Addition',
keys: ['2', 'plus', '5', 'equal'],
result: '7',
},
{
message: 'Subtraction',
keys: ['5', 'minus', '9', 'equal'],
result: '-4',
},
{
message: 'Multiplication',
keys: ['4', 'times', '8', 'equal'],
result: '32',
},
{
message: 'Division',
keys: ['5', 'divide', '1', '0', 'equal'],
result: '0.5',
},
// Easy Edge Cases
// Number keys first
{
message: 'Number Equal',
keys: ['5', 'equal'],
result: '5',
},
{
message: 'Number Decimal Equal',
keys: ['2', 'decimal', '4', '5', 'equal'],
result: '2.45',
},
// Decimal keys first
{
message: 'Decimal key',
keys: ['decimal'],
result: '0.',
},
{
message: 'Decimal Decimal',
keys: ['2', 'decimal', 'decimal'],
result: '2.',
},
{
message: 'Decimal Decimal',
keys: ['2', 'decimal', '5', 'decimal', '5'],
result: '2.55',
},
{
message: 'Decimal Equal',
keys: ['2', 'decimal', 'equal'],
result: '2',
},
// Equal key first
{
message: 'Equal',
keys: ['equal'],
result: '0',
},
{
message: 'Equal Number',
keys: ['equal', '3'],
result: '3',
},
{
message: 'Number Equal Number',
keys: ['5', 'equal', '3'],
result: '3',
},
{
message: 'Equal Decimal',
keys: ['equal', 'decimal'],
result: '0.',
},
{
message: 'Number Equal Decimal',
keys: ['5', 'equal', 'decimal'],
result: '0.',
},
{
message: 'Calculation + Operator',
keys: ['1', 'plus', '1', 'equal', 'plus', '1', 'equal'],
result: '3',
},
// Operator Keys first
{
message: 'Operator Decimal',
keys: ['times', 'decimal'],
result: '0.',
},
{
message: 'Number Operator Decimal',
keys: ['5', 'times', 'decimal'],
result: '0.',
},
{
message: 'Number Operator Equal',
keys: ['7', 'divide', 'equal'],
result: '1',
},
{
message: 'Number Operator Operator',
keys: ['9', 'times', 'divide'],
result: '9',
},
// Difficult edge cases
// Operator calculation
{
message: 'Operator calculation',
keys: ['9', 'plus', '5', 'plus'],
result: '14',
},
{
message: 'Operator follow-up calculation',
keys: ['1', 'plus', '2', 'plus', '3', 'plus', '4', 'plus', '5', 'plus'],
result: '15',
},
// Equal followup calculation
{
message: 'Number Operator Equal Equal',
keys: ['9', 'minus', 'equal', 'equal'],
result: '-9',
},
{
message: 'Number Operator Number Equal Equal',
keys: ['8', 'minus', '5', 'equal', 'equal'],
result: '-2',
},
]

Tests which contain Equal keys will not work (because we havenโ€™t handled the Equal key yet). But other tests should pass. Hereโ€™s a list of tests thatโ€™ll fail at this point.

Tests that fail because we handle the equal key.

Handle Equal Keys

Again, we will begin by uncommenting the part we use to handle equal keys.

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'equal':
handleEqualKey(calculator)
break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

Hereโ€™s what we wrote to handle Equal previously.

function handleEqualKey(calculator) {
const displayValue = getDisplayValue()
const { firstValue, operator, modifierValue } = calculator.dataset
const secondValue = modifierValue || displayValue
if (firstValue && operator) {
const result = calculate(firstValue, operator, secondValue)
display.textContent = result
calculator.dataset.firstValue = result
calculator.dataset.modifierValue = secondValue
} else {
display.textContent = parseFloat(displayValue) * 1
}
}

Weโ€™ll copy this code into Calculator as a method.

export default function Calculator() {
// Variables
const calculator = {
// ...
handleEqualKey(calculator) {
const displayValue = getDisplayValue()
const { firstValue, operator, modifierValue } = calculator.dataset
const secondValue = modifierValue || displayValue
if (firstValue && operator) {
const result = calculate(firstValue, operator, secondValue)
display.textContent = result
calculator.dataset.firstValue = result
calculator.dataset.modifierValue = secondValue
} else {
display.textContent = parseFloat(displayValue) * 1
}
},
// Other methods
// Listeners
}
// Add event listeners
// Return calculator
}

And weโ€™ll make the usual changes:

  1. Change calculator to calculatorElement
  2. Omit calculatorElement from parameters
  3. Use calculator.displayValue getters and setters
  4. Use calculator.calculate
export default function Calculator() {
// Variables
const calculator = {
// ...
handleEqualKey() {
const displayValue = calculator.displayValue
const { firstValue, operator, modifierValue } = calculatorElement.dataset
const secondValue = modifierValue || displayValue
if (firstValue && operator) {
const result = calculator.calculate(firstValue, operator, secondValue)
calculator.displayValue = result
calculatorElement.dataset.firstValue = result
calculatorElement.dataset.modifierValue = secondValue
} else {
calculator.displayValue = parseFloat(displayValue) * 1
}
},
// Other methods
// Listeners
}
// Add event listeners
// Return calculator
}

We use handleEqualKey like this:

export default function Calculator() {
// Variables
const calculator = {
// Other methods
handleClick(event) {
// ...
switch (buttonType) {
// ...
case 'equal':
calculator.handleEqualKey()
break
}
// ...
},
}
// Add Event Listeners
// Return the calculator
}

All tests should pass. There should be no error left.

No errors left

One final thing to do.

Adding Keyboard Functionality

Hereโ€™s the code we used to add keyboard functionality:

calculator.addEventListener('keydown', event => {
let key = event.key
// Operator keys
if (key === '+') key = 'plus'
if (key === '-') key = 'minus'
if (key === '*') key = 'times'
if (key === '/') key = 'divide'
// Special keys
if (key === '.') key = 'decimal'
if (key === 'Backspace') key = 'clear'
if (key === 'Escape') key = 'clear'
if (key === 'Enter') key = 'equal'
if (key === '=') key = 'equal'
const button = calculator.querySelector(`[data-key="${key}"]`)
if (!button) return
event.preventDefault()
button.click()
})

Weโ€™ll start by creating a event listener inside Calculator.

export default function Calculator() {
// ...
calculatorElement.addEventListener('keydown', event => {
/* ... */
})
// Return calculator
}

Weโ€™ll name the callback handleKeydown

export default function Calculator() {
// Variables
const calculator = {
// ...
handleKeydown(event) {
// ...
},
}
calculatorElement.addEventListener('keydown', calculator.handleKeydown)
// Return calculator
}

Weโ€™ll copy-paste the code weโ€™ve written into handleKeydown.

export default function Calculator () {
// Variables
const calculator = {
// ...
handleKeydown (event) {
let key = event.key
// Operator keys
if (key === '+') key = 'plus'
if (key === '-') key = 'minus'
if (key === '*') key = 'times'
if (key === '/') key = 'divide'
// Special keys
if (key === '.') key = 'decimal'
if (key === 'Backspace') key = 'clear'
if (key === 'Escape') key = 'clear'
if (key === 'Enter') key = 'equal'
if (key === '=') key = 'equal'
const button = calculator.querySelector(`[data-key="${key}"]`)
if (!button) return
event.preventDefault()
button.click()
}
// Add event listeners
// Return calculator
}

And weโ€™ll change calculator to calculatorElement.

export default function Calculator () {
// Variables
const calculator = {
// ...
handleKeydown (event) {
// ...
const button = calculatorElement.querySelector(`[data-key="${key}"]`)
// ...
}
// Add event listeners
// Return calculator
}

You should be able use the calculator with the keyboard now.

Thatโ€™s it!