Javascript for Interviews

Master JavaScript's primitive types, typeof quirks, type coercion, and equality rules — the foundation of every JavaScript interview.

• Primitive data types: string, number, boolean, null, undefined, symbol, bigint

• typeof operator: checking types and the typeof null quirk (returns "object")

• NaN (Not-a-Number): special numeric value, NaN !== NaN, isNaN() vs Number.isNaN()

• BigInt type: 123n syntax for large integers beyond Number.MAX_SAFE_INTEGER

• Type conversion to number: Number(), parseInt(), parseFloat(), unary +

• Boolean conversion: falsy values (false, 0, "", null, undefined, NaN) and truthy values

• Symbol type: unique identifiers using Symbol("description") syntax

• Type coercion with + operator: string concatenation vs numeric addition

• Equality with type conversion: == (loose equality) vs === (strict equality)

• String to number implicit coercion: occurs with arithmetic operators like -, *, /

Understand arithmetic, comparison, logical, and ternary operators along with precedence rules that trip up candidates in code-reading questions.

• Arithmetic operators: +, -, *, /, % (modulus), ** (exponentiation)

• Operator precedence: multiplication/division before addition/subtraction

• Loose equality (==): performs type coercion (5 == "5" is true)

• Strict equality (===): no type coercion (5 === "5" is false)

• Logical operators: && (AND), || (OR), ! (NOT)

• Logical OR with truthy values: returns first truthy value (0 || "Hello" = "Hello")

• Assignment operators: =, +=, -=, *=, /=, %=

• Ternary operator: condition ? valueIfTrue : valueIfFalse

• Unary operators: ++, --, typeof, delete, void

• Increment/decrement: prefix (++x) vs postfix (x++) behavior

Write precise conditional logic and master all loop types including for...of and for...in — commonly tested with tricky output prediction questions.

• if-else statements: conditional execution and else if chains

• switch statement: case matching, break statements, and default case

• for loop: initialization, condition, and increment pattern

• while loop: condition-checked loops and potential infinite loops

• do-while loop: executes at least once, condition checked after body

• for...of loop: iterating over iterable values (arrays, strings)

• for...in loop: iterating over object properties (enumerable keys)

• break statement: exits loop immediately

• continue statement: skips current iteration and proceeds to next

• Nested loops: loop inside loop and multiplication table patterns

Work with arrays confidently using built-in methods — array type checking, mutations, and utility methods appear in nearly every JavaScript assessment.

• Array type checking: typeof [] returns "object", Array.isArray() for correct check

• Array length property: number of elements, can be manually modified

• push() and pop(): adding/removing elements at the end

• shift() and unshift(): removing/adding elements at the beginning

• includes() method: checks if array contains value, returns boolean

• indexOf() method: finds index of element, returns -1 if not found

• Array.isArray() method: reliable way to check if value is an array

• concat() method: merges arrays and returns a new array

• Default element values: 0 for numeric, false for boolean, null for objects

• Enhanced for loop: iterating arrays without using an index

Master function declarations, expressions, arrow functions, closures, and hoisting — functions are the most nuanced and frequently tested JavaScript topic.

• Normal function declaration: function funcName() { } syntax

• Arrow function syntax: (a, b) => a + b for concise functions

• Anonymous functions: functions without names used as callbacks

• Function hoisting: declarations are hoisted completely, expressions are not

• Function expressions: const func = function() { }

• Variable scope: var (function scope), let and const (block scope)

• Arrow function this behavior: lexically bound, inherits from enclosing scope

• IIFE (Immediately Invoked Function Expression): (function() { })()

• Default parameters: function greet(name = "Guest") { }

• Hoisting with function expressions: ReferenceError if called before definition

Create and manipulate objects using literals, dot and bracket notation, destructuring, and Object utility methods tested across all experience levels.

• Object creation: literal notation { key: value } and new Object()

• Property access: dot notation (obj.prop) and bracket notation (obj["prop"])

• Adding properties dynamically: obj.newProp = value assignment

• Object.keys(): returns array of object's own property names

• Object.values(): returns array of object's own property values

• in operator: checks if property exists anywhere in the object

