Basics of programming in the shell command shell. BASH: description of for, while, until loops and examples of use

6. Using continue and break in a for loop

Example (complete when i=6 and don't execute when i=3 and i=5): for i in (1..8); do if[ $i -eq 6 ]; then break; fi if[ $i -eq 3 ] || [ $i -eq 5 ]; then continue; fi echo $i done Execution result: $ $ for i in (1..8); do \ > if [ $i -eq 6 ]; then break; fi; \ > if [ $i -eq 3 ] || [ $i -eq 5 ]; then continue; fi; \ > echo $i; \ > done 1 2 4

• Tutorial

BASH Basics. Part 2.
I apologize for such a long delay between articles, but the session makes itself felt at the most inopportune moment :)
Thank you all for the comments, criticism and additions that were voiced in the comments to the last article.
This part, as promised, will be devoted to loops, mathematical operations and the use of external commands.
Let's begin.

Cycles. For-in loop.

Let's consider small example:

#!/bin/bash
for i in 0 1 2 3 4 #we will alternately assign values ​​from 0 to 4 inclusive to the variable $i
do
echo "Console number is $i" >> /dev/pts/$i #Write the line "Console number is $i" to the file /dev/pts/$i (virtual terminal file)
done #cycle finished
exit 0

Cycles. While loop.

Let's look at the following example of how the loop works:

#!/bin/bash
again=yes #assign the value "yes" to the variable again
while [ "$again" = "yes" ] #We will execute the loop until $again is equal to "yes"
do
echo "Please enter a name:"
read name
echo "The name you entered is $name"

Echo "Do you wish to continue?"
read again
done
echo "Bye-Bye"

ite@ite-desktop:~$ ./bash2_primer1.sh
Please enter a name:
ite
The name you entered is ite
Do you wish to continue?
yes
Please enter a name:
mihail
The name you entered is mihail
Do you wish to continue?
no
Bye-Bye

As you can see, the loop runs until we enter something other than “yes”. Between do and done you can describe any structures, operators, etc., all of them will be executed in a loop. But you should be careful with this loop, if you run any command in it without changing the expression variable, you can get caught in an endless loop.
Now about the truth condition. After the while, as in the if-then-else conditional statement, you can insert any expression or command that returns the return code, and the loop will be executed until the return code = 0! The "[" operator is analogous to the test command, which checks the truth of the condition that was passed to it.

Let's look at another example, I took it from the book Advanced Bash Scripting. I really liked it :), but I simplified it a little. In this example we will introduce another type of UNTIL-DO loops. This is almost a complete analogue of the WHILE-DO loop, only it is executed while some expression is false.
Here's an example:

#!/bin/bash
echo "Enter numerator: "
read dividend
echo "Enter denominator: "
read divisor

Dnd=$dividend #we will change the variables dividend and divisor,
#let's save their knowledge in other variables, because... they give us
#will be needed
dvs=$divisor
remainder=1

Until [ "$remainder" -eq 0 ]
do
let "remainder = dividend % divisor"
dividend=$divisor
divisor=$remainder
done

Echo "GCD of the numbers $dnd and $dvs = $dividend"

ite@ite-desktop:~$ ./bash2_primer3.sh
Enter the numerator:
100
Enter the denominator:
90
GCD of numbers 100 and 90 = 10

Mathematical operations

#!/bin/bash
echo "Enter a: "
read a
echo "Enter b: "
read b

Let "c = a + b" #addition
echo "a+b=$c"
let "c = a / b" #division
echo "a/b=$c"
let "c<<= 2" #сдвигает c на 2 разряда влево
echo "c after shift by 2 bits: $c"
let "c = a % b" # finds the remainder of a divided by b
echo "$a / $b. remainder: $c "

ite@ite-desktop:~$ ./bash2_primer2.sh
Enter a:
123
Enter b:
12
a+b= 135
a/b= 10
c after shift by 2 digits: 40
123 / 12. balance: 3

Working with external programs when writing shell scripts

Stream redirection.

./program_with_error 2> error_file

2. Conveyors.

ls -la | grep "hash" |sort > sortilg_list

