Introduction to Functions in Unix
The routines contain a set of instructions that act as a separate unit in the entire program code, intended for serving a certain purpose, facilitating performing complex tasks, and syntactically written inside an indented block. That is also useful in optimizing the program performance and allows the programmers to build functionalities that can be performed right from the simplest to the most complex tasks that are termed as functions in Unix. This concept assumes complexity based on the nature of the purpose to be addressed using them.
Syntax of Functions in Unix
The creation of Functions follows the basic syntax code as follows. Sample example of a Function.
Code
First()
{
echo “ First Program for defining functions ”;
echo “ Yayyy! “;
}
Here, we have written two echo statements inside our First Function. For calling the Function, we can just call by the Function name.
Output
Passing Parameters to Function in Unix
We have successfully made a simple Function, called it and executed the commands that we required. Now, what if I need to add two numbers through user inputted values? So, here we would see how we can write a function with arguments. The basic syntax would be the same. Example of parameterized function
Code
Second()
{
echo “Enter your name: “;
read name;
echo “Hi $name , have a good day”;
}
4.5 (7,701 ratings)
View Course
Output
It will prompt us to enter a name and wish them
In the same way, we can even create a script file. Let’s write an addition Function inside a shell script and see how it works.
Code
vi add.sh
echo “enter first number: “;
read a;
echo “enter the second number: “;
read b;
sum=$((a+b));
echo “ Result is $sum”;
*********************
Save the file with: wq!
Output
The only this that has to do here is by updating the file permissions.
We can even execute the sh file using the command by . /add.sh
In the same way, we can even execute a Function by providing command-line arguments. So, let’s see how we can do this through the addition of three numbers.
Code
<Addition()
{
number1=$1;
number2=$2;
number3=$3;
sum=$((number1+number2+number3));
echo “Sum is $sum”;
}
Now we can pass our numbers as command-line arguments and then get our required output.
What if we don’t pass any arguments to the Function?
And, if we give only two arguments?
Else, can we pass strings?
We can even have our code in such a way that it can echo out an error when invalid arguments are passed. Below here, let’s see how we can ask the user to input arguments if there were no command-line arguments passed.
Code
Add()
{
number1=$1;
number2=$2;
if [ $# -ne 2 ]; then
echo “ Enter two numbers to add “;
fi
sum=$((number1+number2));
echo “ Sum is : $sum “;
}
Output
If we don’t pass any arguments to our Function, it gives our echo where we have asked to give two command-line numbers and then give the output of sum. It does so, as we did not tell the Function to stop if we encounter the error. In the second case, we can see the output giving sum properly without any intermediate echo. We can even use return commands in returning out values for these Unix Functions. The value in the return statement is being stored in $?
Output
As an exercise, can you try writing a function that breaks out if we don’t pass the arguments?
Nested Functions in Unix
By naming we can Figure out that Nested Functions are about defining a function inside a Function. Let’s see how we can do that now. We are writing this inside a shell script for easier understanding.
Code
vi Nested_Function.sh
***** Code Inside the sh Function*******
#!/bin/sh
First()
{
echo “ Inside First Function “;
echo “ Calling the second function below “;
echo “**********”;
Second
echo “**********”;
echo “ After calling Second function “;
}
Second()
{
echo “ Inside Second Function”;
echo “ Done “;
}
First
************************
Save the file with: wq!
Output
In the above example, we just called the second Function inside the first. Let’s now write a function inside the first function only.
Code
vi Nest_Func1.sh
***** Code Inside the sh Function*******
First_One()
{
echo “ Inside the function First_One”;
echo “ Below is the inner function “;
Second_One()
{
echo “ ********** “;
echo “ Inside Inner function”;
echo “ Completed Second Function”;
echo “ ********** “;
}
echo “Done with second example too”;
}
First_One
Second_one
************************
Save the file with: wq!
Now, what output do you expect? Do you think both the details of the first and second Functions would be displayed?
Output
We can clearly see that the Function did not call the inner function inside it. So, what’s the problem here?
Inside our script, we have called only the first Function. Now try by calling the second Function too. As observed, here we will not be able to call the Function by itself. In the above code, we have highlighted the added code.
Output
Notice that the echo which we have written after the execution of the Second Function has come before itself. Now, if we try calling the second Function first, followed by the First one?
Output
We can clearly understand that until the main/first Function is called the inner function is not being called. As an exercise, can you try the addition of two numbers using nested Functions? (One for inputting user values and others to add the numbers)
Conclusion
So, this is how we can define Functions in Unix. And one major advantage in Unix I found was the error in the output can be easily understood and can help to rectify our code accordingly. Try executing those Functions and use return command too. Have happy learning in Unix.
Recommended Article
This has been a guide to Functions in Unix. Here we discuss an introduction to Functions in Unix and different types of function along with syntax and detail explanation. You can also go through our other suggested articles to learn more –
