You learned that you can pass information called an argument to a function.

The function stores that value in a parameter and uses it within the function.

Functions can accept more than one argument.

When calling a function, you're able to pass multiple arguments to the function.

Each argument gets stored in a separate parameter and

used as a separate variable within the function.

Let's revisit the example of you and

your assistant in the useful goToCoffeeShop function.

Perhaps you not only want to order a drink but

also get something to eat when your assistant runs off to the coffee shop.

Currently, the goToCoffeeShop function is limited to just one item.

You can another parameter in the function definition by typing a comma,

followed by the parameter name.

Let's call it pastry.

Then update the programming inside the function to use the new pastry perimeter.

Now this function expects two arguments.

When you call the function,

pass the second argument by typing a comma followed by a value.

croissant, for instance.

This function is now flexible enough for you to order a different drink and

pastry each time it's called.

All right, now let's create a function that uses multiple parameters and

arguments.

This time, open the file named multiple-args.js.

And as usual, update the script tag in index.html so

that it points to multiple-args.js.

The function we'll create is going to calculate the area of a rectangle.

Define a function named getArea, and the math for

calculating the area is pretty straightforward.

Multiply the length of a rectangle by its width.

Let's have this function accept a length value and

a width value via the parameters width and length.

Inside the function, declare a variable named area.

Its value is the result or product of width times length.

And let's have the function returned the value of area using a return statement.

Now to use this function, you call it and pass it a width and

length value, let's say 10 and 20.

Let's view the value in the console.

Once the browser loads JavaScript,

you can call any functions in your JavaScript file directly from the console.

For example, I'll test the getArea function by cutting the function call

out of the file, saving the file, and pasting it in the console.

The function returns an area of 200, but 200 what?

I want to return a value that includes a unit of measurement, like square feet and

square meters.

For example, a value like 200-square feet.

To do that, I'll add a third parameter to the function called unit.

Remember, a function can only return a single value.

So I'll need to adjust the return statement to return a string holding

the area and unit.

I'll replace area with a template literal that uses the ${} syntax,

or string interpolation, to insert the values of area and unit into the string.

I'll save this file, refresh the page and back in the console,

I'll press the up arrow key wants to bring back the getArea function call.

This time I'll pass the unit value as a string.

Now the console output's 200 sq ft.

I'll try a different set of values.

Let's say 5, And

17.5, sq m.

That returns 87.5 sq m, good.

You're able to pass any number of arguments to a function.

Too many arguments, however, can make your functions difficult to manage.

For instance, passing 12 arguments to a function and adding 12 parameters to

a function definition makes it challenging to track each value.

In a future course, you'll learn more efficient ways to pass lots of

pieces of information to a function with something called an array,

as well as an object literal that holds multiple values.

For now, keep in mind that passing more than four or five arguments to a function

can make your function tedious to use and harder to read.