Bash Functions

Bash Functions

Introduction to Bash functions


4 min read

Functions are a useful way to organize code and reuse logic in Bash scripts. Here are some highlights of Bash functions:

  • Functions are defined using the function keyword:
function_name () {
   # function body 
  • Functions allow you to group a set of statements together to perform a specific task.

  • Functions can accept arguments just like shell scripts:

function_name () {
    echo "First argument is $1"
    echo "Second argument is $2"

function_name arg1 arg2
  • Functions can return a value using the return statement:
function_name () {
    return 10

echo "Return value is $return_value"
# Prints 10
  • Functions make code reusable. The function definition only needs to be written once but can be called multiple times.

  • Functions help organize complex scripts into logical units.

For example:

print_hello() {
  echo "Hello!"

print_goodbye() {
  echo "Goodbye!"


This will print:

Goodbye! Hello!

Reusing the print_hello() function multiple times.

So in summary, functions allow us to:

  • Reuse code

  • Organize scripts into logical units

  • Pass arguments and return values

They are an essential part of writing maintainable Bash scripts.

Recursive Functions

Bash does allow defining recursive functions. Here is a simple example of a recursive function that calculates the factorial of a number:

factorial() {
   if [[ $1 -le 1 ]]; then
       echo 1
       local n=$(($1-1))
       local result=$(factorial $n)
       echo $(($1 * $result))

# Call the function
factorial 5
# Prints 120 (5! = 5 * 4 * 3 * 2 * 1)

Here's how this works:

  • We define the factorial() function which accepts an integer argument $1.

  • We have a base case where if the number is 1 or less, we return 1.

  • Otherwise, we:

    • Decrement the number by 1 and store in $n

    • Call the factorial() function recursively with $n

    • Multiply the result by the original number and return the result

  • When we call factorial(5), it calls factorial(4), which calls factorial(3), and so on until it hits the base case of factorial(1) = 1. It then starts multiplying the results up the recursive calls to get the final factorial.

So in summary:

  • Bash allows defining recursive functions

  • We need a base case to stop the recursion

  • The recursive call passes a simpler problem until the base case is reached

  • The results are combined on the way back up the recursive calls.

Recursive functions allow solving problems that are naturally divided into simpler sub-problems in Bash.

Is Bash a functional language?

Bash is not considered a functional programming language. While it does support some functional programming features like functions and recursion, it is primarily a scripting language with an imperative programming style.

Some reasons Bash is not a functional programming language:

  • Variables are mutable - Variables can be reassigned new values, which is not functional.

  • Functions have side effects - Functions can modify global variables and the environment, which is not functional.

  • Loops are imperative - Bash uses for/while loops, not map/filter/reduce functions.

  • No support for higher-order functions - Bash does not allow passing functions as arguments to other functions.

  • No support for functions as first-class objects - Functions cannot be assigned to variables or data structures.

While Bash does support functions and recursion as we discussed, it lacks many of the key features that define a functional programming language like:

  • Immutable data

  • Higher-order functions

  • Functions as first-class objects

  • Map/filter/reduce functions

  • Lack of side effects

So in summary, while Bash shares some similarities with functional programming, it is not considered a fully functional programming language due to:

  • Imperative and procedural nature

  • Lack of support for key functional programming concepts and features

Bash is primarily used for scripting tasks and automating command line interactions. Functional programming in Bash is mostly limited to functions and recursion.

Disclaim: This article was created with AI and my guidance. Learn and prosper.๐Ÿ––