Most often, Bash scripts are used to automate some routine operations in the console, hence sometimes there is a need to process the stdout of one command and transfer it to stdin to another command, while the result of executing one command must be processed in some way. In this section I will try to explain the basic principles of working with external teams inside the script. I think that I have given enough examples and now I can write only the main points.

1. Passing the output to a variable.

a = `echo "qwerty"`
echo $a

Result: qwerty

LIST=`find /svn/ -type d 2>/dev/null| awk "(FS="/") (print $4)"| sort|uniq | tr "\n" " "`
for ONE_OF_LIST in $LIST
do
svnadmin hotcopy /svn/$ONE_OF_LIST /svn/temp4backup/$ONE_OF_LIST
done

As you can see, everything is not difficult, just understand the principle and write a couple of your own scripts. In conclusion of the article, I would like to wish you good luck in learning BASH and Linux in general. Criticism, as usual, is welcome. The next article may be devoted to the use of programs such as sed, awk.

What is a shell and why is it needed?

The command shell in any unix-like systems, which includes GNU/Linux, is a regular program launched both in a text console (which is used less and less) and in a graphical environment - in the window of a terminal emulator, available on any Linux system .

Its task is simple and obvious: accept a line (or lines) of input, parse them and, based on the results of this analysis, react accordingly - execute a command, run a program, display a diagnostic message, etc.

Almost all Linux distributions For users, the default command shell is bash (Bourne Again SHell is another Bourne command shell; Steve Bourne is the author of the first command shell in Unix - sh). In fact, it has become an unofficial standard, and improvements to it functionality continues continuously. There are other command shells - tcsh (version of C-shell), ksh (Korn Shell), zsh, etc. – each has its own advantages and disadvantages, as well as its own groups of fans. However, bash is more familiar to a wide range of users with different levels of experience, which is why I chose it. It is also worth noting that no matter what capabilities the various shells have, they are all compatible with their ideological progenitor - the Bourn Shell (sh). In other words, a script written for sh will work correctly in any modern shell (the reverse is generally not true).

Benefits of the Command Line

The question may arise: why bother with the command line if there are convenient and beautiful graphical interfaces? There are many reasons for this. Firstly, not all operations are more convenient or faster to perform using GUI. Second, every program follows the fundamental principle of Unix systems: do a well-defined job and do it well. In other words, you always understand what happens when you run a particular utility (if something is not entirely clear, you should refer to the man manual). Thirdly, by mastering commands, trying their combinations and combinations of their parameters, the user studies the system, acquiring valuable practical experience. You get access to powerful tools such as pipelines that allow you to organize a chain of commands for processing data, I/O redirection tools, and you can also program directly from the command shell. Perhaps it’s worth dwelling on programming in more detail, especially since many system scripts in Linux (for example, scripts for launching system services) are written for the shell.

Command shell as a programming language

So, the command shell can be considered as a programming language and as software environment execution simultaneously. Of course, this language is not compiled, but interpreted. It allows the use of variables: system or own. The sequence of execution of program commands is changed using condition checking constructs and selecting the appropriate option: if-then-else and case. While, until, and for loops allow you to automate repetitive actions. It is possible to combine groups of commands into logical blocks. You can even write real functions that pass parameters to them. Thus, all the signs and characteristics of a full-fledged programming language are available. Let's try to get double benefit from this - along with learning the basics of programming, we will automate our daily work.

Hello, World! Simple backup system

About the need for regular Reserve copy Everyone knows the data, but users never have enough time for this boring operation. The solution is simple - organize automatic creation of backup copies. This will be our first shell programming task.

Any command script (script is a script, as command shell programs are called) begins with an identifier line, in which the command interpreter is explicitly specified, indicating the full path to it. The full path is a sequential listing of all directories, starting from the root, that must be entered to get to the target file, and, of course, the name of this file. Recording the full path is extremely important to uniquely identify each file in the file system hierarchy.

Four lines of comments follow. Once the shell encounters the "#" character, it treats all subsequent characters as comments and completely ignores them until the end of the current line. Therefore, you can start a comment not from the very beginning of the line, but accompany it with some command.

After the comments there is an empty line. It means nothing to the command shell, and no action is taken. In scripts, blank lines are usually inserted to make the code easier to read.

