Basics of writing Linux scripts

Linux shell Script Basic Learning, although not involved in specific things, but lay a good foundation is to learn easily after the premise.

Basic Introduction to 1.1 grammar

1.1.1 Opening

The program must start with the following line (must be in the first line of the file):

#!/bin/sh

The symbol #! is used to tell the system that the parameter behind it is the program used to execute the file. In this example we use/BIN/SH to execute the program.

When you edit a script, you must also make it executable if you want to execute the script.

To make the script executable:

Compile chmod +x filename so you can use./filename to run

1.1.2 Notes

In shell programming, a sentence that begins with # represents a comment until the end of the line. We sincerely recommend that you use annotations in your programs.

If you use annotations, you can understand the script's function and how it works in a very short time, even if you haven't used the script for quite a long period of time.

1.1.3 Variable

In other programming languages, you must use variables. In shell programming, all variables are made up of strings, and you do not need to declare the variables. To assign a value to a variable, you can write:

#!/bin/sh

#对变量赋值:

A= "Hello World"

# now print the contents of variable a:

echo "A is:"

Echo $a

Sometimes variable names are easily confused with other words, such as:

num=2

echo "The $numnd"

This does not print out "This is the 2nd" and simply prints "This is the" because the shell will go to search for the value of the variable numnd, but this variable has no value. You can use curly braces to tell the shell that we're printing num variables:

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 do not discuss environment variables, because environment variables are typically used only in logon scripts.

1.1.5 shell command and Process Control

There are three types of commands that can be used in shell scripts:

1) Unix command:

Although you can use any Unix command in a shell script, there are some relatively common commands. These commands are usually used for file and text operations.

Common command syntax and functions

echo "Some text": Print text content on the screen

LS: File list

Wc–l filewc-w filewc-c File: Count the number of words in the file count the number of characters in the file

CP sourcefile destfile: File copy

MV oldname newname: Renaming files or moving files

RM file: Deleting files

grep ' pattern ' file: Search for strings within a file such as: grep ' searchstring ' file.txt

Cut-b colnum File: Specifies the range of files to display and outputs them to a standard output device such as: Output from 5th to 9th characters per line cut-b5-9 file.txt never be confused with cat commands, this is two completely different commands

Cat file.txt: Output file contents to standard output device (screen)

File somefile: Get the files type

Read Var: Prompts the user for input and assigns the input to the variable

Sort file.txt: Sorting rows in a file.txt file

Uniq: Delete columns that appear in a text file such as: sort File.txt | Uniq

Expr: Perform mathematical operations Example:add 2 and 3expr 2 "+" 3

Find: Search for files like: Search for Find by file name. -name Filename-print

Tee: Output data to standard output devices (screens) and files such as: Somecommand | Tee outfile

basename file: Returns a file name that does not contain a path such as: Basename/bin/tux will return Tux

DirName file: Returns the path of the files such as: Dirname/bin/tux will return/bin

Head file: Print text file at the beginning of a few lines

Tail File: Print text file at the end of a few lines

Sed:sed is a basic find-and-replace program. You can read text from standard input, such as a command pipeline, and output the results to a standard output (screen). the command is searched using a regular expression (see Reference). Do not confuse with wildcard characters in the shell. For example: Replace Linuxfocus with Linuxfocus:cat text.file | Sed ' s/linuxfocus/linuxfocus/' > Newtext.file

The Awk:awk is used to extract fields from a text file. By default, the field separator is a space, and you can use-f to specify additional delimiters.

Cat File.txt | Awk-f, ' {print $ ', ' $ i} ' here we use, as field separators, while printing the first and third fields. If the contents of the file are as follows: Adam Bor, Indiakerry Miller, the USA command output is: Adam Bor, Indiakerry Miller, USA

2) Concepts: piping, redirection and Backtick

These are not system commands, but they are really important.

Pipe (|) The output of one command as input to another command.

1	grep"hello" file.txt | wc-l

Searches for a row containing "Hello" in File.txt and calculates its number of rows.

Here the output of the grep command is used as input to the WC command. Of course you can use multiple commands.

Redirect: Outputs the result of the command to a file instead of the standard output (screen).

> Write files and overwrite old files

>> add to the end of the file, preserving the contents of the old file.

Anti-Short Slash

Use a backslash to make the output of one command a command-line argument for another command.

Command:

1	find. -mtime -1 -typef -print

Used to find files that have been modified in the last 24 hours (-mtime–2 represents the last 48 hours). If you want to hit a package with all the files you find, you can use the following script:

#!/bin/sh# The Ticks is backticks (') not normal quotes ('): TAR-ZCVF lastmod.tar.gz ' Find. -mtime-1-type F-print '

3) Process Control

1.if

The "If" expression executes the following part if the condition is true:

If ....; Then

....

Elif ...; Then

....

Else

....

Fi

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

The condition test is usually represented by "[]". Note that the space here is important. The space to ensure the square brackets.

[-F "somefile"]: Determine if it is a file

[-X "/bin/ls"]: Determine if/bin/ls exists and has executable permissions

