Reusable block of code that can be executed (called/invoked)

Can accept inputs (parameters) and return an output (return value)

First-class citizens

Syntax: function name(a, b) { ... }

Hoisting

Has a name (useful in stack traces)

Syntax: const fn = function(a, b) { ... };

Not hoisted like declarations (variable is hoisted, initialization is not)

Named function expression

Syntax: const fn = (a, b) => { ... }

Expression form (not hoisted as a declaration)

Lexical this and arguments (does not bind its own)

Cannot be used as constructors (new not allowed)

Concise bodies

Object method shorthand

Class methods

Syntax: function Person(name){ this.name=name } + new Person("A")

new behavior

Syntax: function* gen(){ yield 1; }

Returns an iterator; supports yield/yield*

Syntax: async function f(){ return 1 }

Always returns a Promise

await pauses within async function

Syntax: (function(){ ... })();

Used to create a private scope (historically pre-let/const)

fn() or fn(arg1, arg2)

Execution context is created per call

obj.method()

this is typically obj (unless extracted)

new Fn()

this is the newly created instance

fn.call(thisArg, a, b)

fn.apply(thisArg, [a, b])

fn.bind(thisArg, a) returns a new function (does not invoke immediately)

obj.method?.() calls only if method exists

cond && fn() (call only if cond truthy)

Function calls itself directly or indirectly

Base case prevents infinite recursion

Takes functions as input or returns functions

Common examples: map, filter, reduce, event handlers

Parameter: variable in function definition

Argument: value supplied at call site

JavaScript is pass-by-sharing (call-by-sharing)

Syntax: function f(a = 1) { ... }

Evaluated at call time

Can depend on earlier parameters: f(a, b = a*2)

Syntax: function f(a, ...rest) { }

Collects remaining arguments into an array

Must be last parameter

Array-like object of passed arguments

Not available in arrow functions

Prefer rest parameters in modern code

Object destructuring: function f({x, y}) { }

Array destructuring: function f([a, b]) { }

Combine with defaults: function f({x=0} = {}) { }

Extra arguments are allowed (accessible via rest/arguments)

Missing arguments become undefined (unless default applied)

Positional: f(a, b, c) (order matters)

Named-like: f({a, b, c}) (object parameter for clarity)

return value sends value to caller

No return or return; yields undefined

Returning multiple values

Determined by code structure at definition time, not call time

Inner scopes can access outer scope variables

Global scope

Function scope

Block scope

Module scope

Lookup starts in current scope, then walks outward to global

If not found

var

let

const

function declarations

class declarations

Accessing let/const before declaration throws ReferenceError

Exists from start of block until declaration is evaluated

A function plus access to the variables in its outer lexical scopes

Inner function defined inside outer function captures variables

Captured variables live as long as closure is reachable

Data privacy / encapsulation

Function factories

Memoization/caching

Event handlers and callbacks

Capturing loop variables

Scope is lexical; this is runtime-binding (call-site dependent)

Function call: fn() → this is undefined in strict mode, global object in sloppy mode

Method call: obj.fn() → this is obj

Constructor: new Fn() → this is new instance

Explicit: call/apply/bind sets this

Arrow functions

Extracting method: const m = obj.method; m() loses obj

Fixes

Declarations registered before code runs

function declarations: hoisted with implementation

var: hoisted and set to undefined

let/const/class: hoisted but inaccessible due to TDZ

Prevents accidental globals

Changes default this in plain calls to undefined