JavaScript has 7 primitive data types: string, number, bigint, boolean, undefined, symbol, and null. Primitives are immutable and passed by value. Objects (including arrays, functions, and plain objects) are mutable collections of key-value properties and are passed by reference.

var is function-scoped (or globally scoped) and hoisted with an initial value of undefined. let and const are block-scoped and hoisted into a Temporal Dead Zone (TDZ). const creates a read-only variable reference that cannot be reassigned after declaration.

== (loose equality) performs type coercion to convert operands to a common type before comparing. === (strict equality) checks for equality without type conversion; both the value and the type must match.

Hoisting is JavaScript's behavior of moving variable and function declarations to the top of their containing scope during creation phase. Function declarations are hoisted with their complete definitions, var declarations are hoisted with undefined, while let and const remain uninitialized in the TDZ.

Scope determines the accessibility of variables in code. JavaScript has Global Scope, Function Scope, and Block Scope. When a variable is referenced, JavaScript looks in the current scope; if not found, it traverses up the Scope Chain to outer enclosing scopes until it reaches the global scope.

A closure is the combination of a function bundled together with references to its surrounding lexical environment. Closures give inner functions access to an outer function's scope variables even after the outer function has finished executing.

function createCounter(initialValue = 0) {
  let count = initialValue;
  return {
    increment: () => ++count,
    decrement: () => --count,
    getValue: () => count
  };
}

This encapsulates count inside a private closure, exposing only controlled modifier functions.

The value of this depends on how a function is called: standard method call (obj.fn()) sets this to obj; plain function call sets this to window/undefined (strict mode); constructors (new Fn()) bind this to the new instance; arrow functions bind this lexically from their outer scope.

call() invokes a function with a specified this context and arguments passed individually (fn.call(ctx, arg1, arg2)). apply() invokes the function with arguments passed as an array (fn.apply(ctx, [arg1, arg2])). bind() returns a new function with this bound permanently.

Objects in JavaScript have an internal [[Prototype]] link (exposed as __proto__). When accessing a property on an object, JavaScript looks at the object first, then traverses up the prototype chain until the property is found or null is reached.