JavaScript Regular Parameter

function executeOperation(param1, param2) {
    // param1 and param2 are regular parameters
}

const arg1 = 10;
const arg2 = 20;
executeOperation(arg1, arg2); // arg1 and arg2 are arguments bound to the parameters

​

Parameter Binding and Arity

• Under-application: If fewer arguments are passed than declared parameters, the unmapped parameters are automatically initialized to the primitive value undefined.
• Over-application: If more arguments are passed than declared parameters, the excess arguments are not bound to any named identifier. They are ignored by the parameter list but remain accessible internally via the local arguments object.

​

The arguments Object Aliasing

• Non-Strict Mode with Simple Parameters: If the function uses a simple parameter list (no default parameters, rest parameters, or destructuring), regular parameters are dynamically mapped to the arguments object. Modifying a named parameter automatically updates the corresponding index in the arguments object, and conversely, mutating the arguments object updates the named parameter. Crucially, this bidirectional mapping only applies to arguments that were actually passed during invocation. If a parameter is under-applied (receives undefined because no argument was provided), modifying the parameter does not map it to or update the arguments object.
• Strict Mode or Non-Simple Parameters: The dynamic mapping is completely disabled. If the function is in strict mode, or if the signature contains any non-simple parameters (ES6+), regular parameters and the arguments object remain entirely separate. Modifying a parameter identifier has no effect on the arguments object.

function nonStrictAlias(param1, param2) {
    param1 = "mutated";
    param2 = "mutated";
    console.log(arguments[0]); // Outputs: "mutated" (mapped because argument was passed)
    console.log(arguments[1]); // Outputs: undefined (unmapped because argument was omitted)
}
nonStrictAlias("initial"); // Invocation with only one argument

function strictAlias(param) {
    "use strict";
    param = "mutated";
    console.log(arguments[0]); // Outputs: "initial" (mapping severed by strict mode)
}
strictAlias("initial");

function nonSimpleAlias(param = "default") {
    param = "mutated";
    console.log(arguments[0]); // Outputs: "initial" (mapping severed by non-simple parameter)
}
nonSimpleAlias("initial");

​

Evaluation Strategy

• Primitive Values: The parameter receives an independent copy of the primitive value. Reassigning or modifying the parameter inside the function does not affect the original argument.
• Object Values: The parameter receives a copy of the reference pointing to the object in memory (a concept often referred to as “call-by-sharing”). Reassigning the parameter identifier to a completely new object does not affect the external reference, but mutating the properties of the referenced object will mutate the original object.

​

Scope and Shadowing

​

Strict Mode Constraints

// Non-strict mode: Allowed (param evaluates to the second argument)
function nonStrictFunc(param, param) {} 

// Strict mode: Throws SyntaxError: Duplicate parameter name not allowed in this context
function strictFunc(param, param) {
    "use strict";
}