Skip to main content
A function expression defines a function as part of a larger expression syntax, typically by assigning it to a variable. Unlike function declarations, which are parsed and hoisted before execution, function expressions are evaluated at runtime when the JavaScript engine reaches that specific statement in the execution flow.

​
Syntax

Function expressions can be either anonymous (omitting the function name) or named. 
// Anonymous Function Expression
const calculateArea = function(width, height) {
    return width * height;
};

// Named Function Expression (NFE)
const calculateFactorial = function factorial(n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
};

// Arrow Function Expression (ES6+)
const multiply = (a, b) => a * b;

​
Technical Characteristics

Hoisting and Execution Context Function expressions are not hoisted. The variable identifier is hoisted according to its declaration keyword (var, let, or const), but the function definition itself is not assigned to the variable until runtime. Attempting to invoke a function expression before its definition results in an error. 
// TypeError: processData is not a function
// (processData is hoisted as undefined)
processData(); 
var processData = function() { return true; };

// ReferenceError: Cannot access 'fetchData' before initialization
// (fetchData is in the Temporal Dead Zone)
fetchData(); 
const fetchData = function() { return true; };
Named Function Expressions (NFE) and Scope When a function expression includes a name (e.g., function factorial(n)), that identifier is bound exclusively within the function’s own local lexical scope. It is not added to the enclosing scope. This internal binding is immutable and is utilized by the engine for recursive calls and to provide descriptive identifiers in call stacks. 
const mathOperation = function subtract(a, b) {
    console.log(typeof subtract); // "function" (accessible internally)
    return a - b;
};

mathOperation(5, 2);
console.log(typeof subtract); // "undefined" (inaccessible externally)
Expression Context Parsing The JavaScript parser distinguishes a function expression from a function declaration based on the statement’s context. If the function keyword is the first token in a statement, the parser treats it as a declaration. If it appears anywhere else—such as after an assignment operator = , as an argument, or wrapped in grouping parentheses ()—it is evaluated as an expression yielding a function object.
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More