Writing Functions in Shell Scripting

This chapter covers the core concepts of writing and executing functions in Shell Scripting (Bash). We will explore how to transition from repetitive, error-prone scripts to modular, reusable code blocks, handle common syntax pitfalls (such as spaces in conditional expressions and modulo operations), and implement clean control flows using real-world analogies.

1. The Debugging Mindset: Handling Modulo & Syntax Sensitivity

When writing shell scripts, developers frequently encounter syntax errors when performing mathematical operations or conditional checks. A classic example is checking if a number is even using the modulo operator (%).

In Bash, syntax is highly sensitive to spaces and brackets. A minor spacing error can cause the entire script to fail or behave unexpectedly.

The Modulo Operator Syntax Challenge

In many programming languages, checking for an even number is as simple as num % 2 == 0. In Bash, however, you must evaluate arithmetic expressions using specific double-parentheses syntax (( ... )) or the expr command.

Naive vs. Correct Modulo Implementations

• Incorrect (Common Mistake):
  BASH

  Copy

  # This will result in a syntax or command-not-found error
  if [ num % 2 == 0 ]
  

• Correct (Arithmetic Evaluation):
  BASH

  Copy

  if (( num % 2 == 0 ))
  then
      echo "Even"
  fi
  

The Alternative: Step-Incrementing

If you want to print even numbers within a loop without dealing with complex modulo syntax, a cleaner and more performant alternative is to increment your loop counter by 2 instead of 1.

# Start at 0, increment by 2 to naturally generate even numbers
num=0
while [ $num -le 10 ]
do
    echo $num
    num=$((num + 2))
done

2. Tabular Synthesis: Modulo Check vs. Step-Incrementing

3. Core Mental Model: What is a Function?

A function is a reusable block of code designed to perform a specific task. Instead of writing the same logic repeatedly throughout your script, you group the commands together under a single name. Whenever you need to execute that logic, you simply "call" the function by its name.

Real-Life Analogy: The "Jethalal Loyalty Check"

Imagine you want to verify if a character (e.g., Jethalal from a popular show) is loyal.

Instead of writing down a 10-step verification process (checking his phone, asking his friends, tracking his schedule) every single time you suspect him, you bundle all 10 steps into a single checklist called is_loyal.

Whenever you need to run the check, you don't rewrite the 10 steps; you simply call the is_loyal checklist. This saves time, reduces errors, and ensures consistency.

4. Shell Function Syntax & Anatomy

In Bash, there are two primary ways to define a function. Both are valid, but consistency is key.

Syntax Style 1: Using the function Keyword

This style explicitly declares the block as a function using the function keyword.

function function_name {
    # Commands to execute
    echo "This is a function"
}

Syntax Style 2: Standard POSIX Style (Recommended)

This style is more portable across different shells (like sh, zsh, and ksh). It omits the function keyword and uses parentheses () after the function name.

function_name() {
    # Commands to execute
    echo "This is a portable function"
}

Calling a Function

To execute a function, write its name on a line by itself. Do not use parentheses when calling the function.

# Correct Call:
function_name

# Incorrect Call (Will cause a syntax error):
function_name()

5. Step-Step Evolution: From Naive Script to Modular Function

Let's look at how we can refactor a repetitive script into a clean, modular script using functions.

Phase 1: The Naive Approach (Repetitive Code)

In this script, we check the loyalty status of multiple characters. The logic is repeated, leading to a bloated script.

#!/bin/bash

# Checking Jethalal
echo "--- Checking Jethalal ---"
read -p "Is Jethalal at home? (yes/no): " status
if [ "$status" == "yes" ]; then
    echo "Jethalal is loyal."
else
    echo "Jethalal is not loyal."
fi

# Checking Iyer (Repeated Logic)
echo "--- Checking Iyer ---"
read -p "Is Iyer at home? (yes/no): " status
if [ "$status" == "yes" ]; then
    echo "Iyer is loyal."
else
    echo "Iyer is not loyal."
fi

Phase 2: The Modular Approach (Using Functions & Arguments)

We can refactor this by creating a single function check_loyalty that accepts the character's name as an argument ($1).

#!/bin/bash

# Define the function
check_loyalty() {
    local name=$1 # Store the first argument passed to the function
    echo "--- Checking $name ---"
    read -p "Is $name at home? (yes/no): " status
    
    if [ "$status" == "yes" ]; then
        echo "$name is loyal."
    else
        echo "$name is not loyal."
    fi
}

# Call the function with different arguments
check_loyalty "Jethalal"
check_loyalty "Iyer"

6. Real-World Practical Pitfalls & Edge Cases

When working with functions in shell scripts, keep these critical execution behaviors in mind:

1. Function Definition Order

In Bash, functions must be defined before they are called. The shell reads scripts sequentially from top to bottom. If you call a function at line 5 but define it at line 20, the shell will throw a command not found error.

# ERROR CASE:
is_loyal # This will fail!

is_loyal() {
    echo "Checking loyalty..."
}

2. Variable Scope (Global by Default)

By default, all variables in Bash are global, even if they are defined inside a function. This can lead to accidental overwrites of variables in other parts of your script. Always use the local keyword inside functions to restrict variable scope.

#!/bin/bash
name="Global Name"

modify_name() {
    local name="Local Name" # Safe: does not overwrite the global variable
    echo "Inside function: $name"
}

modify_name
echo "Outside function: $name" # Prints "Global Name"

7. Complete Execution Flow Walkthrough

Below is the step-by-step execution path of a shell script containing a function definition and invocation:

Summary and Key Takeaways

• Code Reusability: Functions allow you to group repetitive commands into a single, named block, keeping your scripts DRY (Don't Repeat Yourself).
• Syntax Sensitivity: Bash is highly sensitive to spaces. Always ensure proper spacing inside conditional brackets [ ... ] and use double parentheses (( ... )) for arithmetic operations like modulo.
• Step-Incrementing Alternative: When generating even numbers, incrementing your loop counter by 2 (num=$((num + 2))) is often simpler and less error-prone than using modulo checks.
• POSIX Portability: Using the function_name() syntax is preferred over the function function_name keyword syntax for broader compatibility across different Unix shells.
• Definition Order: Always define your functions at the top of your script before invoking them.
• Local Variables: Use the local keyword inside functions to prevent variables from leaking into the global scope and causing unexpected side effects.
• Arguments: Pass data into functions using positional parameters ($1, $2, etc.) just like you would pass arguments to a standalone shell script.