Definition and Syntax

Purpose

Overview A shell function is analogous to a command alias. It encapsulates a block of code into a named unit. This unit can then be invoked elsewhere to execute the entire block. Functions can also be placed in separate files and sourced when needed.

Benefits

• Defining recurring code segments as functions reduces overall code volume and enhances development efficiency.
• Improves readability and manaegability of scripts.
• Facilitates modular program design, promoting code reuse and portability.

Syntax

Standard Form:

function func_name () {
    commands...
    return n
}

Simplified Form:

func_name () {
    commands...
    return n
}

Execution Methods Functions can be simple or parameterized:

• func_name
• func_name arg1 arg2

Parameter Handling Notes:

1. Shell positional parameters ($1, $2, $#, $*, $?, $@) can serve as function arguments.
2. The function's arguments temporarily shadow the parent script's parameters.
3. $0 remains the name of the parent script.
4. The original script arguments are restored after the function completes execution.
5. Parameter variables are defined within the function's scope.

Key Details

• Invoke functions using only the name; omit the function keyword and parentheses.
• Function definitions must precede their invocation in the execution flow.
• Shell execution precedence: Aliases > Functions > System Commands > Executable Files.
• Functions share variables with their calling script. Local variables and special positional parameters can be defined within functions.
• Inside a function, return exits the function, while exit exits the entire script.
• return provides an exit status to the calling context; exit returns a status to the shell.
• Functions stored in separate files must be loaded using source or . (dot).
• Use the local keyword inside functions to define variables that are scoped to the function and cease to exist outside it.

Practical Examples

Basic Function Definition and Call vim /opt/scripts/example1.sh

#!/bin/bash
func_one () {
echo "Executing function one."
}
func_two () {
echo "Executing function two."
}
func_one
func_two

Execution: bash /opt/scripts/example1.sh

Executing function one.
Executing function two.

Explanation: Two functions are defined and subsequently invoked, producing their respective output.

Sourcing Functions from a System Library The /etc/init.d/functions file is a standard Linux function library. You can add functions there and source them.

• Append a function to the library:

cat >>/etc/init.d/functions <<'EOF'
display_message () {
    echo "Function loaded from system library."
}
EOF

• Create a script that sources and uses the function: vim /opt/scripts/example2.sh

#!/bin/bash
[ -f /etc/init.d/functions ] && . /etc/init.d/functions || exit 1
display_message

Exeuction: bash /opt/scripts/example2.sh

Function loaded from system library.

Explanation: The script checks for the library file's existence, sources it, and then calls the defined function.

Function with Parameters vim /opt/scripts/example3.sh

#!/bin/bash
greet_user () {
echo "Hello, the provided name is: $1"
}
greet_user $1

Execution: bash /opt/scripts/example3.sh Alice

Hello, the provided name is: Alice

Explanation: The function greet_user uses the positional parameter $1. When the script is invoked with an argument, that argument is passed to the function's $1 parameter.