If you have prior experience of programming and you are just getting started with bash, there’s one thing that you may find a little odd.
Unlike other programming languages, functions in bash do not return any value. Instead, it returns exit status or a numeric value indicating the success or failure of execution.
But the question here is how you make the function return value in bash.
Sure, if I’m writing this tutorial, I must have a solution (read workaround) to tackle this issue but before that, let’s understand the problem first.
The problem we’re dealing with
First, let me share a simple C program to explain how programming languages return value through a bash function:
#include <stdio.h>
// Function declaration with return type int
int add(int x, int y) {
return x + y;
}
int main() {
// Call the function and store the result in a variable
int result = add(3, 4);
// Print the result
printf("%dn", result);
return 0;
}If you run the above C program, it will return 7 as shown here:
In the above C program, I created a function named add that takes two values and uses the return statement to add two values.
Sadly, functions in bash do not work that way and what they give you is the exit status of the last command used in the function and the exit status can be 0 (success) or non-zero (failure).
To know the exit bash, there’s a special variable in the bash $? to know the exit status. So let me quickly share how you can use it:
#!/bin/bash
# Defining the function
function test {
echo "A demo function created to check the exit status"
}
# Calling function
test
# Checking the status
echo "The exit status of the test is: $?"
As you can see, it returned 0 indicating the function was executed successfully!
Now, let’s have a look at how you can make the bash function return value.
How to make bash functions return a value
There are two ways in which you can make the bash functions return a value:
- Using the standard output data stream (involves usage of echo or print command)
- Using global variable
Of course, it’s not the same as returning values in C or other programming languages but it may help you in many cases.
So let’s start with the first one.
Method 1: Using the standard output data stream
If you are unaware of data streams, there are 3 data streams in Linux: input, output, and error. Each is meant for a different task.
As the title suggests, I will use the standard output data stream using the echo or the printf command in this method.
Still confused? In simple words, I will be sending the output of the function to the standard output data stream to print the output (there’s where the usage of the printf or echo command).
First, let me share a bash script:
#!/bin/bash
# Function definition
function demo {
local namaste="Namaste from Bash!"
echo "${namaste}"
}
# Call the function and capture its output
output=$(demo)
# Print the captured output
echo "${output}"
When executed, it will give you the following output:
Now, let’s have a look at the explanation part.
First, I created a function demo in which there was a local variable namaste containing the string that I wanted to print.
Later, I used the echo command to print the data inside of the namaste variable.
In the next part, I called the function inside of the $() notion which will execute the demo function in the subshell and the output is captured by the output variable.
Finally, the echo command was used to print the captured output of the ouptut variable.
Pretty easy. Right?
Method 2: Using a global variable
By default, every variable in the bash is global and to use the local variable, you have to use the term local before assigning any value to it.
But the question is how you use a global variable to return value in the bash function. Well, let me show a simple bash script that uses a global variable for that purpose:
#!/bin/bash
# Global variable to store the result
output=""
# Function definition
function generate_greeting {
local name=$1 # Function parameter
# Assign the greeting to the global variable
output="Hello, ${name}!"
}
# Call the function with a name as an argument
generate_greeting "$USER"
- The Best WordPress Page Builder Plugins for Creating Stunning and Customizable Layouts: If you are seeking to improve the appearance of your WordPress site with visually appealing and customizable layouts, page builder plugins offer a valuable solution. This article aims to delve into the concept of WordPress page builder plugins, outlining the reasons for their utility, and presenting a selection of top-rated options such as Elementor, Beaver Builder, Divi Builder, Visual Composer, and Thrive Architect.
- A Basic Guide to Designing a Multilingual Website: Whether your goal is to generate significant revenue or to establish a robust international community, it’s crucial to consider several design elements from the outset. These elements will ensure your website is versatile and can be easily adapted to meet various international standards. Creating foreign-language versions of your site involves more than simple translation; proper localization is necessary before your launch, and early planning can significantly simplify this process.
- 5 Different Types of Shell Commands in Linux: When it comes to gaining absolute control over your Linux system, then nothing comes close to the command line interface (CLI). In order to become a Linux power user, one must understand the different types of shell commands and the appropriate ways of using them from the terminal. In Linux, there are several types of commands, and for a new Linux user, knowing the meaning of different commands enables efficient and precise usage. Therefore, in this article, we shall walk through the various classifications of shell commands in Linux.
- Bare Metal as a Service: Direct access to physical servers: In the evolving landscape of cloud computing, businesses are continually seeking more robust and customisable solutions to meet their unique needs. One such solution that has gained prominence is Bare Metal as a Service (BMaaS). This model offers direct access to physical servers, providing enhanced performance, security, and flexibility. Let’s delve deeper into what BMaaS is and why it might be the right choice for your organisation.
# Access the global variable
echo "${output}"The above script simply greets the currently logged-in user and when you execute the above script, you can expect the following output:
Now, let’s break down the script.
First, the empty global variable output was declared.
Then, the function named generate_greeting was created that takes one parameter name and in the next line, the greeting text with username was assigned to the output variable.
Next, the script will call the function generate_meeting with the $USER argument to get the name of the currently logged-in user.
Finally, using the echo command the value of the global variable output was printed.
Yep, that’s all it takes you to use a global variable to make a function return value in bash.
Which method to use? (in my opinion)
I personally don’t like the idea of using a global variable to make the bash functions return a value and there’s a simple reason why.
Global variables by their nature can be accessed and modified anywhere in the script which may cause trouble, especially if the script is complex and it may be changed by the user in between.
So what I’d recommend is to use the first method, which utilizes the standard output data stream.
I hope you will find this guide helpful.
New to bash scripting? Start here 👇
