JavaScript Functions


JavaScript Functions: Parameters, Arguments, and Defaults

JavaScript is a versatile and widely used programming language that empowers developers to create dynamic and interactive web applications. One of the essential components of JavaScript is functions, which play a crucial role in organizing code, making it reusable, and improving overall efficiency.

JavaScript Functions: Parameters, Arguments, and Defaults

In this blog post, we will dive deep into JavaScript functions, focusing on parameters, arguments, and default values. Understanding these concepts is fundamental to becoming proficient in JavaScript, and we’ll explore various code samples and examples to solidify our knowledge.

What are JavaScript Functions?

A function in JavaScript is a block of code that can be defined once and executed multiple times. It encapsulates a series of statements and actions, allowing developers to break their code into smaller, manageable chunks. This not only enhances code organization but also promotes reusability and maintainability.

Function Declaration

In JavaScript, we can declare a function using the function keyword, followed by the function name, a list of parameters (inputs), and the function body enclosed in curly braces. Here’s a basic function declaration:

function greet(name) {
  console.log(`Hello, ${name}!`);

Function Invocation

After declaring a function, we can invoke (call) it by using its name followed by parentheses. The arguments (values) we pass inside the parentheses will be used as the function’s parameters during execution:

greet("Alice"); // Output: Hello, Alice!
greet("Bob");   // Output: Hello, Bob!

In the example above, the greet function takes a name parameter and logs a greeting message with the provided name.

Parameters and Arguments

In the context of JavaScript functions, the terms “parameters” and “arguments” are often used interchangeably, but they have distinct meanings.


Parameters are the placeholders for values that a function expects to receive. When defining a function, you can specify the parameters it accepts. These parameters act as variables within the function and are assigned the values passed as arguments when the function is called.

Let’s look at a simple example:

function multiply(a, b) {
  return a * b;

In this multiply function, a and b are parameters. They act as placeholders for the values we want to multiply together.


Arguments, on the other hand, are the actual values passed to a function when it is called. They correspond to the parameters defined in the function declaration.

Continuing with the multiply function, here’s how we would pass arguments:

const result = multiply(5, 3);
console.log(result); // Output: 15

In this example, 5 and 3 are arguments that are assigned to the a and b parameters, respectively, during the function call.

Number of Arguments

In JavaScript, a function can accept any number of arguments, regardless of the number of parameters defined in the function declaration. If the number of arguments exceeds the number of parameters, the extra arguments are ignored. Conversely, if there are fewer arguments than parameters, the missing parameters will have a value of undefined.

Let’s see this in action:

function add(a, b, c) {
  return a + b + c;

const result1 = add(2, 3, 4);
console.log(result1); // Output: 9

const result2 = add(1, 2);
console.log(result2); // Output: NaN (Not a Number)

In the first call to add, all three arguments are provided and assigned to the corresponding parameters. However, in the second call, only two arguments are provided, resulting in c being undefined, which leads to NaN when trying to add undefined to a number.

Default Parameter Values

ES6 (ECMAScript 2015) introduced default parameter values, allowing us to specify default values for parameters in case arguments are not provided during function invocation. This feature provides more flexibility when working with functions and reduces the need for checking and handling missing arguments manually.

To set default values for parameters, we can assign the desired default value directly in the function declaration:

function greet(name = "Guest") {
  console.log(`Hello, ${name}!`);

greet();         // Output: Hello, Guest!
greet("Alice");  // Output: Hello, Alice!

In this example, if the greet function is called without any arguments, the name parameter will take the default value of “Guest”. If an argument is provided, it will override the default value.

Rest Parameters

In addition to regular parameters, JavaScript also supports rest parameters, denoted by three consecutive dots (…). Rest parameters allow a function to accept an indefinite number of arguments as an array, providing more flexibility when dealing with varying numbers of inputs.

Let’s see how rest parameters work:

function sum(...numbers) {
  return numbers.reduce((acc, num) => acc + num, 0);

const result1 = sum(1, 2, 3, 4, 5);
console.log(result1); // Output: 15

const result2 = sum(10, 20);
console.log(result2); // Output: 30

In the sum function, the rest parameter numbers collects all the arguments passed to the function as an array. We can then use array methods like reduce to perform operations on these arguments.


JavaScript functions are at the core of building complex applications, providing a way to organize code, make it reusable, and improve overall efficiency. Understanding how parameters, arguments, and default values work together is essential for writing robust and flexible functions.

In this blog post, we covered the basics of JavaScript functions and their relationship with parameters and arguments. We explored the distinction between parameters and arguments, how to use default parameter values, and the benefits of using rest parameters.

As you continue your JavaScript journey, keep practicing and experimenting with functions to master this crucial aspect of the language. With a solid understanding of functions, you’ll be well-equipped to build dynamic and powerful web applications. Happy coding!

Previously at
Flag Argentina
time icon
Experienced JavaScript developer with 13+ years of experience. Specialized in crafting efficient web applications using cutting-edge technologies like React, Node.js, TypeScript, and more.