# Bash Scripting Functions — Writing Clean, Reusable Automation Code (Part 3)

Up to this point, you’ve learned many Bash scripting concepts:

* Variables
    
* Conditionals
    
* Loops
    
* Parameters
    
* User input
    

Now we arrive at the **final core concept of Bash scripting**: **functions**.

Functions are what turn Bash scripts from long, messy command lists into **clean, readable, reusable automation tools**.

---

## Why Functions Are Important

Even with simple examples, Bash scripts can quickly grow:

* Multiple `if` statements
    
* Nested loops
    
* Repeated blocks of logic
    

In real DevOps scripts server setup, monitoring, backups you can easily end up with **hundreds of lines of code**.

This creates two major problems:

1. Scripts become hard to read and understand
    
2. Similar logic gets repeated in multiple places
    

Functions solve both problems.

---

## What Is a Function in Bash?

A **function** is:

* A named block of code
    
* A reusable container for logic
    
* A way to group related commands together
    

Instead of repeating the same logic multiple times, you:

* Put it in a function
    
* Call the function whenever you need it
    

Just like variables:

* You define them once
    
* You use them many times
    

---

## Defining a Function

Basic function syntax:

```bash
function score_game() {
  # logic goes here
}
```

Everything inside `{ }` belongs to the function.

Indentation is not required by Bash, but it **greatly improves readability**.

---

## Functions Do Not Run Automatically

Defining a function does **not** execute it.

Just like defining a variable does not print it.

To run a function, you must **call it by name**:

```bash
score_game
```

---

## Example: Moving Existing Logic into a Function

If you previously had a loop or a program that:

* Asked for scores
    
* Calculated a total
    
* Repeated until the user quit
    

You can move that entire logic into a function:

```bash
function score_game() {
  sum=0
  while true; do
    read -p "Enter score (Q to quit): " score
    if [ "$score" = "Q" ]; then
      break
    fi
    sum=$((sum + score))
    echo "Total score: $sum"
  done
}
```

And execute it with:

```bash
score_game
```

---

## Commenting Code in Bash

To temporarily disable or explain code, use comments.

```bash
# This line will not be executed
```

Comments are useful for:

* Documentation
    
* Debugging
    
* Explaining logic
    
* Temporarily disabling commands
    

---

## Functions with Parameters

Functions can accept parameters just like scripts.

Inside a function:

* `$1` → first parameter
    
* `$2` → second parameter
    

Example: A reusable file-creation function

```bash
function create_file() {
  filename="$1"
  touch "$filename"
  echo "File $filename created"
}
```

Calling the function:

```bash
create_file test.txt
create_file myfile.yaml
create_file myscript.sh
```

---

## Best Practice: Keep Functions Small

A good guideline:

* More than **5 parameters** → function is probably doing too much
    
* Split large logic into smaller functions
    

Functions should:

* Do one thing
    
* Do it well
    
* Be easy to understand
    

---

## Using Boolean Parameters

Functions can accept **Boolean values** (`true` / `false`).

Example:

```bash
function create_file() {
  filename="$1"
  is_shell_script="$2"

  touch "$filename"

  if [ "$is_shell_script" = true ]; then
    chmod u+x "$filename"
    echo "Added execute permission"
  fi
}
```

Calling it:

```bash
create_file test.txt false
create_file myscript.sh true
```

`true` and `false` are Bash keywords representing Boolean values.

---

## Returning Values from Functions

Functions can return a result.

Example: Summing two numbers

```bash
function sum_numbers() {
  result=$(($1 + $2))
  return $result
}
```

Calling the function:

```bash
sum_numbers 2 10
result=$?
echo "Sum of 2 and 10 is $result"
```

---

### `$?` — Special Return Variable

* `$?` holds the return value of the **last executed command**
    
* Commonly used to capture function results or command exit codes
    

---

## How Functions Fit into Bigger Scripts

Functions can be:

* Used inside loops
    
* Called inside conditionals
    
* Combined with parameters
    
* Reused across scripts
    

They help structure scripts that:

* Configure servers
    
* Install software
    
* Create users
    
* Monitor systems
    
* Perform backups
    
* Interact with external APIs
    

---

## Bash Scripting in the Real World

Bash scripting is:

* Powerful
    
* Portable
    
* Widely available
    

But also:

* Verbose
    
* Syntax-heavy
    
* Harder to maintain at large scale
    

That’s why DevOps engineers often combine:

* Bash (quick automation)
    
* Python (complex logic)
    
* Configuration tools (Ansible, etc.)
    

Knowing Bash gives you the **foundation** to understand and debug all of them.

---

## Final Takeaway

In this final Bash scripting lecture, you learned:

* What functions are
    
* Why they matter
    
* How to define and call functions
    
* How to pass parameters
    
* How to use Boolean values
    
* How to return values
    
* How functions improve readability and reuse
    

With variables, conditionals, loops, parameters, environment variables, and functions, you now know the **core building blocks of Bash scripting**.

Bash scripts are:

* Automation tools
    
* Documentation
    
* Reusable DevOps assets