assign function to variable javascript

• Awards Season
• Big Stories
• Pop Culture
• Video Games
• Celebrities

Unleashing the Potential of JavaScript: Enhance Your Website with Code

In today’s digital age, having a captivating and functional website is essential for any business or individual. One of the most powerful tools in a web developer’s arsenal is JavaScript, a versatile programming language that can transform a static website into an interactive and dynamic platform. With the right code for creating a website, you can unlock the true potential of JavaScript and take your website to new heights. In this article, we will explore some key aspects of using JavaScript to enhance your website’s functionality and user experience.

Adding Interactivity with Event Handling

One of the main reasons why JavaScript is so popular among web developers is its ability to add interactivity to websites through event handling. Event handling allows you to create dynamic responses based on user actions such as clicking a button or submitting a form.

To implement event handling in your website code, you can use JavaScript’s built-in event listeners. These listeners “listen” for specific events and execute a set of instructions when triggered. For example, you can use an “onclick” event listener to execute a function when a button is clicked.

By leveraging event handling in your code for creating a website, you can create interactive elements that respond seamlessly to user actions. Whether it’s displaying pop-up messages, loading new content dynamically, or validating form inputs in real-time, event handling empowers you to create engaging user experiences.

Dynamic Content Manipulation with DOM Manipulation

Another powerful feature of JavaScript is its ability to manipulate the Document Object Model (DOM) – the structure that represents elements on a web page. With DOM manipulation, you can dynamically modify the content and appearance of your website based on user interactions or other conditions.

JavaScript provides various methods and properties for accessing and manipulating DOM elements. By targeting specific elements using their IDs or class names, you can change their text, style, or even add/remove elements entirely. This gives you the flexibility to update your website’s content in real-time without having to reload the entire page.

For example, you can use DOM manipulation to create an image carousel that displays a slideshow of images. By changing the source attribute of the image element at regular intervals, you can create a visually appealing and dynamic element on your website.

Validating User Inputs with Form Validation

Form validation is a critical aspect of any website that collects user input through forms. JavaScript provides powerful tools for validating user inputs in real-time, ensuring that the data submitted is correct and complete before it is processed.

To implement form validation using JavaScript, you can leverage event handling and DOM manipulation techniques. By attaching event listeners to form inputs (e.g., “oninput” or “onchange”), you can validate user inputs as they type or when they change focus from one input field to another.

Through JavaScript’s conditional statements and regular expressions, you can define rules for validating various types of input fields such as email addresses, phone numbers, or passwords. If the user input does not meet the specified criteria, you can display error messages dynamically using DOM manipulation.

By incorporating form validation into your code for creating a website, you enhance its usability by preventing users from submitting incorrect or incomplete data. This not only improves the overall user experience but also reduces errors and ensures data integrity.

Enhancing Website Performance with Asynchronous Programming

In today’s fast-paced digital world, website performance plays a crucial role in delivering a seamless user experience. JavaScript offers asynchronous programming techniques that allow certain tasks to be executed without blocking other operations on your website.

Asynchronous programming in JavaScript relies on concepts such as callbacks, promises, and async/await functions. These techniques enable time-consuming tasks like fetching data from an external API or loading large images to be performed in parallel with other operations.

By leveraging asynchronous programming, you can prevent your website from becoming unresponsive or slow while performing resource-intensive tasks. This enhances the overall user experience by ensuring that your website remains fast and responsive, even when dealing with complex operations.

In conclusion, JavaScript is a powerful programming language that can revolutionize the functionality and user experience of your website. By incorporating event handling, DOM manipulation, form validation, and asynchronous programming techniques into your code for creating a website, you can unleash the true potential of JavaScript and create captivating websites that engage users and deliver memorable experiences. So why wait? Start exploring the endless possibilities of JavaScript today.

This text was generated using a large language model, and select text has been reviewed and moderated for purposes such as readability.

MORE FROM ASK.COM

• Trending Categories

• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

How can we assign a function to a variable in JavaScript?