We finally got to the first “real” team. It allows you to change the directory (Change Directory), i.e. move from the current directory to another one passed to the command as an argument. In most cases, the target directory is specified explicitly, for example, cd /tmp or cd projects, but in our case the predefined system variable HOME is used - it contains the full path to the home directory current user, on behalf of which the command script is executed. This eliminates the need to make code changes every time we change users, because the command returns everyone to their personal directory. The dollar sign "$" in front of a variable name means that you need to extract the value contained in that variable and substitute it in place of its name on the command line. It should be especially noted that in the command language, letter case shells have important, i.e. HOME, Home and home are three different variables. By agreement, in letters uppercase The names of system variables are indicated: HOME, PATH, EDITOR, etc. This convention does not prevent users from creating their own variables with names from capital letters, but why complicate your life by violating generally accepted norms and rules? It is also not recommended to change the values ​​of system variables unless absolutely necessary. In general, we follow a simple rule: we use system variables for read-only purposes, and if we need our own, we write its name in lowercase letters.

Our first command could be written more briefly:

Here the "~" symbol also means the current user's home directory. Command line veterans put it even more succinctly:

The idea is that when the cd command is given no argument, it changes to the home directory.

Next up is the classic software design for checking conditions and making the appropriate decision. The general scheme is:

The last word of the construction (if in reverse order) acts as a closing parenthesis, i.e. boundaries of the list of commands executed when the condition is true. The presence of fi is mandatory, even if there is only one team on the list.

To check a condition, as a rule, the test command or its alternative form of notation in square brackets is used. In other words, records

absolutely equivalent. I prefer square brackets because they more clearly define the boundaries of the condition being tested. Both the right and left parentheses must be separated from the condition by spaces.

The criteria for checking the condition are determined by various flags. The test command recognizes a very large list of them. In our example, the -d flag is used, which allows us to check whether the name specified after the flag corresponds to an actual directory. The following flags are most often used when working with files:

F – whether a regular file with the given name exists;

R – whether the specified file has the right to read from it;

W – whether the specified file has the right to write to it;

X – whether the specified file has the right to execute it;

S – whether the specified file has a non-zero size.

In our case, the condition is preceded by Exclamation point, denoting the operation of logical negation, so the meaning of the condition being tested becomes completely opposite. Let's try to write down the meaning of these commands in ordinary Russian:

As you can see, everything turned out to be not so complicated. With a little practice, you can easily read and create similar designs yourself. The directory creation command is so obvious that no further explanation is required.

On the next line we create our own local variable, cur_date. In the vast majority of cases, variables are created by simply assigning a specific value, for example:

But in our example, a little trick is used. Please note that after the equal sign - the assignment symbol - the command is written in back quotes. This form of notation allows you to assign to a variable not the string itself, but the result of its execution. Here is the output of the date command, which returns the current date and time in a format specified by a list of parameters:

%Y – current year in full form, i.e. of four digits (for example, 2009);

%m – number of the current month (for example, 09 – for September);

%d – current day number;

%H – current hour in 24-hour format;

%M – current minute.

Thus, if you run the command

on the tenth of September 2009 at 22:45, the variable cur_date will be assigned the string value "200909102245". The purpose of this trick is to create a unique, non-repeating name for the archive file. If you intend to run several instances of the program within one minute, you can improve the uniqueness of the names by adding the current seconds. How? Study the date utility manual (man date) - there is nothing complicated about it.

Before we start creating an archive file, we need to determine which directories we will save in it. For greater flexibility, we can specify a set of directories to be archived by default, but provide the ability to replace this set with a list of directories passed as an argument to our command script. For this purpose, special command shell variables are used: $# – the number of parameters passed to the script and $* – all parameters passed, written in one line format.

Checking the condition “if the number of passed parameters is zero”, then execute the following command. Note that the then keyword can be written on the condition line, separated from the conditional expression by a semicolon.

The command to create an archive file and compress this file. The tar utility itself does not perform compression, but only collects everything specified files and directories into a single tar file. The first flag is intended for this - c (create). Compression performs external program– here it is gzip, called by the second flag - z. If you have the more efficient bzip2 compression program installed on your system, you can take advantage of it by modifying the command as follows:

