> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# JavaScript Function Declaration
A function declaration defines a named function, binding an identifier directly to a function object within the current lexical environment. Unlike function expressions, declarations are parsed and instantiated in the environment record before the execution phase of the containing scope begins.
```javascript theme={"dark"}
function identifier(param1, param2, ...paramN) {
// statements
}
```
## Technical Characteristics
**Hoisting**
During the compilation phase, the JavaScript engine hoists function declarations to the top of their enclosing scope. Both the function identifier and the function body are fully initialized in the execution context's variable environment before any step-by-step code execution occurs. This allows the function to be invoked lexically before its actual declaration in the source code.
```javascript theme={"dark"}
// Valid execution due to hoisting
invokeMe();
function invokeMe() {
return true;
}
```
**Scoping Rules**
The visibility of a function declaration depends on the strictness of the execution context:
* **Strict Mode (`'use strict'`):** Function declarations are block-scoped. They are only accessible within the lexical block `{ ... }` in which they are defined.
* **Non-Strict Mode:** Function declarations are scoped to the enclosing function or the global scope, bypassing block boundaries (though modern engine implementations may exhibit complex legacy behaviors in this scenario).
**Internal Methods and Prototype**
Functions defined via declaration inherit from `Function.prototype`. They are created with both `[[Call]]` and `[[Construct]]` internal methods. Because they possess the `[[Construct]]` method and a `prototype` property, they can be invoked as constructors using the `new` keyword.
**Context Bindings**
Upon invocation, a function declaration generates a new execution context. This context automatically provisions two implicit local bindings:
1. `arguments`: An array-like object containing all arguments passed to the function.
2. `this`: A dynamically bound reference determined by the call site (how the function is invoked), rather than where it is lexically defined.
**Return Behavior**
If the execution of the function body completes without evaluating a `return` statement, or if a `return` statement is evaluated without an accompanying expression, the function implicitly returns `undefined`.
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
