Basic Linux script writing knowledge

1. Linux script compiling Basics

1.1 Basic syntax Introduction

Start with 1.1.1

The program must start with the following line (the first line of the file must be placed ):
#! /Bin/sh
Symbol #! The parameter used to tell the system that the program is used to execute the file. In this example, we use/bin/sh to execute the program.
When editing a script, you must make it executable if you want to execute it.
To make the script executable:
Compile chmod + x filename to run it with./filename.

1.1.2 notes

During shell programming, a sentence starting with # represents a comment until the end of this line. We sincerely recommend that you use annotations in your program.
If you have used annotations, you can understand the functions of the script in a short time even if the script is not used for a long time.
And working principles.

1.1.3 Variables

You must use variables in other programming languages. In shell programming, all variables are composed of strings, and you do not need
. To assign a value to a variable, you can write as follows:
#! /Bin/sh
# Assign values to variables:
A = "hello world"
# Print the content of variable:
Echo "A is :"
Echo $
Sometimes the variable name is easily confused with other words, such:
Num = 2
Echo "this is the $ numnd"
This does not print "this is the 2nd", but only prints "this is the", because shell will search for the value of the variable numnd,
But this variable has no value. We can use curly braces to tell shell that we want to print the num variable:
Num = 2
Echo "this is the $ {num} nd"
This will print: this is the 2nd

1.1.4 Environment Variables

Variables processed by the export keyword are called environment variables. We will not discuss the environment variables, because normally we only log on
Use environment variables in the script.

1.1.5 Shell command and Process Control

Three types of commands can be used in shell scripts:

1) Unix command:
Although any unix command can be used in shell scripts, some more common commands are used. These commands are usually used
For file and text operations.
Common command syntax and functions
Echo "some text": print the text on the screen
Ls: file list
Wc-l filewc-w filewc-c file: calculate the number of file lines. Calculate the number of words in the file. Calculate the number of characters in the file.
Cp sourcefile destfile: file copy
Mv oldname newname: rename a file or move a file
Rm file: delete an object
Grep 'pattern' file: searches for strings in a file, for example, grep 'searchstring' file.txt.
Cut-B colnum file: specify the content range of the file to be displayed, and output them to the standard output device, such as: Output
Cut-b5-9 file.txt, which contains 5th to 9th characters per line, must not be confused with cat commands,
These are two completely different commands.
Cat file.txt: output file content to the standard output device (screen)
File somefile: get the file type
Read var: prompt the user to input and assign the input value to the variable.
Sort file.txt: sorts the rows in the file.txt file.
Uniq: Delete the columns in a text file, for example, sort file.txt | uniq
Expr: perform mathematical operations Example: add 2 and 3 expr 2 "+" 3
Find: search for a file. For example, search for find.-name filename-print based on the file name.
Tee: outputs data to the standard output device (screen) and files such as: somecommand | tee outfile
Basename file: returns a file name that does not contain a path, for example, basename/bin/tux.
Dirname file: the path of the returned file. For example, dirname/bin/tux will return/bin.
Head file: prints the first few lines of a text file.
Tail file: number of rows at the end of a text file
Sed: Sed is a basic search replacement program. You can read text from standard input (such as command pipeline) and
The result is output to the standard output (screen ). This command uses a regular expression (see references) for search.
Do not confuse with wildcards in shell. For example, replace linuxfocus
LinuxFocus: cat text. file | sed's/linuxfocus/LinuxFocus/'> newtext. file
Awk: awk is used to extract fields from text files. By default, the field delimiter is a space. You can use-F to specify other separators.
Cat file.txt | awk-F, '{print $1 "," $3}', which is used here as a field delimiter and printed at the same time
The first and third fields. If the file contains the following content: Adam Bor, 34, IndiaKerry Miller, 22, USA
Command output result: Adam Bor, IndiaKerry Miller, USA

2) concept: pipelines, redirection, and backtick

