How to Create a First Shell Script
Shell scripts are short programs that are written in a shell programming language and interpreted by a shell process. They are extremely useful for automating tasks on Linux and other Unix-like operating systems.
A shell is a program that provides the traditional, text-only user interface for Unix-like operating systems. Its primary function is to read commands (i.e., instructions) that are typed into a console (i.e., an all-text display mode) or terminal window (i.e., all-text mode window) and then execute (i.e., run) them. The default shell on Linux is the very commonly used and highly versatile bash.
A programming language is a precise, artificial language that is used to write computer programs, which are sets of instructions that can be automatically translated (i.e., interpreted or compiled) into a form (i.e., machine language) that is directly understandable by a computer’s central processing unit (CPU).
A feature of bash and other shells used on Unix-like operating systems is that each contains a built-in programming language, referred to as a shell programming language or shell scripting language, which is used to create shell scripts. Among the advantages of using shell scripts are that they can be very easy to create and that a large number are already available in books and on the Internet for use with or without modification for a wide variety of tasks. Shell scripts are also employed extensively in the default installations of Unix-like operating systems.
A First Script
The following example, although extremely simple, provides a useful introduction to creating and using shell scripts. The script clears the monitor screen of all previous lines and then writes the text Good morning, world. on it.
All that is necessary to create this script is to open a text editor (but not a word processor), such as gedit or vi, and type the following three lines exactly as shown on a new, blank page:
Alternatively, the above code could be copied from this page and pasted to a blank page opened by the text editor page using the standard keyboard or mouse copy and paste functions.
After saving this plain text file, with a file name such as morning (or anything else desired), the script is complete and almost ready to run. Scripts are typically run by typing a dot, a forward slash and the file name (with no spaces in between) and then pressing the ENTER key. Thus, for example, if the above script were saved with the name morning, an attempt could be made to execute it by issuing the following command:
However, the script probably will not run, in which case an error message will appear on the screen such as bash: ./morning: Permission denied. This is because the permissions for the file first have to be set to executable. (By default, the permissions for new files are set to read and write only.) The problem can easily be solved by using the chmod command with its 755 option (which will allow the file creator to read, write and execute the file) while in the same directory as that in which the file is located as follows:
Now the script is ready to run by typing the following, again while in the same directory, and then pressing the ENTER key:
How It Works
The first of the three lines tells the operating system what shell to use to interpret the script and the location (i.e., absolute pathname) of the shell. The shell is bash, which is located in the /bin directory (as are all shells); thus the line contains /bin/bash. This instruction is always preceded by a pound sign and an exclamation mark in order to inform the operating system that it is providing the name and location of the shell (or other scripting language).
The second line tells the shell to issue the clear command. This is a very simple command that removes all previous commands and output from the console or terminal window in which the command was issued.
The third line tells the shell to write the phrase Good morning, world. on the screen. It uses the echo command, which instructs the shell to repeat whatever follows it. (The quotation marks are not necessary in this case; however, it is good programming practice to use them, and they can make a big difference in more advanced scripts.) In slightly more technical terms, Good morning, world. is an argument (i.e., input data) that is passed to the echo command.
As is the case with other commands used in shell scripts, clear and echo can also be used independently of scripts. Thus, for example, typing clear on the screen and pressing the ENTER key would remove all previous commands and output and just leave a command prompt for entering the next command.
It Doesn’t Work!
If the phrase Good morning, world. does not appear at the top of the screen, there are several possible reasons: (1) an error was made in copying the code (such as omitting the word echo), (2) the name used in the command was not exactly the same as that of the file (e.g., there is an extra space or a minor difference in spelling or capitalization), (3) the period and/or forward slash were omitted (or reversed) in the command, (4) a space was inserted after the period or slash, (5) the file is not a plain text file (typically because a word processor was used to create it instead of a text editor), (6) the command was not issued in the same directory as that in which the file is located and (7) the permissions were not changed to execute for the owner (i.e., creator) of the file.
It is important to avoid practicing writing and executing scripts as the root (i.e., administrative) user. An improperly written script could damage the operating system, and, in a worst case scenario, it could result in the loss of valuable data and make it necessary to reinstall the entire operating system. For this and other reasons, if an ordinary user account does not yet exist on the computer, one should immediately be created (which can be easily accomplished with a command such as adduser).
Experiments
There are a number of simple, and instructive, experiments that a curious user could do with the above example before moving on to more complex examples. They consist of revising the code as suggested below, saving the revisions (using either the same file name or a different file name), and then executing them as explained above.
(1) One is to try changing some of the wording (for example, changing the third line to echo «Good evening, folks.»).
(2) Another is to add one or more additional lines to be written to the screen, each beginning with the word echo followed by at least one horizontal space.
(3) A third is to leave a blank line between two echo lines. (It will be seen that this will not affect the result; however, a blank line can be created by just typing echo on it and nothing else.)
(4) A fourth is to insert some blank horizontal spaces. (Notice that the result will be different depending on whether the blank spaces are inserted before or after the first quotation marks. This tells something about the role of quotation marks in shell scripts.)
(5) A fifth is to execute the file from a different directory from that in which it is located. This requires adding the path of the executable script to the beginning of the command name when it is issued (e.g., ./test/morning if the file has been moved to a subdirectory named test).
(6) Another experiment would be to add some other command to the script file, such as ps (which shows the processes currently on the system), pwd (which shows the current directory), uname (which provides basic information about a system’s software and hardware) or df (which shows disk space usage). (Notice that these and other commands can be used in the script with any appropriate options and/or arguments.)
Created December 21, 2005.
Copyright © 2005 The Linux Information Project. All Rights Reserved.
Источник
The Beginner’s Guide to Scripting on Linux
Have you ever wanted to learn “scripting” in Linux? Making them is easier than you might think. Sometimes scripts (often referred to as shell or bash scripts) are real programs with complicated code inside. Other times they’re just a long list of tasks that users put together to make getting things done under Linux faster and easier.
In this article we’ve decided to make a quick guide explaining how to make a basic shell script under Linux. This tutorial won’t turn you into a Bash or scripting expert. Instead, it will show you how easy it is to get started (and the best practices) scripting in Linux.
Why would you make a script?
Making scripts in Linux is a very useful skill to have. Even if you don’t fully understand Bash, you can use your limited knowledge of the terminal to automate and “mass-accomplish” some tasks, or simply to open multiple applications simultaneously.
For example: maybe you just built Arch Linux from scratch. The operating system is installed, along with all of the basic packages, and it can boot to the terminal when the operating system starts up. Arch Linux takes time to set up, so the process isn’t completed.
It is at this point where the user could write a Bash script and accomplish everything at once. None of this is programming, or advanced for that matter. However, given the fact that the user understands enough about the way Arch Linux works, they’d be able to automate almost the entire post-setup process (desktop environment, drivers, user setup, etc.).
The only limit to your bash script is your own Linux and Bash knowledge! Making them is easier than you might think.
Getting started – Shebangs
When writing code, things need to be specified and resources loaded. When scripting with the shell, some things need to be specified as well. In bash scripting this is known as a “shebang.” The shebangs used in scripts tells the script what interpreter it should execute under. This could be Bash or any other scripts available in your system. Do note that different languages have their own shebangs.
For example: When writing a Python script, the shebang would be #!/usr/bin/python , etc.
Bash has many different shebangs that can be used, but most users have probably only seen the #!/bin/bash one. As a general rule, use #!/bin/bash when writing a simple script and don’t plan on taking it off of Linux. All modern Linux distributions are on the same version of bash, and the bash shell is usually located in the same place.
Another shebang that proves itself useful is the #!/usr/bin/env bash shebang. This one is designed for portability and should be used if the script is designed to run on other Unix-like operating systems (BSDs, macOS, etc.).
Best Practices
Writing scripts in Bash can be a complicated process if the writer makes it that way. More often than not, scripts are just a collection of different operations. Moving a file, downloading something, installing programs, and that sort of thing.
- Keep in mind that Bash is a language that is designed to manipulate files and processes on the system. If Bash meets your needs, that is good. However, do understand that for advanced programming, Bash really isn’t the right choice, and it’d be best to move onto something like Python.
- Make your scripts “SH” compatible and in the “.sh” format if the plan is to use scripts on more than just a Linux platform. Though other UNIX-like operating systems may have “bash-like” shells, some don’t have bash at all, and it’s good to be prepared for this.
- Learn the Bash shell and how it works. It’ll help you write your scripts better.
- Always use a shebang and more importantly: use the right one. It can mean the difference between a good script and a terrible one that doesn’t work right.
- Always comment out every operation. In six months you might come back to your script and wonder what everything means, so it is crucial that your script is documented well and easy to understand (for you and anyone else who might see it).
- Make your code readable. Even if your script isn’t anything complex, it should still make sense, and making them is easier than you might think.
- Test your script for errors before giving it out to others. Don’t make others bug test for you. Ideally, scripts should work before you send them out for people to use.
Making a script
To start scripting, all you need is a text editor. Any simple text editor will do – it doesn’t have to be a complicated or comprehensive one. For this example we’ll make a simple Ubuntu update script using Gedit.
This first part of the script is the shebang, like mentioned before. This allows the script to tell the interpreter what it should use to understand the code.
Next, let’s write a comment. This will allow anyone who uses the script to understand what the code is meant to do. Comments can be added to a script by placing a “#” symbol. Anything after it won’t be picked up by the script.
Now it is time to add the code to the script. In this case we’re working on making a bash script that will run Ubuntu’s two update commands in succession. Start off with the update software sources command.
The second part of the script is the apt upgrade command. This command allows the previously checked updates to be installed. Add a -y to the end so that the script won’t need any user interaction. This will allow the command to update by itself.
Save the script with a “.sh” extension. For example, “myscript.sh.”
To run the script, open a terminal and type:
This will mark the newly created script as executable. Doing this to scripts isn’t always required, as for the most part Bash will run it anyways. Regardless, this a good practice when scripting.
To execute the newly created script, run the following command:
File Extensions
There isn’t a difference in file extensions for scripts. Naming a file with the “.sh” file extension does little to affect the way the “program” runs. A Bash script will still run with no file extension – blank text files and everything in between as long as the right commands and arguments are present.
Even though the Bash shell ignores file extensions, that doesn’t mean the script writer should. Some desktop environments that allow for setting shell scripts to run at startup depend on the script to have the correct “.sh” file extension. This also helps for organization purposes, too.
When it comes down to it, most shell scripts are saved as “.sh” files for portability. The “sh” doesn’t have anything to do with Bash itself, and the script can run with any compatible shell.
Alternatively, scripts can be saved as .bash, .ksh (Unix korn shell), etc. These file extensions are inferior and really limit the usefulness of a script. This is due to the fact that they are designed only for the shells that use those extensions.
Code resources
For those looking for useful Bash scripts, check out the Bash User Repository on Reddit. It is a collection of neat and useful scripts that are free to use and modify!
Additionally, those looking to learn the advanced nature of Bash and programming with the shell should check out Freecode. The website has an entire lesson guide that teaches everything there is to know about advanced Bash scripting.
Conclusion
Though scripting with Bash on Linux isn’t a unique feature (Macs have bash too), it tends to help Linux users out more overall. Considering so much of Linux can be accomplished under the terminal, learning how to manipulate the shell is very useful.
What Bash scripts do you use under Linux to make your life easier? Tell us below!
Derrik Diener is a freelance technology blogger.
Источник