The third flag f indicates that what follows is the name of the archive file, so it is always the last one in the list of flags. Note that when substituting, the variable name is enclosed in curly braces. This is done to explicitly highlight the variable on the line surrounding it, thereby eliminating many potential problems. Extensions archive file are not assigned automatically; you fill in everything you need yourself. I've specified projects and bin as the default directories to archive, but you can write down the names of your most valuable directories here.

The else keyword opens an alternative branch of execution. The commands of this block begin to work if the condition check returns the result “false” (in our example: “the number of parameters passed is non-zero,” i.e. the user specified directory names). In this case the command will look like this:

Here the default directories are replaced by a directory name string accepted externally. It is possible to accept and process each external parameter separately, but it is more convenient for us to pass the entire string.

At the end of the program, another check is performed. In Unix environments, all commands return a completion status code. If the command was successful, it returns code 0, otherwise the exit code will be non-zero. To check the success of the previous archiving command, we will use another special variable $?, which always contains the value of the completion code of the most recent command. If in the variable $? contains 0, i.e. The backup file was successfully created, then we move it to the archive directory:

and display the corresponding message:

If the check shows that the completion code of the archiving operation is not zero, then an error message is displayed:

This completes our command script.

To check the operation of our program, you need to save the above source in a file called bckp, for example, and then make it executable for convenience:

and run:

to create a backup of the default directories, and

to create a backup copy of the listed directories (specify the names of the directories that actually exist on your system, otherwise you will receive an error message).

You can place the bckp file in one of the directories specified in the system PATH variable. The most preferred locations are /usr/local/bin or $HOME/bin if you have them. After this you can run bckp as a system command.

How to automate scheduled backup operations

A few words about backup automation. For this purpose, the system serves cron scheduler, which reads work instructions from a special crontab file. To define such instructions, you need to create and edit your crontab file using the command:

Instructions are written in a strictly defined format (fields are separated by spaces):

One option for scheduling backup operations might look like this:

This means that the backup script (you must provide the full path to this file) will run at 23:30 on the 10th, 20th and 30th of each month, regardless of the day of the week. (Asterisks indicate the entire permissible range of values, in this case: every month - in the 4th field, any day of the week - in the 5th field)

If you prefer to summarize your results by week, and your system runs 24/7, then it makes sense to schedule backups during off-peak hours:

Here backups will be created at 5:00 on Wednesdays and Fridays in each month (asterisk in the 4th field), regardless of the date (asterisk in the 3rd field).

You can read about all the intricacies of scheduling in man manual 5 crontab.

Results and conclusions

The backup script discussed in this article has modest functional properties. But that was not his point the main task, but so that the reader understands what can be done on the command line, and not only copies and executes the proposed command file, but becomes interested in expanding its functions and begins to explore the immense possibilities provided by command shells. And if someone, after reading this article, tries to improve the code given here, or writes their own version, or implements their own independent idea, then I will consider that the main goal has been achieved.

Resources for download

static.content.url=http://www.site/developerworks/js/artrating/

ArticleID=458335

ArticleTitle=Shell Programming Basics

The shell programming language has several constructs that will give flexibility to your programs:

• Commentaries will allow you to describe the functions of the program;
• "here document" allows you to include lines in the program's shell that will be redirected as input to some of the program's shell commands;
• The exit command allows you to terminate the program at the desired point and use return codes;
• The for and while loop constructs allow you to repeat a group of commands in a loop;
• conditional commands if and case execute a group of commands if some condition is met;
• The break command allows you to unconditionally exit a loop.

9.3.1. Comments

To place comments in the program, use the # sign. If a # sign appears after a command, the command itself is executed and the comment is ignored. Comment line format:

#comment

9.3.2. "Here document"

"Here document" allows you to place lines in a shell program that are redirected as command input in that program. This is one way to provide input for a command in a shell program without using separate file. The entry consists of a redirection character<< и разделителя, который указывает начало и конец строк ввода. В качестве разделителя может использоваться один символ или строка символов. Чаще всего это знак!.

The command format is as follows:

Command<...input lines... delimiter

9.3.3. Using ed in a shell program