[-N ' $var]: Determine if the $var variable has a value

["$a" = "$b"]: Determine if $ A and $b are equal

Execute man test to see the types that all test expressions can compare and judge.

Execute the following script directly:

#!/bin/shif ["$SHELL" = "/bin/bash"]; Then    echo "Your login shell was the bash (Bourne again shell)" Else    echo "Your login shell is not bash but $SHELL" fi

The variable $shell contains the name of the login shell, which we compared with/bin/bash.

Shortcut operator

A friend familiar with C might like the following expression:

[-F "/etc/shadow"] && echo "This computer uses Shadow Passwors"

Here && is a shortcut operator that executes the statement on the right if the expression on the left is true.

You can also think of it as an operation in a logical operation. The above example prints "This computer uses Shadow Passwors" if the/etc/shadow file exists. Same OR operation (| |) is also available in Shell programming. Here's an example:

#!/bin/shmailfolder=/var/spool/mail/james[-R "$mailfolder"] | | {echo "Can not read $mailfolder"; exit 1;} echo "$mailfolder have mail from:" grep "^from" $mailfolder

The script first determines whether the mailfolder is readable. Prints the "from" line in the file if it is readable. If unreadable or the operation takes effect, the script exits after the error message is printed. Here's the problem: we have to have two commands.

-Print error message

-Exit Program

We use curly braces to put two commands together as a command in the form of an anonymous function. The general functions are mentioned below.

Without the and and or operators, we can do anything with an if expression, but using and or operators is much more convenient.

2.case

Case: The expression can be used to match a given string instead of a number.

Case ... in

...) do something here;;

Esac

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

File lf.gz

This will return:

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

Last Modified:mon 23:09:18 2001, Os:unix

We use this to write a script called Smartzip, which automatically extracts compressed files of bzip2, gzip, and zip types:

#!/bin/shftype= ' file ' "' Case" $ftype "in    " $1:zip Archive "*)        Unzip" $ ";;    " $1:gzip Compressed "*)        gunzip" $ ";;    " $1:BZIP2 Compressed "*)        bunzip2" $ ";;    *) echo "File" can not is uncompressed with smartzip "; Esac

You may notice that we are using a special variable here. The variable contains the first parameter value passed to the program.

In other words, when we run:

Smartzip Articles.zip

$ $ is the string articles.zip

3. Selsect

The select expression is an extended application of bash and is particularly adept at interactive use. Users can choose from a different set of values.

Select Var in ...; Do

Break

Done

.... Now $var can be used ....

Here is an example:

#!/bin/shecho "What is your favourite OS?" Select Var in "Linux", "Gnu Hurd" "Free BSD" and "other"; Do    Breakdoneecho "You have selected $var"

The following is the result of the script running:

What is your favourite 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. Would run while the expression, the We test for is true.

The keyword "break" is used to jump out of a loop. The keyword "Continue" is used to skip to the next loop without executing the rest of the section.

The For-loop expression looks at a list of strings (strings separated by spaces) and assigns them to a variable:

for Var in ...; Do

....

Done

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

#!/bin/shfor var in A B C; Do    Echo ' var is $var ' done

The following is a more useful script showrpm, which functions to print some RPM package statistics:

#!/bin/sh# List A content summary of a number of RPM packages# usage:showrpm rpmfile1 rpmfile2 ... # example:showrpm/cdr Om/redhat/rpms/*.rpmfor rpmpackage in $*; Do    if [-R ' $rpmpackage "];then        echo" =============== $rpmpackage ============== "        rpm-qi-p $rpmpackage    else        echo "error:cannot Read file $rpmpackage"    Fidone

There is a second special variable, $*, that contains all the input command-line parameter values.

If you run

showrpm openssh.rpm w3m.rpm webgrep.rpm

At this point $* contains 3 strings, namely openssh.rpm, w3m.rpm and webgrep.rpm.

5. Quotation marks

The program expands wildcard characters and variables before passing any parameters to the program. The so-called extension means that the program replaces the wildcard character (such as *) with the appropriate file name, and the variable is replaced with the variable value. To prevent the program from making this substitution, you can use quotation marks: Let's take a look at an example, assuming there are some files in the current directory, two JPG files, mail.jpg and tux.jpg.

1.2 Compiling shell scripts

Script FileName:

#!/bin/sh Echo *.jpg

chmod +x filename

./filename to execute your script.

This will print out the results of "mail.jpg tux.jpg".

quotation marks (single and double quotation marks) prevent this wildcard extension:

#!/bin/shecho "*.jpg" Echo ' *.jpg '

This will print "*.jpg" two times.

Single quotes are more restrictive. It prevents any variable expansion. Double quotes prevent wildcard expansion but allow variable expansion.

#!/bin/shecho $SHELLecho "$SHELL" Echo ' $SHELL '

The result of the operation is:

/bin/bash

/bin/bash

$SHELL

Finally, there is a way to prevent this extension by using the escape character-the backslash:

#!/bin/shecho \*.jpgecho \ $SHELL

This will output:

*.jpg

$SHELL

Linux Shell Scripting Basics Here, the control process has a little bit of here document content to analyze next time.

Basics of writing Linux scripts