These are not system commands, but they are really important.
The pipeline (|) uses the output of a command as the input of another command.
Grep "hello" file.txt | wc-l
Search for a row containing "hello" in file.txt and calculate the number of rows.
Here, the grep command output serves as the wc command input. Of course, you can use multiple commands.
Redirection: output the command result to a file instead of a standard output (screen ).
> Write the file and overwrite the old file
> Add it to the end of the file to retain the content of the old file.
Backlash
You can use a backslash to output a command as a command line parameter of another command.
Command:
Find.-mtime-1-type f-print
Used to search for files modified in the past 24 hours (-mtime-2 indicates the past 48 hours. If you
You can use the following script to pack all the searched files:
#! /Bin/sh
# The ticks are backticks (') not normal quotes ('):
Tar-zcvf lastmod.tar.gz 'Find.-mtime-1-type f-print'
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 and determine files.
Whether it exists and whether it 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 preceding example, if the/etc/shadow file exists
Print "This computer uses shadow passwors ". Similarly, the operation (|) is also used in shell programming.
Available. 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 not
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:

Copy codeThe Code is as follows :#! /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:Copy codeThe Code is as follows :#! /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 so-called extension means that the program will put the wildcard
(For example, *) Replace the variable with the variable value with the appropriate file name. You can use
Quotation marks: Let's look at an example. Suppose there are some files in the current directory, two jpg files, mail.jpg and tux.jpg.
1.2 compile SHELL scripts
# Ch #! /Bin/sh mod + x filename
Cho *. jpg is slow. Why ?. /Filename to execute your script.
This will print the result of "mail.jpg 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 are stricter. It can prevent any variable extension. 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
When you want to pass several lines of text to a command, here documents)
A good method. It is very useful to write a helpful text for each script. If we have the here documents
You do not need to use the echo function to output a row. A "Here document" uses shift by 2

Copy codeThe Code is as follows: --) shift; break; # end of options
-*) Echo "error: no such option $1.-h for help"; exit 1 ;;
*) Break ;;
Esac
Done
Echo "opt_f is $ opt_f"
Echo "opt_l is $ opt_l"
Echo "first arg is $1"
Echo "2nd arg is $2"
You can run the script as follows:
Extends parser-l hello-f ---somefile1 somefile2
The returned result is:
Opt_f is 1
Opt_l is hello
First arg is-somefile1
2nd arg is somefile2

How does this script work? The script first loops through all input command line parameters.
Compare with the case expression. If the expression matches, set a variable and remove this parameter. According to the Conventions of unix systems,
First, enter a parameter that contains the minus sign.
Part 1 instances
Now let's discuss the general steps for writing a script. Any excellent script should have help and input parameters. And write a pseudo script (framework. sh) that contains the framework structure required by most scripts, which is a very good idea. At this time, when writing a new script, we only need to execute the copy command:
Cp framework. sh myscript
Then insert your own function.
Let's look at two more examples:
Binary to decimal conversion
The script b2d converts the binary number (such as 1101) to the corresponding decimal number. This is also an example of a mathematical operation using the expr command:Copy codeThe Code is as follows :#! /Bin/sh
# Vim: set sw = 4 ts = 4 et:
Help ()
{
Cat <
B2h -- convert binary to decimal
USAGE: b2h [-h] binarynum
OPTIONS:-h help text
EXAMPLE: b2h 111010
Will return 58
HELP
Exit 0
}
Error ()
{
# Print an error and exit
Echo "$1"
Exit 1
}
Lastchar ()
{
# Return the last character of a string in $ rval
If [-z "$1"]; then
# Empty string
Rval = ""
Return
Fi
# Wc puts some space behind the output this is why we need sed:
Numofchar = 'echo-n "$1" | wc-c | sed's // g''
# Now cut out the last char
Rval = 'echo-n "$1" | cut-B $ numofchar'
}
Chop ()
{
# Remove the last character in string and return it in $ rval
If [-z "$1"]; then
# Empty string
Rval = ""
Return
Fi
# Wc puts some space behind the output this is why we need sed:
Numofchar = 'echo-n "$1" | wc-c | sed's // g''
If ["$ numofchar" = "1"]; then
# Only one char in string
Rval = ""
Return
Fi
Numofcharminus1 = 'expr $ numofchar "-" 1'
# Now cut all but the last char:
Rval = 'echo-n "$1" | cut-B 0-$ {numofcharminus1 }'
}
While [-n "$1"]; do
Case $1 in
-H) help; shift 1; # function help is called
--) Shift; break; # end of options
-*) Error "error: no such option $1.-h for help ";;
*) Break ;;
Esac
Done
# The main program
Sum = 0
Weight = 1
# One arg must be given:
[-Z "$1"] & help
Binnum = "$1"
Binnumorig = "$1"
While [-n "$ binnum"]; do
Lastchar "$ binnum"
If ["$ rval" = "1"]; then
Sum = 'expr "$ weight" "+" "$ sum "'
Fi
# Remove the last position in $ binnum
Chop "$ binnum"
Binnum = "$ rval"
Weight = 'expr "$ weight" "*" 2'
Done
Echo "binary $ binnumorig is decimal $ sum"

