Functions in Unix

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”;
}

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 –

1. Unix Architecture
2. Unix commands
3. Uses of Unix
4. UNIX interview questions