ColorCode

VideosCoursesPodcastMerchLogin

JavaScript
MasterClass

Available Soon

  • Hello World!

    Get oriented to the course and see how the fundamentals connect to the browser project you’ll build later.

  • Why JavaScript in 2027

    Explore where JavaScript runs and how it turns static pages into interactive experiences.

  • How to succeed

    Set up a practice routine that gives you time to write code, test your understanding, and revisit tricky concepts.

  • AI and the power of fundamentals

    See how JavaScript fundamentals help you assess AI-generated code, verify what it does, and debug it when it behaves unexpectedly.

  • How code works

    Follow a small program line by line as JavaScript evaluates expressions, runs statements, and keeps track of values.

  • How to write JavaScript

    Write and run a short JavaScript program, then change an expression and compare the output.

  • Setup

    Set up your editor and browser tools so you can run examples and experiment as you go.

  • Debugging

    Read an error message, narrow down the problem, and inspect values with the browser debugger.

  • What are variables?

    Use variables to name values and follow how those values are read or reassigned as a program runs.

  • Numbers

    Work with integers and decimals, and learn what results like NaN, Infinity, and rounding errors tell you.

  • Strings

    Build, inspect, and combine text using string literals, template literals, and common string methods.

  • Booleans

    Use true and false to represent decisions and track conditions in a program.

  • Objects

    Group related values under named properties, then read and update those properties.

  • Arrays

    Store an ordered collection, access items by index, and use common methods to add or remove entries.

  • Undefined and Null

    Distinguish a missing or uninitialized value from an explicitly empty one, and decide how to handle each case.

  • Let, Cost, Var

    Choose a declaration based on scope and reassignment, and recognize var when you encounter older code.

  • Primitives vs. Objects

    Compare how primitive values and objects behave when you assign them, compare them, or pass them to a function.

  • What are operators?

    Read an expression by identifying its operators and operands, then work out the value it produces.

  • Arithmetic

    Perform calculations with JavaScript’s arithmetic operators and use parentheses to make the order explicit.

  • Assignment

    Assign a value and use compound assignments to update it based on its current value.

  • Comparison

    Compare values with equality and ordering operators, and see when coercion affects the result.

  • Logical

    Combine or invert conditions with AND, OR, and NOT, and see how those operators pick the value they return.

  • Ternary

    Use a conditional expression to choose between two values without interrupting a surrounding expression.

  • String

    Join strings and see how adding a string to another value can affect the result.

  • Nullish

    Use the nullish coalescing operator to supply a fallback while preserving values such as zero and an empty string.

  • Optional chaining

    Use optional chaining to access a property or call a method when part of a chain might be null or undefined.

  • Spread

    Expand an iterable into values or copy an object’s own enumerable properties into a new object.

  • Delete

    Remove an object property and see how deletion differs from assigning undefined to it.

  • Typeof

    Use typeof to check a value’s type and recognize cases that need a more specific check.

  • Instanceof

    Check whether an object’s prototype chain contains a constructor’s prototype.

  • What are conditionals?

    Make a program choose what to do based on the result of an expression.

  • If/else statements

    Write branches for different inputs and follow how JavaScript selects the first matching branch.

  • Switch statements

    Match a value against several cases and use break and default to control what happens next.

  • Truth and Falsy

    Recognize which values JavaScript treats as true or false in a condition.

  • Short circuit evaluation

    Predict when AND or OR skips its right-hand expression, and use that behavior in a practical guard.

  • What are functions?

    Turn a repeated operation into a reusable block of code that you can call with different inputs.

  • Function syntax

    Read and write function declarations, function expressions, and arrow functions.

  • Input

    Pass arguments into a function, give parameters meaningful names, and supply default values where useful.

  • Output

    Return a value to the caller and trace what happens when execution reaches return or falls through.

  • Existing functions

    Read a built-in function’s signature and use its inputs and return value in your own code.

  • Different types of functions

    Choose between declarations, expressions, and arrow functions based on how they’ll be used.

  • Closures

    See how a function keeps access to variables from the scope in which it was created.

  • Classes

    Define a class with a constructor and methods, then see how class syntax uses prototypes.

  • What are loops?

    Identify work that needs to repeat and decide what should stop the loop.

  • For loop

    Write a counted loop and follow how its initializer, condition, and update determine each iteration.

  • While loop

    Repeat an operation while a condition holds and check that the loop makes progress toward stopping.

  • For Of

    Use for...of to read values from arrays, strings, and other iterables.

  • ForEach

    Run a callback for each array item and choose forEach when you need to perform an action for each item.

  • Array iterators

    Transform, select, order, or combine array items with the method that matches your goal.

  • For In

    Iterate over enumerable string keys and see when inherited properties are included.

  • Looping through objects

    Choose between Object.keys, Object.values, and Object.entries to pull out the parts of an object you need.

  • What is scope

    Determine which variables a piece of code can read based on where those variables were declared.

  • Lexical scope & closures

    Trace a nested function’s variable lookup and see what it can still access after its outer function returns.

  • Hoisting

    Work out what is available before a declaration runs, including differences between functions, var, let, and const.

  • The THIS keyword

    Predict what this refers to from the way a function is called, and see how arrows capture it from their surroundings.

  • Avoiding scope pitfalls

    Recognize accidental globals and variable shadowing, and use clear declarations to make scope easier to follow.

  • What is a sync?

    See how JavaScript can start a slow operation, continue other work, and handle the result when it’s ready.

  • Callbacks

    Pass a function to another operation to decide what should happen when it completes.

  • Promises

    Follow a promise from pending to fulfillment or rejection and chain work that depends on its result.

  • Async Await

    Use async and await to express asynchronous steps in order and handle rejections with try and catch.

  • Promise.all

    Wait for a group of independent promises and see what happens if one rejects.

  • Fetch API

    Request data with fetch, check the HTTP status, and read the response body.

  • Error handling

    Handle failures where you can recover and pass unexpected errors back to the caller.

  • Abort Controller

    Cancel a request with an abort signal when its result is no longer needed.

  • What is the Event Loop?

    Put the call stack, task queue, and microtask queue together to predict the order of mixed synchronous and asynchronous code.

  • What are browsers?

    Explore how browsers load resources, run JavaScript, and turn HTML and CSS into a page you can use.

  • The DOM

    Find elements in the document tree and update their text, attributes, or structure.

  • Events & Listeners

    Listen for user actions and trace how events move through the document.

  • Forms

    Read submitted values, respond to a form’s submit event, and give the user feedback.

  • Cookies

    See how browsers store small values in cookies and when those values accompany HTTP requests.

  • LocalStorage

    Save simple preferences across visits, and serialize structured values before storing them.

  • SessionStorage

    Store data for the lifetime of a browser tab and compare when to use sessionStorage or localStorage.

  • Importing & Exporting Modules

    Share functionality between files using named and default exports, then import it where it’s needed.

  • Splitting Code into Modules

    Organize a small feature across modules and follow its dependencies from the entry point.

  • Build a Web App

    Build WeatherOrNot, an interactive weather app that fetches live data, updates the DOM, and saves user preferences.

  • Writing Test Cases

    Write test cases for the app’s expected behavior, including what happens when the weather request fails.