- 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.
JavaScriptMasterClass
Available Soon
- 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.