读书笔记 - Beginning Linux Programming - Chapter 2 Shell Programming

Shell

 

What is Shell

Just like the batch file in windows, but more powerful

 

Pipes and redirection

 

Redirecting Output

$ ls -l > lsoutput.txt

Write into isoutput.txt
$ ps >> lsoutput.txt

Append to the file

$ kill -HUP 1234 >killout.txt 2>killerr.txt
Kill the process and sperate the output and error info into different files

$ kill -1 1234 >killouterr.txt 2>&1

Kill the process and write the error info in to the same file as output

 

Redirecting Input

$ more < killout.txt

 

Pipes

You can connect processes using the pipe operator ( | ).In Linux, unlike in MS-DOS, processes connected by pipes can run simultaneously and are automatically rescheduled as data flows between them
$ ps | sort > pssort.out
$ ps | sort | more
$ ps –xo comm | sort | uniq | grep -v sh | more

 

The Shell as a Programming Language

$ for file in *
> do
> if grep -l POSIX $file
> then
> more $file
> fi
> done
Note how the normal $ shell prompt changes to a > when the shell is expecting further input. You can type away, letting the shell decide when you’re finished, and the script will execute immediately.

 

widl cards

$ ls my_{finger,toe}s

 

Experienced Linux users would probably perform this simple operation in a much more efficient way,
perhaps with a command such as
$ more `grep -l POSIX *`
or the synonymous construction
$ more $(grep -l POSIX *)
In addition,
$ grep -l POSIX * | more

 

Creating a script

#!/bin/sh
#first
#This file looks through all the files in the current
#directory for the string POSIX, and then prints the names of
t#hose files to the standard output.
for file in *
do
if grep -q POSIX $file
then
echo $file
fi
done
exit 0

 

#! characters tell the system that the argument that follows on the line is the program to be used to execute this file. In this case, /bin/sh is the default shell program.

 

The exit command ensures that the script returns a sensible exit code

 

Lnux, and UNIX in general, rarely makes use of the filename extension to determine the type of a file

 

Making a script executable

 

1. $ /bin/sh first

2. $ chmod +x first

#cp first /usr/local/bin
#chown root /usr/local/bin/first
#chgrp root /usr/local/bin/first
#chmod 755 /usr/local/bin/first

 

Shell Syntax

 

Varaibles

You don’t usually declare variables in the shell before using them. Instead, you create them by simply
using them (for example, when you assign an initial value to them). By default, all variables are consid-
ered and stored as strings, even when they are assigned numeric values. The shell and some utilities will
convert numeric strings to their values in order to operate on them as required. Linux is a case-sensitive
system, so the shell considers the variable foo to be different from Foo, and both to be different from FOO.

 

$ salutation=Hello
$ echo $salutation
Hello
$ salutation=”Yes Dear”
$ echo $salutation
Yes Dear
$ salutation=7+5
$ echo $salutation
7+5

 

Note how a string must be delimited by quote marks if it contains spaces. In addition, there can’t be any spaces on either side of the equals sign.

 

$ read salutation
Wie geht’s?
$ echo $salutation
Wie geht’s?

 

The behavior of variables such as $foo inside quotes depends on the type of quotes you use. If you
enclose a $ variable expression in double quotes, then it’s replaced with its value when the line is exe-
cuted. If you enclose it in single quotes, then no substitution takes place. You can also remove the special
meaning of the $ symbol by prefacing it with a /.

 

#!/bin/sh
myvar=”Hi there”
echo $myvar
echo “$myvar”
echo ‘$myvar’
echo /$myvar
echo Enter some text
read myvar
echo ‘$myvar’ now equals $myvar
exit 0

Enrironment Varaible

$HOME
$PATH
$PS1
$PS2

$IFS
$0
$#
$$

 

Parameter Variable

$1,$2,$3

 

Conditions

The test and [ commond

In practice, most scripts make extensive use of the [ or test command, the shell’s Boolean check

 

if test -f fred.c
then
...
fi

 

if [ -f fred.c ]
then
...
fi

 

Note that you must put spaces between the [ braces and the condition being checked. You can remember this by remembering that [ is just the same as writing test, and you would always leave a space after the test command.
If you prefer putting then on the same line as if, you must add a semicolon to separate the test from the then:
if [ -f fred.c ]; then
...
fi

The condition types that you can use with the test command fall into three types: string comparison, arithmetic comparison, and file conditionals.

 

String Comparison Result
string1 = string2 True if the strings are equal
string1 != string2 True if the strings are not equal
-n string True if the string is not null
-z string True if the string is null (an empty string)
Arithmetic Comparison Result
expression1 -eq expression2 True if the expressions are equal
expression1 -ne expression2 True if the expressions are not equal
expression1 -gt expression2 True if expression1 is greater than expression2
expression1 -ge expression2 True if expression1 is greater than or equal to
expression2
expression1 -lt expression2 True if expression1 is less than expression2
expression1 -le expression2 True if expression1 is less than or equal to
expression2
! expression True if the expression is false, and vice versa
File Conditional Result
-d file True if the file is a directory
-e file True if the file exists. Note that historically the -e option
       has not been portable, so -f is usually used.
-f file True if the file is a regular file
-g file True if set-group-id is set on file
-r file True if the file is readable
-s file True if the file has nonzero size
-u file True if set-user-id is set on file
-w file True if the file is writable
-x file True if the file is executable

 

Condition structures

if condition
then
statements
else
statements
fi

 

elif

If you want the echo command to delete the trailing new line, the most portable option is to use the printf command (see the printf section later in this chapter), rather than the echo command. Some shells use echo –e, but that’s not supported on all systems. bash allows echo -n to suppress the new line, so if you are confident your script needs to work only on bash, we suggest using that syntax.

 

for variable in values
do
statements
done

 

What would happen if you changed the first line from for foo in bar fud 43 to for foo in “bar fud 43”? Remember that adding the quotes tells the shell to consider everything between them as a single string. This is one way of getting spaces to be stored in a variable.

 

While

 

while condition do
statements
done

 

#!/bin/sh
echo “Enter password”
read trythis
while [ “$trythis” != “secret” ]; do
echo “Sorry, try again”
read trythis
done
exit 0

 

until

 

until condition
do
statements
done

 

In general, if a loop should always execute at least once, use a while loop; if it may not need to execute at all, use an until loop.

 

case

 

case variable in
pattern [ | pattern] ...) statements;;
pattern [ | pattern] ...) statements;;
...
esac

 

Notice that each pattern line is terminated with double semicolons (;;). You can put multiple state-
ments between each pattern and the next, so a double semicolon is needed to mark where one statement
ends and the next pattern begins.

 

#!/bin/sh
echo “Is it morning? Please answer yes or no”
read timeofday
case “$timeofday” in
yes) echo “Good Morning”;;
no ) echo “Good Afternoon”;;
y ) echo “Good Morning”;;
n ) echo “Good Afternoon”;;
* ) echo “Sorry, answer not recognized”;;
esac
exit 0

It doesn’t look for a best match, just the first match. The default condition often turns out to be the impossible condition, so using * can help in debugging scripts.

 

#!/bin/sh
echo “Is it morning? Please answer yes or no”
read timeofday
case “$timeofday” in
yes | y | Yes | YES ) echo “Good Morning”;;
n* | N* ) echo “Good Afternoon”;;
* ) echo “Sorry, answer not recognized”;;
esac
exit 0

 

remember using " | " as or operation

 

#!/bin/sh
echo “Is it morning? Please answer yes or no”
read timeofday
case “$timeofday” in
yes | y | Yes | YES )
echo “Good Morning”
echo “Up bright and early this morning”
;;
[nN]*)
echo “Good Afternoon”
;;
*)
echo “Sorry, answer not recognized”
echo “Please answer yes or no”
exit 1
;;
esac
exit 0

 

You must be careful to put the most explicit matches first and the most general match last. This is important
because case executes the first match it finds, not the best match. If you put the *) first, it would always be matched, regardless of what was input.

Lists

 

The AND List

 

The AND list construct enables you to execute a series of commands, executing the next command only if all the previous commands have succeeded. The syntax is

 

statement1 && statement2 && statement3 && ...

 

#!/bin/sh
touch file_one
rm -f file_two
if [ -f file_one ] && echo “hello” && [ -f file_two ] && echo “ there”
then
echo “in if”
else
echo “in else”
fi
exit 0

 

The OR list

 

The OR list construct enables us to execute a series of commands until one succeeds, and then not execute any more. The syntax is as follows:

 

statement1 || statement2 || statement3 || ...

 

#!/bin/sh
rm -f file_one
if [ -f file_one ] || echo “hello” || echo “ there”
then
echo “in if”
else
echo “in else”
fi
exit 0

 

Functions

 

To define a shell function, simply write its name followed by empty parentheses and enclose the statements in braces:

 

function_name () {
     statements
}

 

#!/bin/sh
foo() {
echo “Function foo is executing”
}
echo “script starting”
foo
echo “script ended”
exit 0

 

There is no foward declaration in shell, so defind the function before you use it

 

Local variable and global variable

 

#!/bin/sh
sample_text=”global variable”
foo() {
local sample_text=”local variable”
echo “Function foo is executing”
echo $sample_text
}
echo “script starting”
echo $sample_text
foo
echo “script ended”
echo $sample_text
exit 0

Return a value

#!/bin/sh

 

yes_or_no() {
echo “Is your name $* ?”
while true
do
echo -n “Enter yes or no: “
read x
case “$x” in
y | yes ) return 0;;
n | no ) return 1;;
* )
echo “Answer yes or no”
esac
done
}

 

echo “Original parameters are $*“
if yes_or_no “$1”
then
echo “Hi $1, nice name”
else
echo “Never mind”
fi
exit 0

 

Commonds

 

break

 

We use break to escape from for while and until

 

#!/bin/sh
rm -rf fred*
echo > fred1
echo > fred2
mkdir fred3
echo > fred4
for file in fred*
do
if [ -d “$file” ]; then
break;

fi
done
echo first directory starting fred was $file
rm -rf fred*
exit 0

 

:

 

The colon command is a null command. It’s occasionally useful to simplify the logic of conditions, being an alias for true. Since it’s built-in, : runs faster than true, though its output is also much less readable.

 

#!/bin/sh
rm -f fred
if [ -f fred ]; then
:
else
echo file fred did not exist
fi
exit

 

continue

 

Just like the continue in C

 

#!/bin/sh
rm -rf fred*
echo > fred1
echo > fred2
mkdir fred3
echo > fred4

 

for file in fred*
do
if [ -d “$file” ]; then
echo “skipping directory $file”
continue
fi
echo file is $file
done
rm -rf fred*
exit 0

 

for x in 1 2 3
do
echo before $x
continue 1
echo after $x
done

 

The (dot) commond

.

 

excute the commond in the current sheel

. ./shell_script

 

echo

 

eval

 

foo=10
x=foo
y=’$’$x
echo $y

 

gives $foo

but

 

foo=10
x=foo
eval y=’$’$x
echo $y

 

gives 10

 

exec

 

exit n

 

The exit command causes the script to exit with exit code n

 

export

 

#!/bin/sh
echo “$foo”
echo “$bar”

 

#!/bin/sh
foo=”The first meta-syntactic variable”
export bar=”The second meta-syntactic variable”
export2

 

The commands set -a or set -allexport will export all variables thereafter.

 

expr

x=$(expr $x + 1)

 

Expression Evaluation Description
expr1 | expr2 expr1 if expr1 is nonzero, otherwise expr2
expr1 & expr2 Zero if either expression is zero, otherwise expr1
expr1 = expr2 Equal
expr1 > expr2 Greater than
expr1 >= expr2 Greater than or equal to
expr1 < expr2 Less than
expr1 <= expr2 Less than or equal to
expr1 != expr2 Not equal
expr1 + expr2 Addition
expr1 - expr2 Subtraction
expr1 * expr2 Multiplication
expr1 / expr2 Integer division
expr1 % expr2 Integer modulo

 

printf

just like the one in C/C++

 

printf “format string“ parameter1 parameter2 ...

 

Escape Sequence Description
/“ Double quote
// Backslash character
/a Alert (ring the bell or beep)
/b Backspace character
/c Suppress further output
/f Form feed character
/n Newline character
/r Carriage return
/t Tab character
/v Vertical tab character
/ooo The single character with octal value ooo
/xHH The single character with the hexadecimal value HH

 

return

 

set

 

#!/bin/sh
echo the date is $(date)
set $(date)
echo The month is $2
exit 0

 

shift

 

#!/bin/sh
while [ “$1” != “” ]; do
echo “$1”
shift
done
exit 0

 

trap