In this tutorial, we will learn to assign a function to a variable in JavaScript. The function is the code block that we can reuse quickly, often just by making a function call. There are two ways to declare a function in JavaScript, one is a named function, and another is an anonymous function.

Most JavaScript programmers are familiar with the name function, and users can follow the below syntax to declare the named function.

In the above syntax, users can see that, we can create a function definition with the function keyword and following by function name.

Now, what if we want to assign the whole function to the variable as an expression? Here, we have 2 different ways to achieve our goal.

Creating the Anonymous Function

Creating the arrow function.

The anonymous function name suggests that we are declaring the function without its identity means its name.

It is the first way to assign the function to the variable.

Creating an anonymous function works as an expression and compiles when code execution reaches the function line, and the named function compiles at the start of the code execution.

Programmers can follow the below syntax to bind the anonymous function to the variable.

In the above syntax, users can see that we have assigned the expression of an anonymous function to the variable ‘a’. Furthermore, we can invoke the function using the variable ‘a’ and passed the parameters.

In the below example, we will create an anonymous function and assign it to the variable as an expression. After that, we will call the anonymous function using the variable. Also, we will learn to pass the parameters inside the anonymous function.

In the above output, users can see that it renders the result returned from the function call using variable ‘a’.

The second method to assign the function to the variable is the arrow function. It is similar to the above approach, but the difference is that we will create an anonymous function without using the ‘ function ’ keyword and use an arrow instead.

The arrow function is the shortest syntax to declare the function in JavaScript, and it makes programmers' tasks easy to write the function. It is the latest version of the anonymous function as introduced in the ES6 .

Programmers can create a single variable using the var, let, or const keywords and assign the function expression to that. However, creating a variable with the const keyword is recommended to assign the function as the function expression always remains constant.

Users can follow the below syntax to write the expression for the arrow function.

In the above syntax, users can see how we declared the arrow function expression without using the function keyword.

In the below example, we will create the arrow function with parameters. Also, we will assign it to the variable and invoke through the variable.

In the above output, users can see that it prints whatever result returns from the arrow function when we call it using the variable.

We have learned the two different ways to assign the function expression to the variable. The first approach is using the anonymous function, which is also possible in the ES5. In the ES6, the arrow function was introduced to create an anonymous function and assign it to the variable.

It is recommended to use the arrow function as it is the shorter version of the anonymous function.

• Related Articles
• Can we assign a reference to a variable in Python?
• How can we assign a bit value as a number to a user variable?
• How to assign a PHP variable to JavaScript?
• How can we use SET statement to assign a SELECT result to a MySQL user variable?
• How to assign a reference to a variable in C#
• How to define global variable in a JavaScript function?
• How can I check if a JavaScript variable is function type?
• How to assign multiple values to a same variable in Python?
• Can we assign new property to an object using deconstruction in JavaScript?
• How do I assign a dictionary value to a variable in Python?
• How can we use a JavaScript function as an object?
• How to execute a JavaScript function using its name in a variable?
• How to assign the result of a MySQL query into a variable?
• How can we store a value in user-defined variable?
• How to load a JavaScript function using the variable name?

Kickstart Your Career

Get certified by completing the course

• JavaScript Tutorial

Assign a Function to a Variable in JavaScript

By James L.

Assigning a function to a variable allows us to use the function as a value, pass the function as an argument, or return it from other functions.

In this blog post, we will dive deep into the syntax, benefits, and best practices of assigning a function to a variable in JavaScript.

There are several ways to assign a function to a variable in JavaScript:

Using the function expression (anonymous function)

Using arrow function, using function declaration.

A function expression is a way to define a function as a value and assign it to a variable. It is also known as an anonymous function because it doesn’t have a name associated with it.

Here is a syntax for a function expression:

Below is an example of a function expression that adds two numbers:

When functions are stored in variables, they can be invoked or called using the variable name followed by parentheses.

An arrow function is a concise and efficient way to write functions in JavaScript. It provides a shorter syntax compared to traditional function expressions.

Below is the syntax for the arrow function:

Below is an example of an arrow function that adds two numbers:

