LWM-Linux/07 - Shell Scripting Basics/Functions in Bash.md

# Functions in Bash: A Comprehensive Guide

## 1. Introduction to Bash Functions

Bash functions are reusable pieces of code that perform a specific task. They help in organizing code, improving readability, and reducing repetition. Functions in Bash are similar to functions in other programming languages but with some unique characteristics.

## 2. Basic Syntax

The basic syntax for defining a function in Bash is:

```bash
function_name() {
    # Function body
    # Commands go here
}
```

Alternatively, you can use the `function` keyword:

```bash
function function_name {
    # Function body
    # Commands go here
}
```

## 3. Calling Functions

To call a function, simply use its name:

```bash
function_name
```

## 4. Function Parameters

Bash functions can accept parameters, which are accessed using special variables:

- `$1`, `$2`, `$3`, etc.: Positional parameters
- `$@`: All parameters as separate quoted strings
- `$*`: All parameters as a single quoted string
- `$#`: Number of parameters

Example:

```bash
greet() {
    echo "Hello, $1! Nice to meet you."
}

greet "Alice"  # Output: Hello, Alice! Nice to meet you.
```

## 5. Return Values

Bash functions don't return values in the traditional sense. Instead, they use exit status:

```bash
is_even() {
    if (( $1 % 2 == 0 )); then
        return 0  # Success (true)
    else
        return 1  # Failure (false)
    fi
}

is_even 4
echo $?  # Output: 0 (success)

is_even 5
echo $?  # Output: 1 (failure)
```

## 6. Capturing Function Output

To capture a function's output, use command substitution:

```bash
get_date() {
    echo $(date +"%Y-%m-%d")
}

today=$(get_date)
echo "Today is $today"
```

## 7. Local Variables

Use the `local` keyword to declare variables that are only accessible within the function:

```bash
my_function() {
    local my_var="Hello, local variable!"
    echo $my_var
}

my_function  # Output: Hello, local variable!
echo $my_var  # Output: (empty, as my_var is not accessible here)
```

## 8. Function Scope

Functions in Bash have access to global variables, but it's generally better to pass values as parameters:

```bash
global_var="I'm global"

my_function() {
    echo "Inside function: $global_var"
    local local_var="I'm local"
    echo "Local variable: $local_var"
}

my_function
echo "Outside function: $global_var"
echo "Trying to access local_var: $local_var"  # This will be empty
```

## 9. Function Libraries

You can create function libraries by putting related functions in a separate file and sourcing it:

```bash
# In file: my_functions.sh
greet() {
    echo "Hello, $1!"
}

farewell() {
    echo "Goodbye, $1!"
}

# In your main script
source my_functions.sh

greet "Alice"
farewell "Bob"
```

## 10. Advanced Techniques

a. Default Parameters:
```bash
greet() {
    local name=${1:-"Guest"}
    echo "Hello, $name!"
}

greet  # Output: Hello, Guest!
greet "Alice"  # Output: Hello, Alice!
```

b. Variable Number of Arguments:
```bash
sum() {
    local result=0
    for num in "$@"; do
        ((result += num))
    done
    echo $result
}

sum 1 2 3 4 5  # Output: 15
```

c. Recursive Functions:
```bash
factorial() {
    if (( $1 <= 1 )); then
        echo 1
    else
        local prev=$(factorial $(($1 - 1)))
        echo $(($1 * prev))
    fi
}

factorial 5  # Output: 120
```

## 11. Best Practices

- Use descriptive function names
- Comment your functions, especially for complex operations
- Keep functions focused on a single task
- Use local variables to avoid naming conflicts
- Pass data to functions as parameters rather than relying on global variables
- Use `set -e` at the beginning of your script to exit on any error, including within functions

## 12. Debugging Functions

Use the `set -x` command to enable debugging mode, which prints each command before executing it:

```bash
set -x  # Enable debugging
my_function() {
    echo "Doing something"
    local result=$((2 + 2))
    echo "Result: $result"
}
my_function
set +x  # Disable debugging
```

## Conclusion

Bash functions are powerful tools for creating modular, reusable code. They can significantly improve the organization and maintainability of your shell scripts. By mastering functions, you'll be able to write more efficient and elegant Bash scripts.