"Here document" suggests a way to use ed in a shell program. Let's say you want to create shell program, which will call the ed editor, make global changes to the file, write the changes to the file, and then exit ed. The following screen shows the contents of the ch.text program, which performs these tasks:

$ cat ch.text echo Type in the filename read file1 echo Type in the exact text to be changed. read old_text echo Type in the exact new text to replace the above. read new_text ed - $file1<

Note the - (minus) sign in the ed command. This option prevents the character counter from being printed on the screen. Also note the format of the ed command for global replacement:

G/$old_text/s//$new_text/g

The program uses 3 variables: file1, old_text, new_text. When run, this program uses the read command to obtain the values ​​of these variables. These variables contain the following information:
file - name of the file that will be edited;
old_text - text that will be changed;
new_text - new text.

Variables are introduced into the program, here document redirects the global replace command, the write command, and the end command to the ed command. Run the ch.text program. Get the following screen:

$ch.text Type in the filename memo Type in the exact text to be changed. Dear John: Type in the exact new text to replace the above. To what it may concern: $ cat memo To what it may concern: $

9.3.4. Completion Codes

Most shell commands return codes that indicate whether the command completed successfully. If the return value is 0 (zero), then the command completed successfully. Return codes are not printed automatically, but can be obtained as the value of the special shell $? parameter.

9.3.4.1. Checking completion codes

After running a command interactively, you can see the exit code when you type:

Echo$? Consider the following example: $ cat hi This is file hi. $echo$? 0 $ cat hello cat: cannot open hello $ echo $? $2

In the first case, the file hi exists in your directory and you have read permission. Using the cat command you can print the contents of a file. The result of the cat command is the return code 0, which you will get by specifying the $? parameter. In the second case, the file either does not exist or you do not have read permission. The cat command prints a diagnostic message and returns code 2.

The shell program exits normally when the last command in the file is executed. However, you can use the exit command to terminate the program. More importantly, you can use the exit command to obtain shell program return codes.

9.3.5. Cycles

The for and while loop statements allow you to execute a command or sequence of commands multiple times.

9.3.5.1. for statement

The for statement executes a sequence of commands for each element of the list. It has the format:

For variable in a_list_of_values do command_1 command_2 . . . last command done

For each iteration of the loop, the next element of the list is assigned to the variable given in the for statement. This variable can be referenced anywhere in commands within a do statement. When constructing each section of commands, you need to make sure that for each do there is a corresponding done at the end of the loop.

The variable can have any name. For example, if your variable is named var, then a reference to $var in the command list will make the value available. If the in operator is omitted, then the value for var will be the set of arguments given in the command and available in the special parameter $*. The list of commands between the do and done keywords will be executed for each value.

When the commands are executed for last element list, the program will execute the line below done.

9.3.5.2. while statement

The while loop operator uses 2 groups of commands. It will execute the sequence of commands in the second group (the do ... done list) until the last command in the first group (the while list) returns true, meaning that the expression after the do can be executed.

General format while loop operator:

While command_1 . . . last command do command_1 . . . last command done

For example, the enter.name program uses a while loop to enter a list of names into a file. The program consists of the following command lines:

$ cat enter.name while read x do echo $x>>xfile done $

After making some additions, we get the following program:

$ cat enter.name echo Please type in each person"s name and than a echo Please end the list of names with a<^d>while read x do echo $x>>xfile done echo xfile contains the following names: cat xfile $

Note that after the loop completes, the program executes the commands below done.

The first two echo commands use special characters, so you must use quotes to escape the special meaning. The following screen shows the output of enter.name:

$enter.name Please type in each person"s name and than a Please end the list of names with a<^d>Mary Lou Janice <^d>xfile contains the following names: Mary Lou Janice $

After the loop completes, the program will print out all the names contained in the xfile.

9.3.6. Using /dev/null

The file system has a file /dev/null where you can store unwanted output. For example, if you simply enter the who command, the system will answer who is working on the system. If you redirect the output of this command to /dev/null:

Who > /dev/null then you will not get a response.

9.3.7. Conditional statements

The if command tells the shell program to execute the sequence of commands after then if the last command in the if statement's list of commands completed successfully. If constructs end with the fi keyword.

