Learn about creating and using Functions in Powershell

Functions In Powershell

As you continue to gain invaluable Powershell scripting experience, there will be certain concepts that will notably advance your expertise. One of those areas is the use of functions!

Functions in Powershell are groups of code collected in a single location that can be referenced anywhere in your code.

In this lesson, we’ll examine the following: 
- how to write functions
- the components of a function
- internal versus external functions
- cases where scripts can benefit from the use of functions.  


Text image with the title, Functions, and a quote, Functions will enhance your scripting integrity and code readability and save you time with code reuse.

What Are Functions?

In this lesson, we learned about functions within Powershell - why they're used, correct syntax, parameters, and the tremendous potential they have to enhance your scripting.

As you continue to develop in Powershell, look for opportunities to add functions to your scripting. It will enhance your scripting integrity and code readability and save you time with code reuse!

Great job!

Summary

As you develop scripts, you will likely write similar lines repeatedly. Instead of constantly typing or copying the same lines, it’s best practice to write a function containing those lines. 

Functions are a way to collect code in a single space and reference them with a simple command throughout your script. This makes code easier to read.

```PowerShell
function greet {
  Write-Host "Hello, there!"
}
``` 
The above function is named `greet` and contains one line of code that outputs a hello message. Within our code, we can now "call" the function by its name, `greet`.

If we use the `greet` function multiple times in our code and decide to change our greeting from `"Hello there!"` to `"Hi"`, we only have to change it once; inside the `greet` function.

We also have a useful code block to take to other scripts. If another script needs to output a greeting, we can copy the function over and reference it in our code.

Functions are an excellent programming practice because:
- Whenever a collection of code is needed, it can be called via a single reference, which will make our code cleaner and easier to read.
- If changes are needed to any parts of those lines of code, we can adjust it in a single location rather than multiple locations.
- Reuse! If we've written code for one script, there’s a good chance we might need it for another. Well-designed functions can be used across multiple scripts.


Why Functions?

You may constantly use the same parameter values for most function calls. But you also want to maintain the flexibility of parameters. To streamline your code, you can set up *default parameters*.  

Default parameters give a value to a function parameter when it is declared. The default value is used if no value is passed to that parameter. 
```PowerShell
function greet2 {
  param($name, $timeOfDay = "morning")
  Write-Host "Good $timeOfDay, $name"
}
```
In the above example, the function `greet2` takes `$name` and `$timeOfDay` parameters. The `$timeOfDay` parameter now has a default value `"morning"`. We can now call the function with just a name:
```PowerShell
greet2 "Codecademy"

# Output: "Good morning, Codecademy"
```
In the above example, the output will default to `"Good morning, Codecademy"` since only the `$name` parameter received a value from the function call.

It is important to note that the default parameter, `$timeOfDay` is the 2nd parameter. The parameter values are placed in the parameter variables in the order used in the function call. If `$timeOfDay` was the first parameter and we called the function: 
```PowerShell
greet2 "Codecademy"

# Output: `"Good Codecademy, "`
```
This output is because "Codecademy" would replace the default value `"morning"` in `$timeOfDay` and `$name` would not get any value since only one value was passed with the function call. Default parameters must be used after non-default parameters.

Default parameters are a great way to define a usual behavior for a function but still get the needed flexibility.

Default Parameters

Giving our functions some data to perform the correct task is often helpful. To send data with our function call, we use *parameters*.

Let's say when we greet someone, we would like to use their name:
```PowerShell
function greet1 {
  param($name)
  Write-Host "Hello, $name"
}
```
Within the above function `greet1`, we have added the line `param($name)`. This allows the function to receive data from our function call and place it in the variable `$name`.
```PowerShell
greet1 "Codecademy"

# outputs "Hello, Codecademy"
```
By adding a string to our function call, we now pass `"Codecademy"` to the variable `$name` in the `greet1` function.

We can also pass multiple variables by separating parameters by commas in the function:
```PowerShell
function greet2 {
  param($timeOfDay, $name)
  Write-Host "Good $timeOfDay, $name"
}
```
The function `greet2` is now crafting its greeting using 2 variables, `$timeOfDay` and `$name`.

To call this function, separate the data by spaces after the function call:
```PowerShell
greet2 "Evening" "Codecademy"

# outputs "Good Evening, Codecademy"
```

Parameters allow us to change the behaviors of our functions. This supports their purpose of being able to reuse code in multiple places that may each night need slightly different behavior.

Using Parameters

Let's take a look at what the components of a function are, and how to call it.

The components of a function in PowerShell are: 
- the keyword `Function`
- a descriptive function name
- a code body inside brackets

```PowerShell
Function greet {
     Write-Host "Hello, there!"
}
```
This example from the last exercise starts with the keyword `function`, followed by a name that describes the function action. Lastly, the code block inside curly braces that performs the action.

Once your function has been declared, you can refer to it in code simply by utilizing the name that you’ve given it, such as:
```PowerShell
greet
```
Since our functions perform actions, it is best to name them in a way that best describes the given action. PowerShell uses this approach when naming cmdlets, using action words such as `Get`, `Write` and `Read`. 