Intermediate JavaScript is where a huge amount of real front-end and Node code actually lives: closures, arrow functions, array methods like map/filter/reduce used instead of manual loops, and destructuring. It is genuinely productive — and it is also where two of the most-cited JavaScript surprises live: a var-in-a-loop closure that captures the wrong value, and a lost `this` binding when a method is passed around as a plain function reference.
What "Intermediate" Actually Covers
Closures — functions that retain access to variables from their enclosing scope even after that scope has finished executing — and a real, working understanding of how let/const scoping inside a loop differs from var. Arrow functions and their lexical `this`, versus regular functions and their call-site-determined `this`.
Array methods used declaratively: map, filter, reduce, forEach, and find, instead of manual for loops. Destructuring for objects and arrays, the spread/rest operators, and default parameters. Basic error handling with try/catch around synchronous code that might throw.
Where It Breaks
- A var declared inside a loop, captured by a closure (often inside setTimeout or an event listener), where every callback ends up reading the loop's final value instead of its value at that specific iteration
- A regular function used as a callback losing its intended `this` binding, because `this` depends on how the function is called, not where it was defined
- A shallow spread copy that looks independent and is not, because nested objects or arrays inside it are still shared with the original
- Array method chains (`.map().filter()`) that silently produce the wrong result because the callback's return value was assumed rather than checked — a very easy mistake when the callback is a one-line arrow function
- Mutating an array or object that is also referenced elsewhere (a common React/Vue-adjacent bug: mutating state directly instead of creating a new copy) and getting a component that does not re-render, because the reference itself never changed
The pattern across all five: intermediate JavaScript tools are correct and genuinely powerful, and each has one specific, well-documented edge — closures over the wrong variable, this depending on call-site, shallow copies looking deep — where an assumption that held in a simple example stops holding the moment a callback, a loop, or nested data enters the picture.
What to Put on a CV at This Level
"Intermediate JavaScript: closures, scope (let/const vs var), arrow functions/this, array methods (map/filter/reduce), destructuring" is accurate and matches what most job ads asking for "solid JavaScript" actually want — building a working, predictable module from scratch, not just modifying one that already exists.
What would overstate it: claiming "advanced JavaScript" on the strength of using .map() correctly. Advanced work, covered next, is specifically about asynchronous code and the event loop — a distinct, testable claim that most intermediate JavaScript never actually exercises.
The Next Rung
Advanced JavaScript is built around Promises and async/await, understanding that JavaScript is single-threaded with a task queue (the event loop), and knowing specifically that microtasks (Promise callbacks) run before macrotasks (setTimeout callbacks) — a scheduling detail that changes execution order in ways that surprise people reasoning about async code line by line.
The JavaScript Test scores scope/functions and async/runtime fundamentals separately across its 30 questions, which is a fast way to see specifically whether closures or this-binding is the actual gap holding an intermediate score back. Pairing it with the SQL Test is common for full-stack roles that expect both front-end logic and query-writing.
Why Intermediate JavaScript Is Where Most Real Front-End Code Sits
It is worth saying plainly: intermediate is not a consolation tier. A large share of UI logic, form handling and data transformation code never directly touches a Promise chain or the microtask queue, and does not need to — the closures-and-array-methods toolkit here is a complete, employable skill on its own.
The honest reason to push further is that almost any real application eventually fetches data, waits on a timer, or reacts to a user event asynchronously — and that is exactly where the advanced tier's subject matter becomes unavoidable. If that describes the work ahead, it is worth the time. If it does not yet, intermediate JavaScript done carefully — with closures and this-binding genuinely understood — is a complete and trustworthy skill.