# Functions

Imagine you are writing the software for a video game. In this game, players are able to buy and drive cars. There are:

1. A red Jaguar
2. A blue Camaro
3. A green Wrangler

So far you've written the program that makes the red Jaguar work: your player can enter and exit the Jaguar, and they can drive around their virtual city. You wrote the program and everything works.

Great!

But there's just one little problem: now you need to write the programs for the blue Camaro and the green Wrangler. You already know how to do this (the red Jaguar works!), but you'll need to copy-paste **all** **the code you wrote** for the red Jaguar, and edit each line to make it work for the blue Camaro and the green Wrangler, and you are definitely **not** looking forward to this.

This is where functions come in.

A function is a re-usable piece of a program. It can be written just once, then used over and over again. 

To solve your video game problem, all you would need to do is... write functions to do everything the red Jaguar already does (door open, door close, engine start, drive, engine stop) and use these functions for the blue Camaro and the green Wrangler. You would finish the game much sooner, and you won't have to copy-paste your old code and read each line to make it work for any new cars.

> A function is a re-usable piece of a program. It can be written just once, then used over and over again. 

In this section, we will use functions to make our most complex program yet. Our program is a ticketing system (similar to the ones used in cinemas) that will sell tickets to customers. Children and teenagers will be charged $1 for admission, and adults will have to pay $2.

We will learn how to split our programs into functions effectively, as well as how to re-use functions.

To start things off, we will write the first draft of our program:

{% code lineNumbers="true" %}

```javascript
let age = 10
let price = 0 // this represents $0

if (age < 18) {
    price = 1
} else {
    price = 2
}

print(price)
// outputs 1
```

{% endcode %}

*If you're having trouble understanding this program, you'll need to pause here and read the sections on* [*Variables*](https://icheka-ozuru.gitbook.io/sonarlang/syntax-basics/variables) *and* [*Conditionals*](https://icheka-ozuru.gitbook.io/sonarlang/syntax-basics/conditionals)*.*

This seems easy enough, but if we need to extend our program, we'll begin to do a lot of copy-pasting. For example, if we want to charge teens $1.50, we'll need this:

{% code lineNumbers="true" %}

```javascript
let age = 14
let price = 0 // this represents $0

if (age < 13) {
// if the customer is a child
    price = 1
} else {
    if (age > 12 and age < 20) {
    // if the customer is a teenager
        price = 1.5
    } else {
    // if the customer is an adult
        price = 2
    }
}

print(price)
// outputs 1.5
```

{% endcode %}

Now our program is a little bit larger and much more complex than before, but if we look closely, we'll see that we are basically doing the same thing for each kind of customer, and if we need to give a discount to senior citizens (aged 60 years or more), we'll need another **if...else** statement to set the price.

### Using Functions to Avoid Duplicating Code

It is considered very bad form to duplicate bits of code when we need them in multiple places. The answer to this is to write the code in one place, using a **function**, and then **call** that function in all the places that we need it.

A function is created by using the **func** keyword.

```javascript
func sayName() {
    print("My name is Frodo Baggins")
}
```

This creates a **function** called **sayName.** Each time we call **sayName**, our program will output "My name is Frodo Baggins".

The **func** keyword tells the computer that we are about to create a function. The **func** keyword can only be used to create functions.&#x20;

After **func**, we give the function a name. The name we choose must be easy to understand. It must also describe what the function will do when it is called.&#x20;

The parentheses after the function's name are very important. We will see how in a bit.

Finally, the curly braces ("{" and "}") tell the computer that everything that comes in-between is part of the function's **body** (the "body" of a function refers to all the code that the function represents. Wherever the function is called, these codes are executed as if they were written right there.)

### Calling the sayName Function

Calling a function in **Sonar** is as easy as writing the function's name, followed by two opposite parentheses.

{% code lineNumbers="true" %}

```javascript
func sayName() {
    print("My name is Frodo Baggins")
}

sayName()
// outputs "My name is Frodo Baggins"
```

{% endcode %}

Now **sayName()** can be called several times to outputs Frodo's name whenever we need to.

### Using Arguments to Give Our Functions Superpowers

In programming, an argument is a value that we give to our functions to make them more powerful and re-usable.

To illustrate, imagine we need to write a program to show the name of every *Lord of the Rings* character. We could write:

{% code lineNumbers="true" %}

```javascript
func sayFrodoName() {
    print("My name is Frodo Baggins")
}
func saySamwiseName() {
    print("My name is Samwise Gamgee")
}
func sayPippinName() {
    print("My name is Pippin Took")
}

sayFrodoName()
saySamwiseName()
sayPippinName()

// outputs
// My name is Frodo Baggins
// My name is Samwise Gamgee
// My name is Pippin Took
```

{% endcode %}

For just three characters, we've already used up 13 lines, and in all three functions, we are basically doing the same –– outputing the name of the character.

We can take this a step further by condensing all three functions to one, and using an **argument** to receive the name of the character into the function and show its name.

An argument is just a way to send data into a function so that the function can use it as if it is a variable that was declared inside it.

{% code lineNumbers="true" %}

```javascript
func sayCharacterName(character_name) {
    print("My name is", character_name)
}

sayCharacterName("Frodo Baggins")
sayCharacterName("Samwise Gamgee")
sayCharacterName("Pippin Took")

// outputs
// My name is Frodo Baggins
// My name is Samwise Gamgee
// My name is Pippin Took
```

{% endcode %}

By using an argument called **character\_name**, we have successfully reduced our main program from 13 lines to 7.

Let's see what exactly is going on here:

1. We wrote a function (sayCharacterName).
2. **sayCharacterName** expects to be called with one argument (character\_name).
3. within the function (sayCharacterName), **character\_name** can now be used just the same way as any variable declared with the **let** keyword.

### The 'Return' Keyword

One way to think about functions is that they are like separate programs within the larger, original program. They have their own variables (this is called "scoping") and they can even have other functions contained in them.

Since functions are their own separate programs, they need a way to communicate with the outside, larger program. This program-function data exchange is necessary for building truly powerful programs. There are several ways functions communicate with the main program. One of these is the use of the "**return" statement.**

When the **return** statement is used, it immediately stops the function from being executed further and returns some value to the main program. An example will make this clearer.

Imagine you need to write a simple calculator that can add, subtract, mulitply and divide two numbers. You might create **add**,**subtract**, **mulitply** and **divide** functions like these:

{% code lineNumbers="true" %}

```javascript
func add(num1, num2) {
    return num1 + num2
}
func subtract(num1, num2) {
    return num1 - num2
}
func multiply(num1, num2) {
    return num1 * num2
}
func divide(num1, num2) {
    return num1 / num2
}

// store the result of adding these numbers
let result = add(1, 2)
print(result)
// outputs 3
```

{% endcode %}

When the **return** statement is the last line in a function, it can be safely omitted like this:

```javascript
func add(num1, num2) {
    num1 + num2
}

let result = add(1, 2)
print(result)
// outputs 3
```