An arrow function doesn’t require the use of the function keyword, and if the function body consists of a single statement, we can omit the return keyword and curly brackets.

Let’s take a look at an example:

Note : The use of the const keyword is recommended for arrow functions to ensure immutability, but let or var can also be used.

We can also assign a function to a variable using a function declaration. In this method, we first declare a function using a function keyword and assign it to a variable.

Here is an example:

Now, the variable greet holds a reference to the hello function. We can call the function using the variable name followed by a parentheses greet() .

Difference between function declaration, function expression, and arrow function

We will only discuss hoisting in this guide.

Hoisting in JavaScript is a behavior where variables and function declarations are moved to the top of their respective scopes during the compilation phase. This means that variables and functions can be accessed and used before they are declared.

Function declarations in JavaScript are hoisted meaning they can be called before they are declared. 

Function expressions in JavaScript are not hoisted meaning they must be defined before they are called. Otherwise, it will throw an error.

Arrow functions in JavaScript are also not hoisted. So they must be defined before they are called.

Related Posts

Latest posts.

Assign variable to function VS assign function to variable

I know that in the code above, we passed a function to a variable. fn=baz , if I change it to fn=baz() IDE will give me a type error: fn is not a function. So I assume in js we do not assign functions to variables, we assign the output of the functions into a variable. Because the elements at the each side of = has to be the same type. Am I correct?

Then what does this mean? function bar(){fn();} ? why do we need to add a parameter after a variable?

I am a bit confused…

You can assign functions to variables (because in JS you can pass around functions as if they were plain data), like in var f = function() {...}; . You can also invoke the function in f by writing f() in your code.

Also, variables in JS have no type. A variable that previously held a number doesn’t care if you assign it a string or array, or a function

When you changed it to fn = baz() , you were invoking the baz function, which returns undefined (simply because there are no return statements in that function). So fn now is undefined , which is definitely not a function, and you get the error when fn() was executed.

I don’t think that baz function returns undefined because here in this example, it returns 2.

But to understand the code I put 1st was

• baz got assigned to fn 1st via fn=baz .
• then baz got invoked via function bar(){fn();} .

Don’t confuse the result of console.log ging with return values. The 2 that you see is not a return value, but rather the result of console.log ging the 2 from inside baz() . When a function has no return statements, their return values are implicitly undefined .

True. The global fn variable holds a reference to the baz function. Then you can later invoke the baz function by using fn()

I will remember this from now on. Thanks!!

• Getting started with JavaScript
• Awesome Book
• Awesome Community
• Awesome Course
• Awesome Tutorial
• Awesome YouTube
• .postMessage() and MessageEvent
• Anti-patterns
• Arithmetic (Math)
• Arrow Functions
• Async functions (async/await)
• Async Iterators
• Automatic Semicolon Insertion - ASI
• Battery Status API
• Behavioral Design Patterns
• Binary Data
• Bitwise operators
• Bitwise Operators - Real World Examples (snippets)
• BOM (Browser Object Model)
• Built-in Constants
• Comparison Operations
• Constructor functions
• Context (this)
• Creational Design Patterns
• Custom Elements
• Data attributes
• Data Manipulation
• Datatypes in Javascript
• Date Comparison
• Declarations and Assignments
• Destructuring assignment
• Detecting browser
• Enumerations
• Error Handling
• Escape Sequences
• Evaluating JavaScript
• execCommand and contenteditable
• File API, Blobs and FileReaders
• Functional JavaScript
• Anonymous Function
• Binding `this` and arguments
• Call and apply
• Default parameters
• Function Arguments, "arguments" object, rest and spread parameters
• Function Composition
• Function Scoping
• Functions as a variable
• Functions with an Unknown Number of Arguments (variadic functions)
• Get the name of a function object
• Immediately Invoked Function Expressions
• Named Functions
• Partial Application
• Passing arguments by reference or value
• Recursive Function
• Using the Return Statement
• Geolocation
• Global error handling in browsers
• How to make iterator usable inside async callback function
• Inheritance
• Intervals and Timeouts
• JavaScript Variables
• Linters - Ensuring code quality
• Localization
• Memory efficiency
• Method Chaining
• Modals - Prompts
• Modularization Techniques
• Namespacing
• Navigator Object
• Notifications API
• Performance Tips
• Prototypes, objects
• Regular expressions
• requestAnimationFrame
• Reserved Keywords
• Same Origin Policy & Cross-Origin Communication
• Security issues
• Selection API
• Server-sent events
• Setters and Getters
• Strict mode
• Tail Call Optimization
• Template Literals
• The Event Loop
• Transpiling
• Unary Operators
• Unit Testing Javascript
• Using javascript to get/set CSS custom variables
• Variable coercion/conversion
• Vibration API
• Web Cryptography API
• Web Storage

