Before we talk about bash functions, let’s discuss this situation. When writing bash scripts, you’ll find yourself that you are using the same code in multiple places. If you get tired of writing the same lines of code again and again in your bash script, it would be nice to write the block of code once and call it anywhere in your bash script. The bash shell allows you to do just that with Functions. Bash functions are blocks of code that you can reuse them anywhere in your code. Anytime you want to use this block of code in your script, you simply type the function name given to it. We are going to talk about how to create your own bash functions and how to use them in shell scripts.
Creating a function
You can create a function like this:
functionName {
}
Or like this:
functionName() {
}
The parenthesis on the second snippet is used to pass values to the function from outside of it, so these values can be used inside the function.
Using Functions
#!/bin/bash
function myfunc {
echo "Using functions"
}
total=1
while [ $total -le 3 ]
do
myfunc
total=$(( $total + 1 ))
done
echo "Loop finished"
myfunc
echo "End of the script"
Here we’ve created a function called myfunc and in order to call it, we just typed its name.
The function can be called many times as you want.
Notice: If you try to use a function which is not defined, what will happen?
#!/bin/bash
total=1
while [ $total -le 3 ]
do
myfunc
total=$(( $total + 1 ))
done
echo "Loop End"
function myfunc {
echo "Using function ..."
}
echo "End of the script"
Oh, it’s an error because there no such function.
Another notice: bash function name must be unique. Otherwise, the new function will cancel the old function without any errors.
#!/bin/bash
function myfunc {
echo "The first function definition"
}
myfunc
function myfunc {
echo "The second function definition"
}
myfunc
echo "End of the script"
As you can see, the second function definition takes control from the first one without any error so take care when defining functions.
Using the return Command
The return command returns an integer from the function.
There are two ways of using return command; the first way is like this:
#!/bin/bash
function myfunc {
read -p "Enter a value: " value
echo "adding value"
return $(( $value + 10 ))
}
myfunc
echo "The new value is $?"
The myfunc function adds 10 to the $value variable then show the sum using the $? Variable.
Don’t execute any commands before getting the value of the function, because the variable $? returns the status of the last line.
This return method returns integers. what about returning strings?
Using Function Output
The second way of returning a value from a bash function is command substitution. This way, you can return anything from the function.
#!/bin/bash
function myfunc {
read -p "Enter a value: " value
echo $(( $value + 10 ))
}
result=$( myfunc)
echo "The value is $result"
Passing Parameters
We can deal with bash functions like small snippets that can be reused and that’s OK, but we need to make the function like an engine, we give it something and it returns a result based on what we provide.
You can use the environment variables to process the passed parameters to the function. The function name is declared as $0 variable, and the passed parameters are $1, $2, $3, etc.
You can get the number of passed parameters to the function using the ($#) variable.
We pass parameters like this:
myfunc $val1 10 20
The following example shows how to use the ($#) variable:
#!/bin/bash
function addnum {
if [ $# -gt 2 ]
then
# If parameters no equal 2
echo "Incorrect parameters passed"
else
# Otherwise add them
echo $(( $1 + $2 ))
fi
}
echo -n "Adding 10 and 15: "
value=$(addnum 10 15)
echo $value
echo -n "Adding three numbers: "
value=$(addnum 10 15 20)
echo $value
The addnum function gets the passed parameters count. If greater than 2 passed, it returns -1.
If there’s one parameter, the addnum function adds this parameter twice. If 2 parameters passed, the addnum function adds them together, and if you try to add three parameters it will return -1.
If you try to use the passed parameters inside the function, it fails:
#!/bin/bash
function myfunc {
echo $(( $1 + $2 + $3 + $4))
}
if [ $# -eq 4 ]
then
value=$( myfunc)
echo "Total= $value"
else
echo "Passed parameters like this: myfunc a b c d"
fi
Instead, you have to send them to the function like this:
#!/bin/bash
function myfunc {
echo $(( $1 + $2 + $3 + $4))
}
if [ $# -eq 4 ]
then
value=$(myfunc $1 $2 $3 $4)
echo "Total= $value"
else
echo "Passed parameters like this: myfunc a b c d"
fi
Now it works!!
Processing Variables in Bash Functions
Every variable we use has a scope, the scope is variable visibility to your script.
You can define two types of variables:
- Global
- Local
Global Variables
They are visible and valid anywhere in the bash script. You can even get its value from inside the function.
If you declare a global variable within a function, you can get its value from outside the function.
Any variable you declare is a global variable by default. If you define a variable outside the function, you call it inside the function without problems:
#!/bin/bash
function myfunc {
input=$(( $input + 10 ))
}
read -p "Enter a number: " input
myfunc
echo "The new value is: $input"
If you change the variable value inside the function, the value will be changed outside of the function.
So how to overcome something like this? Use local variables.
Local Variables
If you will use the variable inside the function only, you can declare it as a local variable using the local keyword like this:
local tmp=$(( $val + 10 ))
So if you have two variables, one inside the function and the other is outside the function and they have the identical name, they won’t affect each other.
#!/bin/bash
function myfunc {
local tmp=$[ $val + 10 ]
echo "The Temp from inside function is $tmp"
}
tmp=4
myfunc
echo "The temp from outside is $tmp"
When you use the $tmp variable inside the myfunc function, it doesn’t change the value of the $tmp which is outside the function.
Passing Arrays As Parameters
What will happen if you pass an array as a parameter to a function:
#!/bin/bash
function myfunc {
echo "The parameters are: $@"
arr=$1
echo "The received array is ${arr[*]}"
}
my_arr=(5 10 15)
echo "The old array is: ${my_arr[*]}"
myfunc $my_arr
The function only takes the first value of the array variable.
You should disassemble the array into its single values, then use these values as function parameters. Finally, pack them into an array in the function like this:
#!/bin/bash
function myfunc {
local new_arr
new_arr=("$@")
echo "Updated value is: ${new_arr[*]}"
}
my_arr=(4 5 6)
echo "Old array is ${my_arr[*]}"
myfunc ${my_arr[*]}
The array variable was rebuilt thanks to the function.
Recursive Function
This feature enables the function to call itself from within the function itself.
The classic example of a recursive function is calculating factorials. To calculate the factorial of 3, use the following equation:
3! = 1 * 2 * 3
Instead, we can use the recursive function like this:
x! = x * (x-1)!
So to write the factorial function using bash scripting, it will be like this:
#!/bin/bash
function fac_func {
if [ $1 -eq 1 ]
then
echo 1
else
local tmp=$(( $1 - 1 ))
local res=$(fac_func $tmp)
echo $(( $res * $1 ))
fi
}
read -p "Enter value: " val
res=$(fac_func $val)
echo "The factorial of $val is: $res"
Using recursive bash functions is so easy!
Creating Libraries
Now we know how to write functions and how to call them, but what if you want to use these bash functions or blocks of code on different bash script files without copying and pasting it on your files.
You can create a library for your functions and point to that library from any file as you need.
By using the source command, you can embed the library file script inside your shell script.
The source command has an alias which is the dot. To source a file in a shell script, write the following line:
. ./myscript
Let’s assume that we have a file called myfuncs that contains the following:
function addnum {
echo $(( $1 + $2 + $3 + $4))
}
Now, we will use it in another bash script file like this:
#!/bin/bash
. ./myfuncs
result=$(addnum 10 10 5 5)
echo "Total = $result"
Awesome!! We’ve used the bash functions inside our bash script file, we can also use them in our shell directly.
Use Bash Functions From Command Line
Well, that is easy, if you read the previous post which was about the signals and jobs you will have an idea about how to source our functions file in the .bashrc file and hence we can use the functions directly from the bash shell. Cool
Edit the .bashrc file and add this line:
. /home/likegeeks/Desktop/myfuncs
Make sure you type the correct path.
Now the function is available for us to use in the command line directly:
$ addnum 10 20
Note: you may need to logout and login to use the bash functions from the shell.
Another note: if you make your function name like any of the built-in commands you will overwrite the default command so you should take care of that.
I hope you like the post. Keep coming back.
Thank you.