The general format of the if construct is:

If command_1 . . . last command then command_1 . . . last command fi

For example, the search shell program demonstrates the use of the if ... then construct. The search program uses the grep command to search for a word in a file. If grep is successful, the program displays the word found. The screen will look like this:

$ cat search echo Type in the word and the file name. read word file if grep $word $file then echo $word is in $file fi $

This program displays the output of the grep command. If you want to store the system's response to the grep command in your program, use the /dev/null file, changing the if command line to the following:

If grep $word $file > /dev/null

Now run the search command. It will only respond with the message specified after the echo command.

The if ... then ... else construct can execute an alternative set of commands after the else if the if sequence is false. The format of this construct is as follows:

If command_1 . . . last command .linthen command_1 . . . last command else command_1 . . . last command fi

With this construct, you can improve the search program so that it will tell you both the word found and the word not found. In this case, the search program will look like this:

$ cat search echo Type in the word and the file name. read word file if grep $word $file > /dev/null then echo $word is in $file else echo $word is NOT in $file fi $

test command

The test command is used to organize a loop. It tests certain conditions for truth and is useful for organizing conditional structures. If the condition is true, the loop will continue. If the condition is false, the loop will end and the next command will be executed. Some examples of using the test command: test -r file true if the file exists and is readable; test -w file true if the file exists and is writable; test -x file true if the file exists and is executable; test -s file true if the file exists and has at least one character; test var1 -eq var2 true if var1 is equal to var2; test var1 -ne var2 true if var1 is not equal to var2.

Example. Let's create a shell program that moves all executable files from the current directory to your bin directory. To do this, we will use the test -x command to select executable files. The mv.file program will look like this:

$ cat mv.file echo type in the directory path read path for file do if test -x $file then mv $file $path/$file fi done $

The case ... esac construct allows you to select one of several patterns and then execute a list of commands for that pattern. The template expression must begin with the in keyword and a right parenthesis must be placed after last character each template. The sequence of commands for each pattern ends with two characters;;. The case construct must be terminated with the esac keyword.

The general format of the case construct is:

Case word in pattern1) command line 1 . . . last command line ;;pattern2) command line 1 . . last command line ;;pattern3) command line 1 . . last command line ;; *)command line 1 . . last command line ;;esac

The case construct tries to find a word with the pattern pattern in the first pattern section. If the search is successful, the program executes command lines after the first pattern before the corresponding signs;;.

If the first template is not found, then the transition to the second template is carried out. If any pattern is found, the program does not consider the remaining patterns, but moves on to the command following esac. The * is used as a pattern to search for any word and thus gives you a set of commands that will be executed if no other pattern is found. Therefore, the asterisk (*) pattern is placed as the last pattern in the case construct so that the other patterns are checked first. This will help you detect incorrect and unexpected input.

Templates can use metacharacters *, ?, . This provides program flexibility.

Let's look at an example. The set.term program sets the TERM variable according to the type of terminal you are using. The following command line is used:

TERM=terminal_name

The * template is the last one in the list of templates. It issues a warning message that there is no matching pattern for the specified terminal type and allows you to complete the case construct.

$ cat set.term echo If you have a TTY 4420 type in 4420 echo If you have a TTY 5410 type in 5410 echo If you have a TTY 5420 type in 5420 read term case term in 4420) TERM-T4 ;; 5410) TERM-T5 ;; 5420) TERM-T7 ;; *) echo not a correcr terminal type ;; esac export TERM echo end of programm $

9.3.8. Unconditional transfer of control

The break command unconditionally stops the execution of any loop in which it is encountered and passes control to the command following keywords done, fi or esac.

In the previous example set.term program, you could use the break command instead of echo to exit the program, as in the following example:

$ cat set.term echo If you have a TTY 4420 type in 4420 echo If you have a TTY 5410 type in 5410 echo If you have a TTY 5420 type in 5420 read term case term in 4420) TERM-T4 ;; 5410) TERM-T5 ;; 5420) TERM-T7 ;; *) break ;; esac export TERM echo end of programm $

The continue command will cause the program to immediately move to the next iteration of the while or for loop without executing the remaining commands in the loop.