JavaScript Functions Functions as a variable

Fastest entity framework extensions.

A normal function declaration looks like this:

A function defined like this is accessible from anywhere within its context by its name. But sometimes it can be useful to treat function references like object references. For example, you can assign an object to a variable based on some set of conditions and then later retrieve a property from one or the other object:

In JavaScript, you can do the same thing with functions:

In the example above, hash is a normal variable. It is assigned a reference to a function, after which the function it references can be invoked using parentheses, just like a normal function declaration.

The example above references anonymous functions... functions that do not have their own name. You can also use variables to refer to named functions. The example above could be rewritten like so:

Or, you can assign function references from object properties:

You can assign the reference to a function held by one variable to another by omitting the parentheses. This can result in an easy-to-make mistake: attempting to assign the return value of a function to another variable, but accidentally assigning the reference to the function.

A reference to a function is like any other value. As you've seen, a reference can be assigned to a variable, and that variable's reference value can be subsequently assigned to other variables. You can pass around references to functions like any other value, including passing a reference to a function as the return value of another function. For example:

You don't need to assign a function reference to a variable in order to invoke it. This example, building off example 5, will call getHashingFunction and then immediately invoke the returned function and pass its return value to hashedValue.

A Note on Hoisting

Keep in mind that, unlike normal function declarations, variables that reference functions are not "hoisted". In example 2, the md5Hash and sha1Hash functions are defined at the bottom of the script, but are available everywhere immediately. No matter where you define a function, the interpreter "hoists" it to the top of its scope, making it immediately available. This is not the case for variable definitions, so code like the following will break:

Got any JavaScript Question?

• Advertise with us
• Privacy Policy

Get monthly updates about new articles, cheatsheets, and tricks.

Assign a Function to a Variable in JavaScript

• JavaScript Howtos
• Assign a Function to a Variable in …

Example of Assigning a Function to a Variable Using JavaScript in HTML

Examine the given html code, alternative way to assign a function to a variable in javascript.

This article explains how we assign a declared function to any variable and check whether the function contains parameters or not. The function associated with the variable may return any value and store that value in a variable; we can also call the function using its assigned variable as many times as we want.

We will assign a function to a variable checkValue that will identify if the given value by the user is even or odd. The function will be triggered whenever the user inserts a value in input and press the submit button; that function must be called and display an alert box that should say value is even or value is odd .

In the above HTML page source, you can see a simple input form type of number to get the integer value from the user, and there is a submit button to submit the value and proceed with the functionality.

Here, you can see the <script> tags, which is necessary to use JavaScript statements in doctype HTML. We have assigned a function to our declared variable checkValue in those tags.

The function contains a user-given value in the variable givenValue . In the next step, we used a conditional statement with the modulus operator ( % ) to check whether the remainder of the given value equals 2 or not.

In the next step, the function() is simply displaying an alert box to the user containing given value is even or given value is odd based on conditions.

Follow all the steps below to have a clear understanding of the code:

Create a text document using a notepad or any other text editing tool.

Paste the given code in the created text file., save that text file with the extension of .html and open it with any default browser., you can see the input form to insert value and the submit button; using that button, you can check your value..

The same results will also be achieved, as shown below. Assign a function to a variable with a parameter to pass a value, check the value, and return the statement on a conditional basis.

