《Beiginning Linux programming || Linux 程序设计》读书笔记(四)

(21) Trap

    The trap command is used to specify the actions to take on receipt of signals. A common use is to tidy up a script when it is interrupted.
    The trap command is passed the action to take, followed by the signal name (or names) to trap on:

         trap command signal

Remember that the scripts are normally interpreted from top to bottom, so you must specify the trap command before the part of the script you wish to protect.

    To see the signal numbers and associated names, you can just type trap -l at a command prompt.
    To reset a trap condition to the default, simply specify the command as -. To ignore a signal, set the command to the empty string ‘’.

    Signal                                Description
    HUP (1)         Hang up; usually sent when a terminal goes offline, or a user logs out
    INT (2)         Interrupt; usually sent by pressing Ctrl+C
    QUIT (3)       Quit; usually sent by pressing Ctrl+/
    ABRT (6)       Abort; usually sent on some serious execution error
    ALRM (14)      Alarm; usually used for handling timeouts
    TERM (15)     Terminate; usually sent by the system when it’s shutting down

(22) unset
    The unset command removes variables or functions from the environment. It can’t do this to read-only variables defined by the shell itself, such as IFS.

(23) find
    The full syntax for the find command is as follows:
         find [path] [options] [tests] [actions]

     Option                    Meaning
                 
    -depth                    Search the contents of a directory before looking at the directory itself.
    -follow                    Follow symbolic links.
    -maxdepths N          Search at most N levels of the directory when searching.
    -mount (or -xdev)     Don’t search directories on other file systems.


Test                         Meaning
                
-atime N        The file was last accessed N days ago.    
           
-mtime N        The file was last modified N days ago.        
       
-name pattern    The name of the file, excluding any path, matches the pattern pro-
                         vided. To ensure that the pattern is passed to find, and not evaluated
                         by the shell immediately, the pattern must always be in quotes.
                        
-newer otherfile    The file is newer than the file otherfile.
               
-type C             The file is of type C, where C can be of a particular type; the most
                     common are “d” for a directory and “f” for a regular file. For other
                     types consult the manual pages.
                
-user username    The file is owned by the user with the given name.


Operator,     Short Form Operator,     Long Form Meaning
                                        
!                    -not                            Invert the test.
                                        
-a                   -and                        Both tests must be true.
                                        
-o                   -or                            Either test must be true.


Action                        Meaning
             
-exec command    Execute a command. This is one of the most common actions. See the
                          explanation following this table for how parameters may be passed to
                          the command. This action must be terminated with a /; character pair.
                          
-ok command        Like -exec, except that it prompts for user confirmation of each file on
                           which it will carry out the command before executing the command.
                          This action must be terminated with a /; character pair.
            
-print                     Print out the name of the file.
             
-ls                        Use the command ls -dils on the current file.


(24) grep
    The grep command takes options, a pattern to match, and files to search in:
             grep [options] PATTERN [FILES]

Option     Meaning
      
-c         Rather than print matching lines, print a count of the number of linesthat match.      
-E         Turn on extended expressions.      
-h         Suppress the normal prefixing of each output line with the name of the file it was found in.       
-i          Ignore case.      
-l          List the names of the files with matching lines; don’t output the actual matched line.      
-v         Invert the matching pattern to select nonmatching lines, rather than matching lines.


(25) Regular Expressions
    The most frequently used are shown in the following table:

    Character                    Meaning
                               
   ^                           Anchor to the beginning of a line
                               
   $                           Anchor to the end of a line
                               
   .                             Any single character
                               
   [ ]                         The square braces contain a range of characters, any one of which
                                may be matched, such as a range of characters like a–e or an inverted
                                range by preceding the range with a ^ symbol.
If you want to use any of these characters as “normal” characters, precede them with a /.

There are also some useful special match patterns that can be used in square braces, as described in the following table:
  
    Match Pattern                        Meaning
                                        
    [:alnum:]                        Alphanumeric characters
                                        
    [:alpha:]                         Letters
                                        
    [:ascii:]                           ASCII characters
                                        
    [:blank:]                          Space or tab
                                        
    [:cntrl:]                          ASCII control characters
                                        
    [:digit:]                           Digits
                                        
    [:graph:]                         Noncontrol, nonspace characters
                                        
    [:lower:]                          Lowercase letters
                                        
    [:print:]                          Printable characters
                                        
    [:punct:]                        Punctuation characters
                                        
    [:space:]                        Whitespace characters, including vertical tab
                                        
    [:upper:]                         Uppercase letters
                                        
    [:xdigit:]                         Hexadecimal digits

In addition, if the -E for extended matching is also specified, other characters that control the completion of matching may follow the regular expression (see the following table). With grep it is also necessary to precede these characters with a /.

Examples:
    $ grep "e$" words2.txt        # this finds lines that end in the letter e.
    $ grep a[[:blank:]] words2.txt          # find words that end with the letter a.  [[:blank:]]  tests for a space or a tab
    $ grep -E [a-z]/{10/} words2.txt         # use the extended grep mode to search for lowercase words that are exactly 10 characterslong. Do this by specifying a range of                                                                      # characters to match a to z, and a repetition of 10 matches

(26) Command Execution
    Execute a command and put the output of the command into a variable. You can do this by using the $(command) syntax.The result of the $(command) is simply the output from the command. If you want to get the result into a variable, you can just assign it in the usual way:
         whoisthere=$(who)
         echo $whoisthere

(27) Arithmetic Expansion
    The expr command can enable simple arithmetic commands to be processed, but this is quite slow to execute because a new shell is invoked to process the expr command.
    A newer and better alternative is $((...)) expansion. By enclosing the expression you wish to evaluate in $((...)), you can perform simple arithmetic much more efficiently.

#!/bin/sh

x=0
while [ "$x" -ne 10 ]; do
    echo $x
    x=$(($x+1))
done

exit 0

(28) Parameter Expansion

These substitutions are often useful when you’re working with strings. The last four, which remove parts of strings, are especially useful for processing filenames and paths, as the following example shows.

#!/bin/sh

unset foo
echo ${foo:-bar}

foo=fud
echo ${foo:-bar}

foo=/usr/bin/X11/startx
echo ${foo#*/}
echo ${foo##*/}

bar=/usr/local/etc/local/networks
echo ${bar%local*}
echo ${bar%%local*}

exit 0

The output is:

bar
fud
usr/bin/X11/startx
startx
/usr/local/etc
/usr

(29) Here Document
One special way of passing input to a command from a shell script is to use a here document. This document allows a command to execute as though it were reading from a file or the keyboard, whereas in fact it’s getting input from the script.

A here document starts with the leader <<, followed by a special sequence of characters that is repeated at the end of the document. << is the shell’s label redirector, which in this case forces the command input to be the here document. This special sequence acts as a marker to tell the shell where the here document ends. The marker sequence must not appear in the lines to be passed to the command, so it’s best to make them memorable and fairly unusual.

#!/bin/sh

cat <<!FUNKY!
hello
this is a here
document

!FUNKY!

4.7 Debugging Shell
    Since scripts are interpreted, there’s no compilation overhead in modifying and retrying a script. The main way to trace more complicated errors is to set various shell options. To do this, you can either use command-line options after invoking the shell or use the set command. The following table summarizes the options:

4.8 Dialog Utility

Example1:
#!/bin/sh
# Ask some questions and collect the answer
dialog --title "Questionnaire" --msgbox "Welcome to my simple survey" 9 18

dialog --title "Confirm" --yesno "Are you willing to take part?" 9 18
if [ "$?" != 0 ]; then
  dialog --infobox "Thank you anyway" 5 20
  sleep 2
  dialog --clear
  exit 0
fi

dialog --title "Questionnaire" --inputbox "Please enter your name" 9 30 2>_1.txt
Q_NAME=$(cat _1.txt)

dialog --menu "$Q_NAME, what music do you like best?" 15 30 4 1 "Classical" 2 "Jazz" 3 "Country" 4 "Other" 2>_1.txt
Q_MUSIC=$(cat _1.txt)

if [ "$Q_MUSIC" = "1" ]; then
  dialog --title "Likes Classical" --msgbox "Good choice!" 12 25
else
  dialog --title "Doesn’t like Classical" --msgbox "Shame" 12 25
fi

sleep 2
dialog --clear
exit 0

Explanation:
    You start with a simple welcome screen, before asking the user if he will take part using the simple --yesno option of dialog. You use the $? variable to check the reply. If he agreed, you then get his name, store it in a variable Q_NAME, and ask what sort of music he likes, using the --menu option of dialog. By storing the numerical output in the variable Q_MUSIC, you can see what he answered, and give an appropriate response.