Creating and calling Functions

3 minute read

Functions in Bash scripting are reusable blocks of code that can be defined once and called multiple times within a script. They allow for modularization, improving code readability, and avoiding redundancy. In this tutorial, we will explore the syntax and usage of creating and calling functions in Bash, accompanied by practical examples.

Basic Syntax of Function Creation

The basic syntax for creating a function in Bash is as follows:

function_name() {
  # Commands to be executed within the function

You can then call the function by using its name followed by parentheses: function_name.

Examples of Creating and Calling Functions

Simple Greeting Function


# Define a simple greeting function
greet() {
  echo "Hello, welcome to the Bash functions tutorial!"

# Call the greeting function

In this example, we define a function called greet that prints a simple welcome message. The function is then called to display the greeting.

Function with Parameters


# Define a function with parameters
multiply() {
  result=$(( $1 * $2 ))
  echo "The result of multiplication is: $result"

# Call the function with arguments
multiply 5 3

Here, the multiply function takes two parameters, multiplies them, and prints the result. The function is then called with arguments 5 and 3.

Returning Values from a Function


# Define a function that returns a value
square() {
  local squared=$(( $1 * $1 ))
  echo $squared

# Call the function and store the result
result=$(square 4)
echo "The square of 4 is: $result"

The square function calculates the square of a number and returns the result. The calling script stores the result and prints it.

Function with Local Variables


# Define a function with local variables
add_numbers() {
  local sum=$(( $1 + $2 ))
  echo "The sum is: $sum"

# Call the function with arguments
add_numbers 7 8

In this example, the add_numbers function uses the local keyword to declare a local variable within the function. The function adds two numbers and prints the sum.

Passing Arguments to Functions

When calling a function, you can pass arguments just like you would with a regular command. The function parameters will capture these values.


# Define a function that uses passed arguments
welcome_user() {
  echo "Welcome, $1! Today is $2."

# Call the function with arguments
welcome_user "John" "Monday"

The welcome_user function takes two parameters, and when called with “John” and “Monday,” it prints a personalized welcome message.


Functions in Bash provide a structured way to organize and reuse code. Whether creating simple greetings, performing calculations, or handling more complex tasks, functions enhance the modularity and maintainability of your scripts.

Now equipped with the knowledge from this tutorial, you can confidently create and call functions in your Bash scripts, making your code more efficient and readable.

Frequently Asked Questions

  1. Can a Bash function have multiple parameters?
    Yes, Bash functions can have multiple parameters, and you can access them within the function using $1, $2, and so on.

  2. Is it possible to return values from a Bash function?
    Yes, Bash functions can return values using the echo command, and the calling script can capture the result.

  3. Can a Bash function modify global variables?
    By default, Bash functions operate in their own scope. If you want to modify global variables, you need to use the local keyword to create local variables within the function.

  4. Are there restrictions on function names in Bash?
    Function names in Bash can consist of letters, numbers, and underscores but cannot start with a number.

  5. How are arguments passed to Bash functions?
    Arguments are passed to Bash functions in the same way as command-line arguments, and they can be accessed within the function using positional parameters like $1, $2, and so on.