Mastering the use of functions is one of the 5 fundamental skills of building algorithms:

- Variables.
- Conditionals.
- Arrays.
- Loops.
`Functions`

.

Basically, a function is a bunch of code wrapped between brackets that you can run anytime, whenever you like. For example:

`1//the function name is "multiply" and receives 2 parameters: a & b 2function multiply(a, b) { 3 //the function returns the multiplication between those 2 parameters 4 return a * b; 5}`

**Every function must have a purpose**(a goal) (like our function “multiply”). The function's purpose is to calculate the multiplication between two given numbers.**It must have a unique name.**In this particular case, our function is called “multiply”, which is a great name because you know exactly what the function is about, it's explicit.**It must return something.**By default, in javascript all functions return “undefined” but you should override and always return something useful. In this example, we want to return the result of a & b multiplication.**Functions may have parameters.**A “parameter” is a variable that the function may receive at the beginning of its code (like a & b in our example).

The whole idea is to have a library of hundreds of functions and use them as you please, you declare all your functions, and later you start using and re-using them all the time.

`1let resultOfMultiplication = multiply(2,4); 2// resultOfMultiplication will be 8`

Coding is very abstract and usually, you forget what you wrote yesterday. Before functions existed, algorithms were this huge, never-ending series of lines of code where developers would have a hard time and get lost. It is hard for your brain to follow a procedure/algorithm of great length; the more lines of code, the more abstract it becomes.

By using functions, you have the following advantages:

- Divide and conquer: divide your algorithm into smaller sub-algorithms and focus on one problem at a time.
- Re-use your code by calling the function several times, dramatically reducing your code length.
- Organize your code: function names will tell you what that piece of code does, you can have all the functions in a separate file and re-use it in all your future developments.

If you think about it, functions are the equivalent of books. They store knowledge and ways of doing things, and in future developments, you re-use them instead of having to figure out everything all over again.

All functions must start and end somewhere, that it's called **the scope of the function**. You can delimit the boundaries using curly brackets like this:

`1 2//this part of the code is OUTSIDE the 'multiply' function 3 4function multiply(a, b) { 5 6 //this part of the code is INSIDE the 'multiply' function 7 8 return a * b; 9 10 //this part of the code is INSIDE my function but it will never be executed because it is located AFTER the return statement. 11} 12 13//this part of the code is OUTSIDE the 'multiply' function`

Any variables that you declare inside the function will not be available outside of it.

`1function multiply(a, b) { 2 3 let myVariable = 'hello'; 4 5 return a * b; 6} 7 8console.log(myVariable); 9// this console.log won't work, it will trigger an error because myVariable was declared inside the function multiply, therefore it is not available outside. 10`

☝ It is very important to remember that once you use the

`return`

statement the function will stop executing, if there is any code after that statement it will never be executed.

You can declare functions without names, but only if you store them in variables like this:

`1const multiply = function(a, b) { 2 return a * b; 3}`

The only way to use (a.k.a: call) a function is to use parenthesis brackets like this:

`1//this is how you call a function without parameters 2multiply(); 3 4//this is how you call a function with parameters 5multiply(<first param>,<second param>); 6 7//for example, to multiply 3 times 9 8multiply(3,9);`

Please remember to assign the function whatever parameters it should receive. In our example, the multiply function was declared, asking for two numbers to multiply. Play with the following example as you like:

You can combine functions however you want and have chained calls like this:

`1function sum(a,b){ 2 return a+b; 3} 4function multiply(a,b){ 5 return a*b; 6} 7 8console.log(multiply(sum(3,5),sum(1,1))); 9 10// the executions go from inside to outside 11// first, the sum of 3+5 and 1+1 will be calculated 12// then, their respective results will be multiplied 13let firstSum = sum(3,5); 14let secondSum = sum(1,1); 15console.log(multiply(firstSum, secondSum));`

The following code has 3 functions declared:

*function getAverage( array: ages){*
...

*function getYoungest( array: ages){*
...

*function getPersonInfo( string: name){*
...

As you can see, the function names are pretty specific about what the functions do, as well as the parameters assigned to them.

Here is the more detailed example:

Other important things to notice:

- We are calling the function
`getPersonInfo`

two times, without using functions we would have to use more code, because we would have no option to re-use the function. - The function
`getAverage`

is to get the average value on a given array. It knows nothing else, and that is great! By separating your code into little functions, you can focus on one thing at a time.