Pipes and sub shells are one way of expanding the capabilities of our shell. The ultimate way is by writing shell scripts. These scenarios must be taken into consideration when dealing with complex tasks that can't be automated with a one line command. The good news is that almost any task can be automated with the use of shell scripts. We won't go over an introduction to shell script and instead, we will be looking at some more advanced use cases for writing them. Enough talking and let's start our journey into shell scripting.

First thing that's open a file called script.sh and split the screen so that you can test while writing. Every shell should start with the shebang command, which is which are these characters and followed by the interpreter. It will our shell script will use we will be using bash is our default interpreter. And it's a good idea to use bash because it's a common interpreter that comes with most Linux distributions, and also our six. So shebang being bash. Let's start with a simple use case, reading the arguments passed into the command line, we will assign the value of the first our command line argument, dollar one to a variable called arc, and then print it back to the screen.

Let's save our script and assign it execution permissions and then run it with one argument. As you can see, the default value test is printed back to the screen. In some cases, we want to assign default values to variables. In order to do this, add this to the variable assignment followed by the default value. Now if we rerun the script, we can see that passing no arguments, we'll call that the value, default value actually. And just like pipes, we can change multiple default value assignments together, we can define another variable, or ox, assign it the value 123.

And use the same syntax to assign its value to the arc variable before using the default value script like so. In this case, arc will always receive 123 as its default value. Now let's look at string selectors. To select the substring use the colon followed by the starting position, followed by another colon followed by how many characters like this. In our case, we will be selecting four characters starting from character five. After running the script, we can see the default value long printed to the screen.

Most shell scripts are designed to be run from the command line and receive a variable number of arguments In order to read command line arguments without knowing the total number of arguments, we use the while statement that checks the first argument to not be now using the minus set conditional expression, which means to not be equal to zero. In the while loop, let's echo the variables value and run shift, which shifts command line arguments one position to the left. If we run our script with the arguments, ABC, we can see that our while loops through the parameters and printed each one on a separate line. Now let's extend our key arguments parser and add the case statement for interpreting the argument. Let's assume that our script will have a help option. parsing standard recommends doing long arguments version with minus minus and short version with only one minus so both H and help will bring The Help message.

Also it is recommended to always have a default case and print the message when the user sent invalid options and then exit with a non zero exit value. If we run our script with the minus h option, we can see the message printed. Same as minus minus help. If we run the script with any other option, the invalid option text is printed and the script exits with the exit code one. To get the exit code of the last command use dollar question mark for your Echo. Now let's look at basic functions in Shell.

The syntax is pretty similar to other programming languages. Let's write the function called print IP that will print the IP of the interface specified as the first argument and we will use a subshell and assign the value to a variable called IP. We already have the full command inside our clipboard It's the same one we saw in the lesson about pipes. Now let's add another case store switch statement for the minus E or minus minus A p option. The option will be followed by the name of the interface, which will then pass to the print IP function. Having two arguments for one option means we need to call the shift command twice.

Let's do an IP config to get the name of our wireless interface. And now let's run the following command. Okay, and we can see the IP address. This is a very basic use case where we can see how command line arguments can be passed. We can add our limited options store case statement, defined functions for handling the arguments and even chain multiple options together to form complex scripts and receive well structured information as command line arguments. being effective means running tasks fast fast.

And when it comes to speed bash is not really the first choice in terms of script interpreters. Luckily, we still have some tricks up our sleeves. So if a shell script needs to run multiple independent tasks, we can use the end simple to send the process in background and move forward to the next command. Let's create two functions long running task one and two and and sleep colony side to simulate a long running task. The first long running task function will be sleeping one second and the next will be sleeping two seconds. Then for testing purposes, let's add another key store switch statement called minus p or minus minus parallel and Run the tool long running tasks.

Now if we run this command, it will Take a total of three seconds for the script to finish, we can measure this with the time utility. If you run both functions in the background, we can reduce the running time to the longest running time of both functions because of the weight. When running long running tasks, we probably want the script to wait for the longest running task to finish. In our case, task two. We can achieve this by grabbing the PID of the second task. Here we use the dollar exclamation mark to grab the PID of the last friend command.

Then we use the wait built in command to wait for the execution to finish. After running the script again with the time utility, we can see it takes us a total of two seconds to complete the task. Who would have thought we can do parallel processing in Shell. In the case that the executions take a longer time we can add up notification when the script finishes, notify sent script.sh execution finished. This way, we can start the script to work on some other tasks and receive a notification when the script finishes, you can let your imagination go wild on the things you can achieve with parallel processing, and notifications. Through this lesson, we have seen some common shell predefined variables.

They were this for first argument. This returns the code of the last command, and this is the fifth of the last command run. Other commonly used shell predefined variables include the number of parameters, the list of parameters, all the parameters, the name of the shell script, or the script and the piece of the current running shell. Bash has a lot of features and we recommend going through its man page too. get more information about them. shell scripts are amazing when used the right way.

They can find you in system commands like we saw in our example when we got only the IP address without the whole IP config output, and much much more. You as a pragmatic terminal user should identify what tasks you most commonly do in the command line and what can be automated using shell script. You should create your own collection of shell scripts and add them to your path so that they are easily accessible from any directory.