JavaScript Fundamentals — Free Sample

1. What's the difference between `var`, `let`, and `const` in JavaScript with respect to scoping?

All three have function scope; only the value-assignment behavior differs. `var` has function scope; `let` and `const` have block scope; the temporal-dead-zone applies to `let` and `const` between their hoisted declaration and their initialization. All three have block scope in modern JavaScript; legacy `var` behavior was removed in ES6. `var` and `let` have function scope; `const` adds block scope.

2. Which of these correctly captures each loop-iteration's value in the closure passed to `setTimeout`?

`for (var i = 0; i < 3; i++) setTimeout(() => console.log(i), 0);` `for (let i = 0; i < 3; i++) setTimeout(() => console.log(i), 0);` `for (var i = 0; i < 3; i++) setTimeout(function() { console.log(i); }, 0);` Both `var`-based options work identically because closures always capture the current value at function-creation time.

3. What does `await` do inside an `async` function?

Pauses synchronous execution of the function until the awaited Promise resolves; does not block the JavaScript event loop; the function continues with the resolved value once the Promise settles. Blocks the entire JavaScript event loop until the Promise resolves. Converts a synchronous function into an asynchronous one at runtime. Throws an error if the Promise has not resolved within 5 seconds.

4. How does `this` binding differ between an arrow function and a regular function in JavaScript?

Arrow functions don't have their own `this`; they inherit `this` lexically from the enclosing scope. Regular functions have a `this` determined by how they're called (method, constructor, plain function call, or via `bind`/`call`/`apply`). Both bind `this` to the global object unless explicitly bound otherwise. Arrow functions always bind `this` to the global object; regular functions bind to the calling object. There's no difference in modern JavaScript; the distinction was removed in ES2020.

5. What's the difference between the spread operator (`...arr`) used in an array literal and the rest operator (`...args`) used in a function parameter list?

Spread expands an iterable into individual elements at the call site; rest collects multiple arguments into a single array parameter inside the function definition. Same syntax, opposite directions of data flow. They're identical; the names are interchangeable. Spread works on objects only; rest works on arrays only. Spread is a runtime operation; rest is a compile-time syntactic transformation.

Your directional indicator

This 5-question sample gives a rough indication only. For a valid, verified Skills Passport credential, take the full 50-question assessment — it takes about 30 minutes.

Coming soon

Full assessment launching soon