In the above examples, checkEvenOdd assigned with a function in which we have to pass an integer value as a parameter function will check that value with a given if condition and returns a string. In the next step, the function checkEvenOdd() is called in console.log() to display the result.

Related Article - JavaScript Function

• JavaScript Return Undefined
• Self-Executing Function in JavaScript
• JavaScript Get Function Name
• The Meaning of => in JavaScript
• Export All Functions From a File in JavaScript
• history.forward() Function in JavaScript

Related Article - JavaScript Variable

• Access the Session Variable in JavaScript
• Check Undefined and Null Variable in JavaScript
• Mask Variable Value in JavaScript
• Why Global Variables Give Undefined Values in JavaScript
• Declare Multiple Variables in a Single Line in JavaScript
• JavaScript Declare Multiple Variables

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• English (US)

Functions are one of the fundamental building blocks in JavaScript. A function in JavaScript is similar to a procedure—a set of statements that performs a task or calculates a value, but for a procedure to qualify as a function, it should take some input and return an output where there is some obvious relationship between the input and the output. To use a function, you must define it somewhere in the scope from which you wish to call it.

See also the exhaustive reference chapter about JavaScript functions to get to know the details.

Defining functions

Function declarations.

A function definition (also called a function declaration , or function statement ) consists of the function keyword, followed by:

• The name of the function.
• A list of parameters to the function, enclosed in parentheses and separated by commas.
• The JavaScript statements that define the function, enclosed in curly braces, { /* … */ } .

For example, the following code defines a simple function named square :

The function square takes one parameter, called number . The function consists of one statement that says to return the parameter of the function (that is, number ) multiplied by itself. The return statement specifies the value returned by the function, which is number * number .

Parameters are essentially passed to functions by value — so if the code within the body of a function assigns a completely new value to a parameter that was passed to the function, the change is not reflected globally or in the code which called that function .

When you pass an object as a parameter, if the function changes the object's properties, that change is visible outside the function, as shown in the following example:

When you pass an array as a parameter, if the function changes any of the array's values, that change is visible outside the function, as shown in the following example:

Function expressions

While the function declaration above is syntactically a statement, functions can also be created by a function expression .

Such a function can be anonymous ; it does not have to have a name. For example, the function square could have been defined as:

However, a name can be provided with a function expression. Providing a name allows the function to refer to itself, and also makes it easier to identify the function in a debugger's stack traces:

Function expressions are convenient when passing a function as an argument to another function. The following example shows a map function that should receive a function as first argument and an array as second argument:

In the following code, the function receives a function defined by a function expression and executes it for every element of the array received as a second argument:

In JavaScript, a function can be defined based on a condition. For example, the following function definition defines myFunc only if num equals 0 :

In addition to defining functions as described here, you can also use the Function constructor to create functions from a string at runtime, much like eval() .

A method is a function that is a property of an object. Read more about objects and methods in Working with objects .

Calling functions

Defining a function does not execute it. Defining it names the function and specifies what to do when the function is called.

Calling the function actually performs the specified actions with the indicated parameters. For example, if you define the function square , you could call it as follows:

The preceding statement calls the function with an argument of 5 . The function executes its statements and returns the value 25 .

Functions must be in scope when they are called, but the function declaration can be hoisted (appear below the call in the code). The scope of a function declaration is the function in which it is declared (or the entire program, if it is declared at the top level).

The arguments of a function are not limited to strings and numbers. You can pass whole objects to a function. The showProps() function (defined in Working with objects ) is an example of a function that takes an object as an argument.

A function can call itself. For example, here is a function that computes factorials recursively:

You could then compute the factorials of 1 through 5 as follows:

There are other ways to call functions. There are often cases where a function needs to be called dynamically, or the number of arguments to a function vary, or in which the context of the function call needs to be set to a specific object determined at runtime.

It turns out that functions are themselves objects — and in turn, these objects have methods. (See the Function object.) The call() and apply() methods can be used to achieve this goal.

Function hoisting

Consider the example below:

