Linux script writing BASICS (3)

3) Process Control

1. If

If the expression "if" is true, the part after then is executed:

If...; then

....

Elif...; then

....

Else

....

Fi

In most cases, you can use test commands to test the conditions. For example, you can compare strings, determine whether a file exists, and whether the file is readable...

"[]" Is usually used to represent a conditional test. Note that spaces are important. Make sure that the square brackets have spaces.

[-F "somefile"]: determines whether it is a file.

[-X "/bin/ls"]: determines whether/bin/ls exists and has the executable permission.

[-N "$ Var"]: determines whether the $ var variable has a value.

["$ A" = "$ B"]: determines whether $ A and $ B are equal.

Run man test to view all types of test expressions that can be compared and judged.

Directly execute the following script:

#! /Bin/sh

If ["$ shell" = "/bin/bash"]; then

Echo "your login shell is the bash (Bourne again shell )"

Else

Echo "your login shell is not bash but $ shell"

Fi

The variable $ shell contains the name of the logon shell. We compared it with/bin/bash.

Shortcut Operators

If you are familiar with the C language, you may like the following expressions:

[-F "/etc/shadow"] & Echo "this computer uses shadow passwors"

Here & is a shortcut operator. If the expression on the left is true, execute the Statement on the right. You can also think of it as a logical operation. In the above example, if the/etc/shadow file exists, print "this computer uses shadow passwors ". Similarly, operations (|) are also available in shell programming. Here is an example:

#! /Bin/sh

Mailfolder =/var/spool/mail/James

[-R "$ mailfolder"] ''{echo" can not read $ mailfolder "; Exit 1 ;}

Echo "$ mailfolder has mail from :"

Grep "^ From" $ mailfolder

The script first checks whether mailfolder is readable. If it is readable, the "from" line in the file is printed. If it is not readable or the operation takes effect, print the error message and exit the script. There is a problem here, that is, we must have two commands:

-Print the error message.

-Exit the program.

We use curly braces to put the two commands together as one command in the form of an anonymous function. General functions will be mentioned below. We can use the if expression to do anything without the sum or operator, but it is much more convenient to use the sum or operator.

2. Case

Case: The expression can be used to match a given string, not a number.

Case... in

...) Do something here ;;

Esac

Let's look at an example. The file command can identify the file type of a given file, for example:

File lf.gz

This will return:

Lf.gz: gzip compressed data, deflated, original filename,

Last modified: Mon Aug 27 23:09:18 2001, OS: Unix

We use this to write a script named smartzip, which can automatically decompress Bzip2, Gzip, and zip compressed files:

#! /Bin/sh

FTYPE = 'file "$1 "'

Case "$ FTYPE" in

"$1: ZIP Archive "*)

Unzip "$1 ";;

"$1: gzip COMPRESSED "*)

Gunzip "$1 ";;

"$1: Bzip2 COMPRESSED "*)

Bunzip2 "$1 ";;

*) Echo "File $1 can not be uncompressed with smartzip ";;

Esac

You may notice that we use a special variable $1 here. The variable contains the first parameter value passed to the program.

That is, when we run:

Smartzip articles.zip

$1 is the string articles.zip

3. selsect

The Select expression is a bash extension application, especially for interactive use. You can select from a group of different values.

Select VaR in...; do

Break

Done

... Now $ VaR can be used ....

The following is an example:

#! /Bin/sh

Echo "What is your favorite OS? "

Select VaR in "Linux" "GNU Hurd" "Free BSD" "other"; do

Break

Done

Echo "you have selected $ Var"

The following is the result of running the script:

What is your favorite OS?

1) Linux

2) GNU Hurd

3) Free BSD

4) Other

#? 1

You have selected Linux

4. Loop

Loop expression:

While...; do

....

Done

While-loop will run until the expression test is true. Will run while the expression that we test for is true. The keyword "break" is used to jump out of the loop. The keyword "continue" is used to directly jump to the next loop without executing the remaining part.

The for-loop expression is used to view a string list (strings are separated by spaces) and then assigned to a variable:

