As you can see, the comments are echoed with the verbose flag. Also, each line is echoed before the variables
and the commands in backquotes are evaluated. Also note the "x" command echoes the assignment to
variables a and b on two lines, while the verbose flag echoed one line. Perhaps the best way to understand the
difference is the verbose flag echoes the line before the shell does anything with it, while the "x" flag causes
the shell to echo each command. Think of it as a case of Before and After.
Combining flags
You can combine the flags if you wish. Execute a script with
sh -x -v script
or more briefly
sh -xv script
Inside, you can use any of these commands
set -x -v
set -xv
set +x +v
set +xv
The first line of a script has an exception. You can use the format
#!/bin/sh -xv
but the following will not work:
#!/bin/sh -x -v
UNIX systems only pass the first argument to the interpreter. In the example above, the shell never sees the
"-v" option.
U - unset variables
Another useful flag for debugging is the "u" flag. Previously, I mentioned how the variable form "${x:?}"
reports an error if the variable is null or not set. Well, instead of changing every variable to this form, just use
the "-u" flag, which will report an error for any unset variable.
N - Bourne Shell non-execute flag
A simple way to check a complex shell script is the "-n" option. If set, the shell will read the script, and parse
the commands, but not execute them. If you wanted to check for syntax errors, but not execute the script, use
this command.
E - Bourne Shell exit flag
Bourne Shell Tutorial
http://www.grymoire.com/Unix/Sh.html
32 of 66
11/21/2011 12:03 PM
I haven't discussed the exit status much. Every external program or shell script exits with a status. A zero
status is normal. Any positive value is usually an error. I normally check the status when I need to, and ignore
it when I don't care. You can ignore errors by simply not looking at the error status, which is the "$?" variable
I mentioned last time. (If the program prints error messages, you have to redirect the messages elsewhere).
Still, you may have a case where the script isn't working the way you expect. The "-e" variable can be used
for this: if any error occurs, the shell script will immediately exit. This can also be used to make sure that any
errors are known and anticipated. This would be very important if you wanted to modify some information,
but only if no errors have happened. You wouldn't want to corrupt some important database, would you?
Suppose the following script is executed:
#!/bin/sh
word=$1
grep $word my_file >/tmp/count
count=`wc -l
echo I found $count words in my_file
The script searches for a pattern inside a file, and prints out how many times the pattern is found. The grep
program, however, exits with an error status if no words are found. If the "e" option is set, the shell terminates
before executing the count program. If you were concerned about errors, you could set the "e" option at the
beginning of the script. If you find out later that you want to ignore the error, bracket it with instructions to
disable the option:
set +e # ignore errors
grep $word my_file >/tmp/count
set -e
T - Bourne Shell test one command flag
Another way to make a script exit quickly is to use the "t" option. This causes the shell to execute one more
line, then exit. This would be useful if you wanted to check for the existence of a script, but didn't want it to
complete. Perhaps the script takes a long time to execute, and you just care if it's there. In this case, executing
sh -t script
will do this for you.
A - Bourne Shell mark for export flag
Previously, I mentioned you had to explicitly export a variable to place it in the environment, so other
programs can find it. That is, if you execute these commands
a=newvalue
newscript
The script newscript will now know the value of variable "a."
in the environment with
export a
Bourne Shell Tutorial
http://www.grymoire.com/Unix/Sh.html
33 of 66
11/21/2011 12:03 PM
A second way to do this is to assign the variable right before executing the script:
a=newvalue newscript
This is an unusual form, and not often used. There is no semicolon on the line. If there was a semicolon
between the assignment and myscript, the variable "a" would not be made an environment variable.
Another way to do this is to set the "a" option:
set -a
If set, all variables that are modified or created will be exported. This could be very useful if you split one
large script into two smaller scripts, and want to make sure all variables defined on one script are known to
the other.
K - Bourne Shell keyword flag
While many of the options I have discussed are useful for debugging, or working around problems, other
options solve subtle problems. An obscure option is the "k" switch. Consider the following Bourne shell
command
a=1 myscript b=2 c d=3
When myscript executes, four pieces of information are passed to the program: The environment variable "a"
has the value 1. Three arguments are passed to the script: "b=2," "c," and "d=3."
Any assignment on the same line as a command is made an environment variable, but only if it's before the
command. The "-k" options changes this All three assignments become environment variables, and the script
only sees one argument.
H - Bourne Shell hash functions flag
I've read the manual page, and was unclear. This seems to be a way to speed up program executings by
pre-storing the paths for each command. The Bash manpage says this is enabled by default. "-h" option.
The $- variable
As I mentioned, you can use the set command to change the value of these flags. However, it cannot be used
to check the values. There is a special variable, called "$-," which contains the current options. You can print
the values, or test them. It has another use. Suppose you had a complex script that called other scripts.
Suppose you wanted to debug all of the scripts. You could modify every script, add the option you wanted.
That is, assume, newscript might contain
#!/bin/sh
myscript arg1 arg2
If this is replaced by
#!/bin/sh
Bourne Shell Tutorial
http://www.grymoire.com/Unix/Sh.html
34 of 66
11/21/2011 12:03 PM
Dostları ilə paylaş: |