Full Stack Web Development JavaScript Programming Syllabus

JavaScript Programming syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for JavaScript Programming in Full Stack Web Development, not a summary of it.

1. 1

   JavaScript Core Syntax

   4 topics

   • Variables and Data Types
     • var, let and const
     • Primitive and reference types
     • Type coercion and conversion
   • Operators and Expressions
     • Arithmetic and assignment operators
     • Comparison (== vs ===)
     • Logical and ternary operators
   • Control Flow
     • if/else and switch
     • for, while and do-while loops
     • break and continue
   • Functions
     • Function declarations and expressions
     • Arrow functions
     • Parameters, defaults and rest
     • Scope and hoisting
2. 2

   Working with Data Structures

   4 topics

   • Arrays
     • Array creation and indexing
     • Iteration methods (map, filter, reduce)
     • forEach, find and sort
   • Objects
     • Object literals and properties
     • Methods and the this keyword
     • Destructuring and spread
   • Strings and Template Literals
     • String methods
     • Template strings and interpolation
   • Maps, Sets and JSON
     • Map and Set collections
     • JSON.parse and JSON.stringify
3. 3

   DOM and Browser APIs

   4 topics

   • DOM Manipulation
     • Selecting elements (querySelector)
     • Creating and modifying nodes
     • Changing styles and classes
   • Event Handling
     • addEventListener and event objects
     • Event bubbling and delegation
     • Preventing default behaviour
   • Browser Storage
     • localStorage and sessionStorage
     • Cookies basics
   • Timers and Web APIs
     • setTimeout and setInterval
     • Geolocation and History API
4. 4

   Modern JavaScript (ES6+)

   4 topics

   • ES6 Features
     • Classes and inheritance
     • Modules (import/export)
     • Symbols and iterators
   • Asynchronous JavaScript
     • Callbacks and the event loop
     • Promises and chaining
     • async/await syntax
   • Fetching Data
     • Fetch API and Promises
     • Handling JSON responses
     • Error handling with try/catch
   • Functional Programming Concepts
     • Pure functions and immutability
     • Higher-order functions and closures

JavaScript Programming flashcards for Full Stack Web Development

20 of 50 cards from the JavaScript Programming deck — real questions with worked answers.

1. In JavaScript, what is the difference between let, const, and var in terms of scope?

   var is function-scoped (or global) and hoisted; let and const are block-scoped. const additionally cannot be reassigned after initialization.

2. What are the seven primitive data types in JavaScript?

   string, number, boolean, null, undefined, symbol, and bigint. Everything else is an object.

3. What does the typeof operator return for null, and why is this notable?

   It returns "object". This is a long-standing bug in JavaScript kept for backward compatibility; null is actually a primitive.

4. What is the difference between undefined and null?

   undefined means a variable has been declared but not assigned a value; null is an intentional assignment representing 'no value'.

5. What is the difference between == and === in JavaScript?

   == compares values after type coercion (loose equality); === compares both value and type without coercion (strict equality).

6. What does the ternary operator look like and what does it do?

   condition ? valueIfTrue : valueIfFalse. It is a shorthand conditional expression that returns one of two values based on the condition.

7. What does the nullish coalescing operator (??) do?

   It returns the right-hand operand only when the left-hand is null or undefined (not for other falsy values like 0 or '').

8. How does the logical OR (||) operator behave with falsy values for default assignment?

   It returns the first truthy operand, or the last operand if all are falsy. So 0 || 'x' returns 'x', unlike ?? which would return 0.

9. What are the six falsy values in JavaScript besides false?

   0, '' (empty string), null, undefined, NaN, and -0. Plus false and 0n (BigInt zero).

10. What is the difference between the prefix (++x) and postfix (x++) increment operators?

    Prefix ++x increments then returns the new value; postfix x++ returns the original value then increments.

11. What is the difference between a for...of loop and a for...in loop?

    for...of iterates over the values of an iterable (arrays, strings); for...in iterates over the enumerable keys/property names of an object.

12. What does the break statement do versus the continue statement in a loop?

    break exits the loop entirely; continue skips the rest of the current iteration and proceeds to the next one.

13. What is the difference between a while loop and a do...while loop?

    A while loop checks the condition before executing the body (may run zero times); a do...while loop executes the body once before checking, guaranteeing at least one run.

14. How does a switch statement use the break keyword, and what happens without it?

    break stops execution after a matching case. Without it, execution 'falls through' to subsequent cases until a break or the switch ends.

15. What is the difference between a function declaration and a function expression regarding hoisting?

    Function declarations are fully hoisted and callable before definition; function expressions are not (only the variable is hoisted, not the assignment).

16. How do arrow functions differ from regular functions regarding the 'this' keyword?

    Arrow functions do not have their own 'this'; they inherit it lexically from the enclosing scope. Regular functions bind 'this' based on how they are called.

17. What are default parameters in a JavaScript function?

    Values assigned to parameters in the signature (e.g., function f(x = 5)) that are used when the argument is undefined or omitted.

18. What does the rest parameter (...args) do in a function definition?

    It collects all remaining arguments into a single real array, allowing variadic functions.

19. What is a closure in JavaScript?

    A closure is a function that retains access to variables from its outer (enclosing) lexical scope even after that outer function has returned.

20. What is an IIFE and why is it used?

    An Immediately Invoked Function Expression: (function(){ ... })(). It runs immediately upon definition, commonly used to create a private scope and avoid polluting the global namespace.

See more JavaScript Programming flashcards →

Planning JavaScript Programming for Full Stack Web Development

JavaScript Programming (Full Stack Web Development) FAQ