• Object.freeze(): prevents modification of object properties

• Object destructuring: const { name, age } = person extracting properties

• for...in loop: iterating over enumerable object properties

• Object.assign(): copies properties from source objects to a target

Understand how this is dynamically vs lexically bound and how execution context phases work — one of the trickiest topics in JavaScript interviews.

• Global this in browser: refers to the window object

• Global this in strict mode: undefined instead of the global object

• this in object methods: refers to the object that owns the method

• this in arrow functions: lexically bound, not dynamically set

• this in standalone functions (non-strict): refers to global object (window)

• call() method: explicitly sets this value for a one-time function call

• this in setTimeout: typically window/global in browser (lost context)

• Execution context phases: creation phase and execution phase

• Types of execution context: global, function, and eval

• this in class methods: refers to the class instance

Select, modify, and interact with HTML elements programmatically — DOM APIs are essential for frontend developer interviews and practical assessments.

• getElementById(): retrieves a single element by its ID attribute

• getElementsByClassName(): returns a live HTMLCollection by class name

• textContent property: gets or sets the text content of an element

• createElement(): creates a new HTML element node

• appendChild(): adds a child node to a parent element

• setAttribute(): changes an attribute value of an element

• removeChild(): removes a child node from its parent

• addEventListener(): attaches an event handler to an element

• querySelector(): selects the first element matching a CSS selector

• querySelectorAll() vs getElementsByClassName(): static NodeList vs live HTMLCollection

Write modern JavaScript using let/const, template literals, destructuring, spread/rest, and modules — ES6+ features dominate current interview questions.

• let vs var: block scope vs function scope and temporal dead zone

• const declaration: block-scoped constant, cannot be reassigned (but object properties can change)

• Template literals: backtick strings for interpolation `Hello ${name}`

• Default parameters: function parameters with automatic default values

• Arrow functions: concise syntax with lexical this binding

• Destructuring assignment: const [x, y] = arr and const { name } = obj

• Spread operator: ...arr expands array elements into individual arguments

• Object property shorthand: { name, age } instead of { name: name, age: age }

• Rest parameters: function(...args) collects remaining arguments into an array

• Modules: export and import statements for code organization across files

Handle asynchronous operations correctly using promises and async/await syntax — async programming is tested in every mid-to-senior JavaScript interview.

• Promise states: pending, fulfilled, and rejected

• Creating promises: new Promise((resolve, reject) => { })

• then() method: handles a fulfilled promise and chains operations

• catch() method: handles a rejected promise for error handling

• Async function return: always returns a promise automatically

• await keyword: pauses the async function until the promise settles

• Error handling with async/await: using try-catch blocks

• Promise.all(): waits for all promises to fulfill, rejects if any fails

• Multiple awaits: executed sequentially by default, not in parallel

• Sequential vs parallel execution: use Promise.all() for concurrent operations

Transform, filter, and aggregate data using functional array methods — map, filter, reduce, and find are staples of every JavaScript coding interview.

• map(): transforms each element and returns a new array

• filter(): selects elements matching a condition and returns a new array

• reduce(): accumulates all values into a single result

• find(): returns the first element that satisfies the condition

• forEach(): executes a function for each element (no return value)

• some(): returns true if at least one element passes the condition

• every(): returns true only if all elements pass the condition

• sort(): sorts array in place, accepts an optional custom comparator

• slice(): extracts a portion of the array without modifying the original

• splice(): adds or removes elements and modifies the original array

Write resilient JavaScript using try-catch-finally, custom errors, and async error handling patterns that interviewers expect from production-ready developers.

• try-catch blocks: catching and handling synchronous errors

• finally block: code that runs regardless of whether an error occurred

• throw statement: throwing built-in or custom error objects explicitly

• Error object properties: message, name, and stack

• Custom error types: extending the Error class for domain-specific errors

• Async error handling: try-catch blocks inside async functions

• Promise error handling: .catch() method on promise chains

• Global error handlers: window.onerror and the unhandledrejection event

• Debugging techniques: console.log, debugger statement, browser DevTools

• Common error types: TypeError, ReferenceError, and SyntaxError