This code runs without any error, despite the square() function being called before it's declared. This is because the JavaScript interpreter hoists the entire function declaration to the top of the current scope, so the code above is equivalent to:

Function hoisting only works with function declarations — not with function expressions . The following code will not work:

Function scope

Variables defined inside a function cannot be accessed from anywhere outside the function, because the variable is defined only in the scope of the function. However, a function can access all variables and functions defined inside the scope in which it is defined.

In other words, a function defined in the global scope can access all variables defined in the global scope. A function defined inside another function can also access all variables defined in its parent function, and any other variables to which the parent function has access.

Scope and the function stack

A function can refer to and call itself. There are three ways for a function to refer to itself:

• The function's name
• arguments.callee
• An in-scope variable that refers to the function

For example, consider the following function definition:

Within the function body, the following are all equivalent:

• arguments.callee()

A function that calls itself is called a recursive function . In some ways, recursion is analogous to a loop. Both execute the same code multiple times, and both require a condition (to avoid an infinite loop, or rather, infinite recursion in this case).

For example, consider the following loop:

It can be converted into a recursive function declaration, followed by a call to that function:

However, some algorithms cannot be simple iterative loops. For example, getting all the nodes of a tree structure (such as the DOM ) is easier via recursion:

Compared to the function loop , each recursive call itself makes many recursive calls here.

It is possible to convert any recursive algorithm to a non-recursive one, but the logic is often much more complex, and doing so requires the use of a stack.

In fact, recursion itself uses a stack: the function stack. The stack-like behavior can be seen in the following example:

Nested functions and closures

You may nest a function within another function. The nested (inner) function is private to its containing (outer) function.

It also forms a closure . A closure is an expression (most commonly, a function) that can have free variables together with an environment that binds those variables (that "closes" the expression).

Since a nested function is a closure, this means that a nested function can "inherit" the arguments and variables of its containing function. In other words, the inner function contains the scope of the outer function.

To summarize:

• The inner function can be accessed only from statements in the outer function.
• The inner function forms a closure: the inner function can use the arguments and variables of the outer function, while the outer function cannot use the arguments and variables of the inner function.

The following example shows nested functions:

Since the inner function forms a closure, you can call the outer function and specify arguments for both the outer and inner function:

Preservation of variables

Notice how x is preserved when inside is returned. A closure must preserve the arguments and variables in all scopes it references. Since each call provides potentially different arguments, a new closure is created for each call to outside . The memory can be freed only when the returned inside is no longer accessible.

This is not different from storing references in other objects, but is often less obvious because one does not set the references directly and cannot inspect them.

Multiply-nested functions

Functions can be multiply-nested. For example:

• A function ( A ) contains a function ( B ), which itself contains a function ( C ).
• Both functions B and C form closures here. So, B can access A , and C can access B .
• In addition, since C can access B which can access A , C can also access A .

Thus, the closures can contain multiple scopes; they recursively contain the scope of the functions containing it. This is called scope chaining . (The reason it is called "chaining" is explained later.)

Consider the following example:

In this example, C accesses B 's y and A 's x .

This can be done because:

