You're learning that functions are a way to run several lines of JavaScript code by

issuing just a single command.

When you call a function,

you tell the JavaScript engine to jump to that function and run the code inside it.

Remember back when you said, go to the coffee shop, to your assistant?

They dashed off to the coffee shop.

When your assistant returned, they handed you coffee.

Well, functions can also give something back when they finish.

This is called, returning a value, and it's common when working with functions.

For example, let's say you needed a way to get the current time so

that you can display it on a web page.

You could create a function that gets the current time and

actually writes it to the page.

Better yet, you could create a function that just gets the time and

gives it back to you.

That way you can not only write the return value to the page, but

you could also use the return value in other ways,

like displaying it in an alert box, or printing it to the console.

In other words, creating a function that just does one thing,

returns the current time, makes the function flexible enough

that you can use it in many different situations.

To return a value from a function, you use the return keyword.

This creates what's called a return statement.

When the JavaScript engine, or

interpreter, encounters the return keyword,

it immediately jumps out of the current function and provides the value to return.

The value that's returned by the function can then be used in your program.

For example, in this case, the return value is given to the alert function.

So the message, your coffee is on its way, appears in an alert dialog box.

But you could use this return value in many different ways.

Print it to the console, or even save it in a variable.

Let's look at the alertRandom function we created earlier and

see how we can improve it.

Generating a random number from one to six is useful.

You can use to build a dice-rolling game, for example.

But the function we created is limited.

It generates a random number but always displays it in an alert box.

What if we wanted to show the random number on the page,

appear on the console, or store it in a variable?

We can make this function more useful by returning the random number only.

That way we could use it any way we wanted to.

I'll show you what I mean by first removing the alert method

from the function.

Next, I'll add a return statement to return a value from a function.

You use the return keyword.

And what do we want to return?

Well, the value stored in randomNumber.

So now the function name alertRandom doesn't make a whole lot of sense,

because the function no longer pops up an alert.

So I'll change it to getRandomNumber, because that's what it's now doing.

So now I can use this function anywhere I want to get a number from one to six.

For example, in an alert dialogue like this.

I can also print it to the console with the console.log method.

I can even store the function in a variable that I can use later.

For example, const dieRoll = a call to getRandomNumber.

And that's right,

a function call itself can be a value that gets stored in a variable.

Creating functions that only return a value is common in programming.

For example, you might create a function that computes the total cost of an item,

including tax and shipping.

The function would return that total cost so that you can use it in other ways,

like displayed on the web page, or use it for more calculations.

Lastly, functions always return a value,

even when they don't have a return statement.

If you don't specify a return value, the function returns undefined.

For example, in the console,

I’ll paste the alertRandom function we first wrote, then call it.

When I run this code, the browser pops up the alert, and

notice that undefined displays in the console.

Undefined is one of JavaScript's built-in values.

When returned by a function, it means that there's no return value specified.

Now, I'll call the getRandomNumber function here in the console.

And this time, the console inputs a random number value.