The script uses decimal and binary weights (, 16,...), such as binary "10 ".
Convert to decimal:
0*1 + 1*2 = 2
To obtain a single binary number, we use the lastchar function. This function uses wc-c to calculate the number of characters,
Then, use the cut command to extract the last character. The Chop function removes the last character.
File loop Program
Maybe you want to save all emails to one of the people in a file, but after a few months
In the future, this file may become so large that the access speed to this file may be slowed down. The following script rotatefile
This problem can be solved. This script can rename the email storage file (assuming outmail) to outmail.1,
For outmail.1, it becomes outmail.2 and so on...Copy codeThe Code is as follows :#! /Bin/sh
# Vim: set sw = 4 ts = 4 et:
Ver = "0.1"
Help ()
{
Cat <
Rotatefile -- rotate the file name
USAGE: rotatefile [-h] filename
OPTIONS:-h help text
EXAMPLE: rotatefile out
This will e. g rename out.2 to out.3, out.1 to out.2, out to out.1
And create an empty out-file
The max number is 10
Version $ ver
HELP
Exit 0
}
Error ()
{
Echo "$1"
Exit 1
}
While [-n "$1"]; do
Case $1 in
-H) help; shift 1 ;;
--) Break ;;
-*) Echo "error: no such option $1.-h for help"; exit 1 ;;
*) Break ;;
Esac
Done
# Input check:
If [-z "$1"]; then
Error "ERROR: you must specify a file, use-h for help"
Fi
Filen = "$1"
# Rename any. 1,. 2 etc file:
For n in 9 8 7 6 5 4 3 2 1; do
If [-f "$ filen. $ n"]; then
P = 'expr $ n + 1'
Echo "mv $ filen. $ n $ filen. $ p"
Mv $ filen. $ n $ filen. $ p
Fi
Done
# Rename the original file:
If [-f "$ filen"]; then
Echo "mv $ filen $ filen.1"
Mv $ filen $ filen.1
Fi
Echo touch $ filen
Touch $ filen

How does this script work? After the user provides a file name, we perform a 9-1 loop. File 9 is named 10, file 8 is renamed to 9, and so on. After the loop is completed, we name the original file as file 1 and create an empty file with the same name as the original file.
Debugging
The simplest debugging command is the echo command. You can use echo to print any variable value in any suspected error. This is why most shell Programmers spend 80% of their time debugging programs. The benefit of a Shell program is that it does not need to be re-compiled, and it does not take much time to insert an echo command.
Shell also has a real debugging mode. If an error occurs in the script "strangescript", you can debug it as follows:
Sh-x strangescript
This will execute the script and display the values of all variables.
Shell also has a mode that only checks the syntax without executing the script. It can be used as follows:
Sh-n your_script
This will return all syntax errors
---------------------------------
Automatic Restart script
Assume that the program to be restarted is named test. Here, we determine whether the program is normal by judging the number of processes.
Ps-ef | grep "$1" | grep-v "grep" | wc-l is the number of processes that get $1 (test in this example, the script determines the next operation based on the number of processes. Through an infinite loop, the number of processes of the specified program in the system is checked every one second.

The Code is as follows:

Script check

Copy codeThe Code is as follows :#! /Bin/sh
#------------------------------------------------------------------------------
# Function: CheckProcess
# Function: Check whether a process exists
# Parameter: $1 --- Name of the process to be checked
# Return: If 0 exists, otherwise 1 is returned.
#------------------------------------------------------------------------------
CheckProcess ()
{
# Check whether the input parameters are valid
If ["$1" = ""];
Then
Return 1
Fi

# $ PROCESS_NUM: gets the number of specified process names. If the value is 1, 0 is returned. If the value is not 1, 1 is returned. If the value is not 1, an error is returned. Restart is required.
PROCESS_NUM = 'ps-ef | grep "$1" | grep-v "grep" | wc-l'
If [$ PROCESS_NUM-eq 1];
Then
Return 0
Else
Return 1
Fi
}
# Check whether the test instance already exists
While [1]; do
CheckProcess "test"
CheckQQ_RET = $?
If [$ CheckQQ_RET-eq 1];
Then
# Kill all the test processes and change the operations you want to perform.
Killall-9 test
Exec./test &
Fi
Sleep 1
Done

Script start:
Add limit coredumpsize 102400 to set the core file size. Once the program Core Dump, traces can be found. Running the check script in the background saves a lot of trouble,

#! /Bin/csh
Limit coredumpsize 102400
./Check &
------------------------------
Shell syntax
Shell syntax
--------------------------------------------------------------------------------
?
& After the command on the left (command 1) returns true (that is, 0 is returned and successfully executed), the command on the right (command 2) can be executed. In other words, "If this command is successfully executed & execute this command ".
| Opposite. If | the command on the left (command 1) is not successfully executed, execute | the command on the right (command 2); or in other words, "If this command fails to be executed | then execute this command.
To execute a group of commands in the current shell, you can use the command separator to separate each command and enclose all the commands in parentheses.
If {} is used to replace (), the corresponding command will be in the sub-shell instead