For VaR in...; do

....

Done

In the following example, ABC is printed to the screen:

#! /Bin/sh

For var in a B C; do

Echo "Var is $ Var"

Done

The following is a more useful script showrpm. Its function is to print statistics of some RPM packages:

#! /Bin/sh

# List a Content summary of a number of RPM packages

# Usage: showrpm rpmfile1 rpmfile2...

# Example: showrpm/CDROM/RedHat/RPMS/*. rpm

For rpmpackage in $ *; do

If [-R "$ rpmpackage"]; then

Echo "=====================$ rpmpackage ===================="

Rpm-qi-p $ rpmpackage

Else

Echo "error: cannot read file $ rpmpackage"

Fi

Done

The second special variable $ * is displayed, which contains all input command line parameter values.

If you run showrpm OpenSSH. RPM w3m. RPM webgrep. rpm

$ * Contains three strings: OpenSSH. rpm, w3m. rpm, and webgrep. rpm.

5. quotation marks

Before passing any parameters to a program, the program extends the wildcards and variables. Here, the extension means that the program will replace the wildcard (for example, *) with the appropriate file name, and replace the variable with the variable value. To prevent such replacement, you can use quotation marks: Let's take a look at an example. Suppose there are some files in the current directory, two JPG files, mail.jpg and tux.jpg.

Quotation marks (single quotation marks and double quotation marks) will prevent such wildcard extension:

#! /Bin/sh

Echo "*. jpg"

Echo '*. jpg'

This will print "*. jpg" twice.

Single quotes can prevent extension of any variable, which is stricter.

Double quotation marks can prevent wildcard extension but allow variable extension.

#! /Bin/sh

Echo $ Shell

Echo "$ shell"

Echo '$ shell'

The running result is:

/Bin/bash

/Bin/bash

$ Shell

Finally, there is also a method to prevent this extension, that is, to use the Escape Character -- reverse oblique ROD:

Echo/*. jpg

Echo/$ Shell

This will output:

*. Jpg

$ Shell

6. Here documents

To pass several lines of text to a command, here documents is a good method. It is very useful to write a helpful text for each script. If we use the here statements, we do not need to use the echo function to output a row. A "Here document" starts with <, followed by a string, which must also appear at the end of the here document. The following is an example. In this example, we rename multiple files and print the help using here documents:

#! /Bin/sh

# We have less than 3 arguments. Print the help text:

If [$ #-lt 3]; then

Cat <

Ren -- renames a number of files using sed Regular Expressions

Usage: Ren 'regexp' 'replace 'files...

Example: rename all *. HTM files in *. html:

Ren 'htm $ ''html' *. htm

Help

Exit 0

Fi

Old = "$1"

New = "$2"

# The shift command removes one argument from the list

# Command line arguments.

Shift

Shift

# $ * Contains now all the files:

For file in $ *; do

If [-F "$ file"]; then

Newfile = 'echo "$ file" | sed "s/$ {old}/$ {New}/g "'

If [-F "$ newfile"]; then

Echo "error: $ newfile exists already"

Else

Echo "Renaming $ file to $ newfile ..."

Mv "$ file" "$ newfile"

Fi

Fi

Done

This is a complex example. Let's discuss it in detail. The first if expression determines whether the number of input command line parameters is smaller than 3 (special variable $ # indicates the number of parameters included ). If the number of input parameters is less than three, the help text is passed to the cat command and then printed on the screen by the cat command. Print the help text and exit the program. If the input parameter is equal to or greater than three, we assign the first parameter to the variable old, and the second parameter to the variable new. Next, we use the shift command to delete the first and second parameters from the parameter list, so that the original third parameter becomes the first parameter in the parameter list $. Then we start the loop. The command line parameter list is assigned to the variable $ file one by one. Then we determine whether the file exists. If yes, we use the SED command to search for and replace the file to generate a new file name. Then, assign the command result in the backslash to newfile. In this way, we can achieve our goal: Get the old and new file names. Use the MV command to rename the file.