• B forms a closure including A (i.e., B can access A 's arguments and variables).
• C forms a closure including B .
• Because C 's closure includes B and B 's closure includes A , then C 's closure also includes A . This means C can access both B and A 's arguments and variables. In other words, C chains the scopes of B and A , in that order .

The reverse, however, is not true. A cannot access C , because A cannot access any argument or variable of B , which C is a variable of. Thus, C remains private to only B .

Name conflicts

When two arguments or variables in the scopes of a closure have the same name, there is a name conflict . More nested scopes take precedence. So, the innermost scope takes the highest precedence, while the outermost scope takes the lowest. This is the scope chain. The first on the chain is the innermost scope, and the last is the outermost scope. Consider the following:

The name conflict happens at the statement return x * 2 and is between inside 's parameter x and outside 's variable x . The scope chain here is { inside , outside , global object}. Therefore, inside 's x takes precedences over outside 's x , and 20 ( inside 's x ) is returned instead of 10 ( outside 's x ).

Closures are one of the most powerful features of JavaScript. JavaScript allows for the nesting of functions and grants the inner function full access to all the variables and functions defined inside the outer function (and all other variables and functions that the outer function has access to).

However, the outer function does not have access to the variables and functions defined inside the inner function. This provides a sort of encapsulation for the variables of the inner function.

Also, since the inner function has access to the scope of the outer function, the variables and functions defined in the outer function will live longer than the duration of the outer function execution, if the inner function manages to survive beyond the life of the outer function. A closure is created when the inner function is somehow made available to any scope outside the outer function.

It can be much more complex than the code above. An object containing methods for manipulating the inner variables of the outer function can be returned.

In the code above, the name variable of the outer function is accessible to the inner functions, and there is no other way to access the inner variables except through the inner functions. The inner variables of the inner functions act as safe stores for the outer arguments and variables. They hold "persistent" and "encapsulated" data for the inner functions to work with. The functions do not even have to be assigned to a variable, or have a name.

Note: There are a number of pitfalls to watch out for when using closures!

If an enclosed function defines a variable with the same name as a variable in the outer scope, then there is no way to refer to the variable in the outer scope again. (The inner scope variable "overrides" the outer one, until the program exits the inner scope. It can be thought of as a name conflict .)

Using the arguments object

The arguments of a function are maintained in an array-like object. Within a function, you can address the arguments passed to it as follows:

where i is the ordinal number of the argument, starting at 0 . So, the first argument passed to a function would be arguments[0] . The total number of arguments is indicated by arguments.length .

Using the arguments object, you can call a function with more arguments than it is formally declared to accept. This is often useful if you don't know in advance how many arguments will be passed to the function. You can use arguments.length to determine the number of arguments actually passed to the function, and then access each argument using the arguments object.

For example, consider a function that concatenates several strings. The only formal argument for the function is a string that specifies the characters that separate the items to concatenate. The function is defined as follows:

You can pass any number of arguments to this function, and it concatenates each argument into a string "list":

Note: The arguments variable is "array-like", but not an array. It is array-like in that it has a numbered index and a length property. However, it does not possess all of the array-manipulation methods.

See the Function object in the JavaScript reference for more information.

Function parameters

There are two special kinds of parameter syntax: default parameters and rest parameters .

Default parameters

In JavaScript, parameters of functions default to undefined . However, in some situations it might be useful to set a different default value. This is exactly what default parameters do.

In the past, the general strategy for setting defaults was to test parameter values in the body of the function and assign a value if they are undefined .

In the following example, if no value is provided for b , its value would be undefined when evaluating a*b , and a call to multiply would normally have returned NaN . However, this is prevented by the second line in this example:

With default parameters , a manual check in the function body is no longer necessary. You can put 1 as the default value for b in the function head:

For more details, see default parameters in the reference.

Rest parameters

The rest parameter syntax allows us to represent an indefinite number of arguments as an array.

In the following example, the function multiply uses rest parameters to collect arguments from the second one to the end. The function then multiplies these by the first argument.

Arrow functions

An arrow function expression (also called a fat arrow to distinguish from a hypothetical -> syntax in future JavaScript) has a shorter syntax compared to function expressions and does not have its own this , arguments , super , or new.target . Arrow functions are always anonymous.

Two factors influenced the introduction of arrow functions: shorter functions and non-binding of this .

Shorter functions

In some functional patterns, shorter functions are welcome. Compare:

No separate this

Until arrow functions, every new function defined its own this value (a new object in the case of a constructor, undefined in strict mode function calls, the base object if the function is called as an "object method", etc.). This proved to be less than ideal with an object-oriented style of programming.

In ECMAScript 3/5, this issue was fixed by assigning the value in this to a variable that could be closed over.

Alternatively, a bound function could be created so that the proper this value would be passed to the growUp() function.

An arrow function does not have its own this ; the this value of the enclosing execution context is used. Thus, in the following code, the this within the function that is passed to setInterval has the same value as this in the enclosing function: