function test() {
    console.log(x); // undefined (hoisting)
    var x = 1;
    
    if (true) {
        let y = 2;  // block-scoped
        const z = 3; // block-scoped, can't be reassigned
    }
    console.log(y); // ReferenceError: y is not defined
}

Interview tip: Always use const by default, let if reassignment needed, and avoid var. Mention Temporal Dead Zone (TDZ) for let/const.

Hoisting is JavaScript's behavior of moving declarations to the top of their scope before code execution.

// Variable hoisting
console.log(x); // undefined (not ReferenceError)
var x = 5;

// Function hoisting
greet(); // 'Hello' - works because function is hoisted
function greet() { console.log('Hello'); }

// let/const hoisting (Temporal Dead Zone)
console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 10;

Interview tip: Explain that hoisting happens at compile-time, not runtime. All declarations (var, let, const, function) are hoisted, but var is initialized to undefined while let/const enter a Temporal Dead Zone.

// Primitive: passed by value
let a = 5;
let b = a;
b = 10;
console.log(a); // 5 (unchanged)

// Object: passed by reference
let obj1 = { name: 'John' };
let obj2 = obj1;
obj2.name = 'Jane';
console.log(obj1.name); // 'Jane' (changed!)

Interview tip: Primitives are immutable and passed by value; objects are mutable and passed by reference. This is why typeof null === 'object' (a famous quirk).

Scope determines the accessibility of variables. JavaScript has global scope, function scope, and block scope (with let/const).

// Global scope
let global = 'I am global';

function outer() {
    let outerVar = 'outer';
    
    function inner() {
        let innerVar = 'inner';
        console.log(innerVar);   // 'inner' - own scope
        console.log(outerVar);   // 'outer' - parent scope
        console.log(global);     // 'I am global' - global scope
    }
    inner();
}
outer();

Interview tip: Scope chain means inner functions can access variables from outer functions, but outer functions cannot access inner function variables.

Type coercion is the automatic conversion of values from one type to another. The == operator performs coercion, while === does not.

// Type coercion with ==
console.log(5 == '5');     // true (string coerced to number)
console.log(5 === '5');    // false (different types)

console.log(true == 1);    // true (boolean coerced to number)
console.log(true === 1);   // false

console.log(null == undefined);  // true (special case)
console.log(null === undefined); // false

console.log([] == 0);      // true (array coerced to number)
console.log([] === 0);     // false

Interview tip: Always use === in production code. Explain some quirks like [] == 0 being true but [] == false also being true - these show why == is dangerous.

Falsy values are values that evaluate to false in a boolean context. There are only 6 falsy values in JavaScript.

// The 6 falsy values
false
0
-0
0n (BigInt zero)
'' (empty string)
undefined
null
NaN

// Examples
if (0) console.log('This won\'t run');
if ('') console.log('This won\'t run');
if (undefined) console.log('This won\'t run');
if (null) console.log('This won\'t run');
if (NaN) console.log('This won\'t run');

if ([]) console.log('This WILL run - arrays are truthy!'); // true
if ({}) console.log('This WILL run - objects are truthy!'); // true
if ('0') console.log('This WILL run - non-empty strings are truthy!'); // true

Interview tip: Remember that empty arrays [], empty objects {}, and the string '0' are all truthy! This trips up many developers.

// undefined
let a;  // declared but not assigned
console.log(a); // undefined

function test(param) {
    console.log(param); // undefined if not passed
}
test();

// null
let b = null;  // explicitly assigned
console.log(b); // null

// Comparison
console.log(null == undefined);   // true (loose equality)
console.log(null === undefined);  // false (strict equality)
console.log(typeof null);         // 'object' (famous bug!)
console.log(typeof undefined);    // 'undefined'

Interview tip: Explain that null is intentional (developer sets it) while undefined is unintentional (JavaScript sets it). Also mention the famous bug: typeof null === 'object'.

The this keyword refers to the object that the function is called on. Its value is determined at call time, not definition time.

// 1. Global context
console.log(this); // Window (browser) or global (Node.js)

// 2. Object method
const obj = {
    name: 'John',
    greet: function() {
        console.log(this.name); // 'John' - this refers to obj
    }
};
obj.greet();

// 3. Constructor function
function Person(name) {
    this.name = name; // this refers to the new object being created
}
const p = new Person('Jane');

// 4. Arrow function (no own this)
const obj2 = {
    name: 'Bob',
    greet: () => {
        console.log(this); // Window or global, not obj2!
    }
};

// 5. call(), apply(), bind()
const person1 = { name: 'Alice' };
const person2 = { name: 'Charlie' };

function printName() {
    console.log(this.name);
}

printName.call(person1);  // 'Alice'
printName.apply(person2); // 'Charlie'
const boundFunc = printName.bind(person1);
boundFunc(); // 'Alice'

Interview tip: Emphasize that this is determined at call time, not definition time. Arrow functions don't have their own this - they use the enclosing scope's this.

Template literals (backticks) allow string interpolation, multi-line strings, and expression evaluation - cleaner than string concatenation.

// Regular strings
const name = 'John';
const greeting = 'Hello, ' + name + '!'; // Concatenation
const multiline = 'Line 1\nLine 2'; // Need \n
// Template literals
const greeting2 = `Hello, ${name}!`; // Interpolation
const multiline2 = `Line 1
Line 2`; // Native multi-line
const expr = `5 + 3 = ${5 + 3}`; // Expression evaluation

// Tagged template literals
function highlight(strings, ...values) {
    return strings.map((str, i) => str + (values[i] ? '<mark>' + values[i] + '</mark>' : '')).join('');
}
const html = highlight`Hello ${name}!`;
// 'Hello <mark>John</mark>!'

Interview tip: Mention that template literals make code more readable and less error-prone. Also mention tagged templates for advanced use cases like formatting, escaping, or localization.

NaN stands for 'Not-a-Number' but is of type 'number'. It's the only value in JavaScript that is not equal to itself!

// What produces NaN
const a = 0 / 0;           // NaN
const b = parseInt('hello'); // NaN
const c = undefined + 5;    // NaN
const d = Math.sqrt(-1);    // NaN

// WRONG way to check for NaN
if (a == NaN) console.log('This will NEVER run!'); // Always false
if (a === NaN) console.log('This will NEVER run!'); // Always false
if (typeof a === 'number' && a != a) console.log('Hacky way'); // Works but ugly

// RIGHT way to check for NaN
if (isNaN(a)) console.log('Correct!'); // true
if (Number.isNaN(a)) console.log('Even better!'); // true - strict version

// Difference between isNaN and Number.isNaN
console.log(isNaN('hello'));         // true (converts to number first)
console.log(Number.isNaN('hello'));  // false (no type conversion)

Interview tip: NaN !== NaN is one of the most famous JavaScript quirks. Always use Number.isNaN() for reliable checking. Mention that typeof NaN === 'number' (weird!).