Function parameters in JavaScript provide a way to pass data to a function when it is called. These parameters, also known as arguments, are used within the function to perform specific tasks. JavaScript offers flexibility in how parameters are handled, with features like default values, rest parameters, and the arguments object.

JavaScript Function Parameters and Arguments

• Parameters: These are placeholders defined in the function declaration that specify what data the function expects to receive.
• Arguments: These are the actual values provided when the function is called.

Basic Syntax

1function functionName(param1, param2) {
2  // Use param1 and param2 in the function
3}

For example, if you define function add(a, b), then a and b are parameters. When you call the function as add(2, 3), the values 2 and 3 are the arguments.

Important Rules for Parameters

1. No Type Checking: JavaScript does not enforce specific data types for parameters.
2. No Argument Count Enforcement: The number of arguments passed can be less or more than the number of parameters defined.
3. Default Value for Missing Arguments: When fewer arguments are passed than parameters defined, the missing ones are assigned undefined.

JavaScript Default Parameter

To handle cases where some arguments are not provided, you can assign default values to parameters. This ensures that your function has meaningful values even when arguments are missing.

Example

1function greet(name = "Guest") {
2  return "Hello, " + name + "!";
3}
4
5console.log(greet()); // Output: Hello, Guest!
6console.log(greet("Alice")); // Output: Hello, Alice!

Using default values simplifies function handling by reducing the need for manual checks.

JavaScript Rest Parameters

The rest parameter syntax (...) allows you to group an indefinite number of arguments into an array. This is useful for functions that can handle varying numbers of inputs.

Example

1function sum(...numbers) {
2  let total = 0;
3  for (const number of numbers) {
4    total += number;
5  }
6  return total;
7}
8
9console.log(sum(1, 2, 3, 4)); // Output: 10

Key Points

• Rest parameters must be the last parameter in the function.
• They gather any "extra" arguments passed during the function call.

JavaScript arguments Object

All functions in JavaScript have access to a special built-in object called arguments. This object contains all arguments passed to the function, even if they are more than the defined parameters.

Example

1function findMax() {
2  let max = -Infinity;
3  for (let i = 0; i < arguments.length; i++) {
4    if (arguments[i] > max) {
5      max = arguments[i];
6    }
7  }
8  return max;
9}
10
11console.log(findMax(10, 20, 5, 99)); // Output: 99

Key Points

• The arguments object is not an array but behaves like one.
• It is particularly useful when the number of arguments is unknown.
• In modern JavaScript, rest parameters are preferred over the arguments object because they provide cleaner and more readable code.

JavaScript Arguments Passed by Value

When you pass arguments to a function, JavaScript passes the values of those arguments, not their references. This means:

• Changing the value of a parameter inside a function does not affect the original variable.
• This applies to primitive values like numbers and strings.

Example

1function modifyValue(x) {
2  x = 10; // Changes x locally
3  return x;
4}
5
6let a = 5;
7console.log(modifyValue(a)); // Output: 10
8console.log(a); // Output: 5 (original value remains unchanged)

Key Takeaways

• Function parameters are flexible in JavaScript, allowing for varying input values.
• Use default parameters to handle cases where arguments are missing.
• Rest parameters (...) allow handling an unlimited number of arguments cleanly.
• The arguments object is a legacy feature but can still be used for backward compatibility.
• JavaScript passes arguments by value, meaning changes inside a function do not affect the original variable unless the value is a reference type like an object or array.