chap2.html

unix 下的C开发手册,还用详细的例程。

<dt>${<i>parameter</i>##<i>word</i>}<dd><code>
<pre>
x=/one/two/three
echo ${x##*/}
<b>three
</b></code>
</pre>

</dl>
<p>
The double-quoting of patterns is different depending on where the
double-quotes are placed:
<dl compact>

<dt>${x#*}<dd>The asterisk is a pattern character.

<dt>${x#"*"}<dd>The literal asterisk is quoted and not special.

</dl>
<h4><a name = "tag_001_006_003">&nbsp;</a>Command Substitution</h4>
<xref type="3" name="cmdsub"></xref>
Command substitution
allows the output of a command to be substituted
in place of the command name itself.
Command substitution occurs when the command is enclosed as follows:
<pre>
<code>
$(<i>command</i>)
</code>
</pre>
or (backquoted version):
<pre>
<code>
`<i>command</i>`
</code>
</pre>
<p>
The shell will expand the command substitution
by executing
<i>command</i>
in a subshell environment (see
<xref href=shexenv><a href="#tag_001_012">
Shell Execution Environment
</a></xref>)
and replacing the command substitution
(the text of
<i>command</i>
plus the enclosing
$()
or backquotes)
with the standard output of the command,
removing sequences of one or more
newline characters
at the end of the substitution.
Embedded
newline characters
before the end of the output will not be removed;
however, they may be treated as field delimiters and eliminated
during field splitting,
depending on the value of
and quoting that is in effect.
<p>
Within the backquoted style of command substitution,
backslash shall retain its literal meaning, except when followed by:
<pre>
<code>
$   `   \
</code>
</pre>
<p>
(dollar-sign, backquote, backslash).
The search for the matching backquote
is satisfied by the first backquote
found without a preceding backslash;
during this search,
if a non-escaped backquote is encountered
within a shell comment, a here-document,
an embedded command substitution of the $(<i>command</i>) form,
or a quoted string, undefined results occur.
A single- or double-quoted string that begins, but does not end, within the
`...` sequence produces undefined results.
<p>
With the $(<i>command</i>)
form, all characters following the open parenthesis to the matching
closing parenthesis constitute the
<i>command</i>.
Any valid shell script can be used for
<i>command</i>,
except:
<ul>
<p>
<li>
a script consisting solely of redirections produces unspecified results
<p>
<li>
see the restriction on single subshells described below.
<p>
</ul>
<p>
The results of command substitution will not be
field splitting and pathname expansion
processed for further
tilde expansion, parameter expansion, command substitution
or arithmetic expansion.
If a command substitution occurs inside double-quotes, it
will not be performed on the results of the substitution.
<p>
Command substitution can be nested.
To specify nesting within the backquoted version,
the application must precede the inner backquotes with
backslashes;
for example:
<pre>
<code>
\`<i>command</i>\`
</code>
</pre>
<p>
The
$()
form of command substitution
solves a problem of inconsistent behaviour when using backquotes.
For example:
<p><table  bordercolor=#000000 border=1 align=center><tr valign=top><th align=center><b>Command</b>
<th align=center><b>Output</b>
<tr valign=top><td align=left>echo '\$x'
<td align=left>\$x
<tr valign=top><td align=left>echo `echo '\$x'`
<td align=left>$x
<tr valign=top><td align=left>echo $(echo '\$x')
<td align=left>\$x
</table>
<p>
Additionally, the backquoted syntax has historical restrictions
on the contents of the embedded command.
While the new
$()
form can process any kind of valid embedded script,
the backquoted form cannot handle some valid scripts that
include backquotes.
For example, these otherwise valid embedded scripts
do not work in the left column, but do work on the right:
<pre>
<code>
echo `                         echo $(
cat &lt;&lt;\eof                     cat &lt;&lt;\eof
a here-doc with `              a here-doc with )
eof                            eof
`                              )

echo `                         echo $(
echo abc # a comment with `    echo abc # a comment with )
`                              )

echo `                         echo $(
echo '`'                       echo ')'
`                              )
</code>
</pre>
<p>
Because of these inconsistent behaviours,
the backquoted variety of command substitution
is not recommended for new applications that nest command substitutions
or attempt to embed complex scripts.
<p>
If the command substitution consists of a single subshell, such as:
<pre>
<code>
$( (<i>command</i>) )
</code>
</pre>
a portable application must separate the
$(
and
"("
into two tokens (that is, separate them with white space).
This is required to
avoid any ambiguities with arithmetic expansion.
<h4><a name = "tag_001_006_004">&nbsp;</a>Arithmetic Expansion</h4>
<xref type="3" name="aritexp"></xref>
Arithmetic expansion provides a mechanism for evaluating
an arithmetic expression and substituting its value.
The format for arithmetic expansion is as follows:
<pre>
<code>
$((<i>expression</i>))
</code>
</pre>
<p>
The expression is treated as if it were in double-quotes,
except that a double-quote inside the expression is not
treated specially.
The shell will expand all tokens in the expression
for parameter expansion, command substitution
and quote removal.
<p>
Next, the shell will treat this as an arithmetic expression
and substitute the value of the expression.
The arithmetic expression will be processed
according to the rules of the ISO&nbsp;C standard,
with the following exceptions:
<ul>
<p>
<li>
Only integer arithmetic is required.
<p>
<li>
The
sizeof()
operator and the prefix and postfix
++
and
--
operators are not required.
<p>
<li>
Selection, iteration and jump statements are not supported.
<p>
</ul>
<p>
As an extension, the shell may recognise arithmetic expressions
beyond those listed.
If the expression is invalid, the
expansion will fail and the shell
will write a message to standard error indicating the failure.
<p>
A simple example using arithmetic expansion:
<pre>
<code>
# repeat a command 100 times
x=100
while [ $x -gt 0 ]
do
    <i>command</i>
    x=$(($x-1))
done
</code>
</pre>
<h4><a name = "tag_001_006_005">&nbsp;</a>Field Splitting</h4>
<xref type="3" name="fldspl"></xref>
After parameter expansion,
command substitution,
and arithmetic expansion 
the shell will scan the results of expansions and substitutions
that did not occur in double-quotes for
field splitting and multiple fields can result.
<p>
The shell will treat each character of the
<i>IFS</i>
as a delimiter and use the delimiters to split the results of
parameter expansion and command substitution into
fields.
<ol>
<p>
<li>
If the value of
<i>IFS</i>
is a space, tab and newline character, or if it is unset,
any sequence of space, tab or newline
characters at the beginning or end of the input
will be ignored and any sequence
of those characters within the input will delimit a field.
For example, the input:
<pre>
<code>
&lt;newline&gt;&lt;space&gt;&lt;tab&gt;foo&lt;tab&gt;&lt;tab&gt;bar&lt;space&gt;
</code>
</pre>
yields two fields,
<b>foo</b>
and
<b>bar</b>.
<p>
<li>
If the value of
<i>IFS</i>
is null, no field splitting will be performed.
<p>
<li>
Otherwise, the following rules will be applied in sequence.
The term
&quot;<i>IFS</i>
white space&quot; is used to mean any sequence (zero or more instances) of
white-space characters that are in the
<i>IFS</i>
value (for example, if
<i>IFS</i>
contains space/comma/tab, any sequence of space and tab
characters is considered
<i>IFS</i>
white space).
<ol type = a>
<p>
<li>
<i>IFS</i>
white space is ignored at the beginning and end
of the input.
<p>
<li>
Each occurrence in the input of an
<i>IFS</i>
character that is not
<i>IFS</i>
white space, along with any adjacent
<i>IFS</i>
white space,
will delimit a field, as described previously.
<p>
<li>
Non-zero-length
<i>IFS</i>
white space will delimit a field.
<p>
</ol>
<p>
</ol>
<p>
The last rule can be summarised as a pseudo-ERE:
<pre>
<code>
(<i>s</i>*<i>ns</i>*|<i>s</i>+)
</code>
</pre>
where <i>s</i> is an
white-space character and <i>n</i> is a character in the
that is not white space.
Any string matching that ERE delimits a field, except that the <i>s</i>+
form does not delimit fields at the beginning or the end of a line.
For example, if
<i>IFS</i>
is space/comma/tab, the string:
<pre>
<code>
&lt;space&gt;&lt;space&gt;red&lt;space&gt;&lt;space&gt;,&lt;space&gt;white&lt;space&gt;blue
</code>
</pre>
yields the three colours as the delimited fields.
<h4><a name = "tag_001_006_006">&nbsp;</a>Pathname Expansion</h4>
<xref type="3" name="pathexp"></xref>
After field splitting, if
<i>set</i>
<b>-f</b>
is not in effect,
each field in the resulting command line will be
expanded using the algorithm described in
<xref href=patmat><a href="#tag_001_013">
Pattern Matching Notation
</a></xref>,
qualified by the rules in
<xref href=patfilx><a href="#tag_001_013_003">
Patterns Used for Filename Expansion
</a></xref>.
<h4><a name = "tag_001_006_007">&nbsp;</a>Quote Removal</h4>
<xref type="3" name="quoterm"></xref>
The quote characters:
<pre>
<code>
\   '   "
</code>
</pre>
<p>
(backslash, single-quote, double-quote)
that were present in the original word
will be removed unless they have themselves been quoted.
<hr size=2 noshade>
<h3><a name = "tag_001_007">&nbsp;</a>Redirection</h3>
<xref type="2" name="redir"></xref>
Redirection is used to open and close files for the current
shell execution environment (see
<xref href=shexenv><a href="#tag_001_012">
Shell Execution Environment
</a></xref>)
or for any command.
<i>Redirection operators</i>
can be used with numbers representing
file descriptors (see the definition in the ISO&nbsp;POSIX-1 standard)
as described below.
<p>
The overall format used for redirection is:
<code>
<p>
<b>[</b><i>n</i><b>]</b><i>redir-op</i>   <i>word</i>
</code>
<p>
The number
<i>n</i>
is an optional decimal number designating
the file descriptor number; it must be delimited
from any preceding text and immediately precede the
redirection operator
<i>redir-op</i>.
If
<i>n</i>
is quoted, the number will not be recognised as part of the
redirection expression.
For example:
<pre>
<code>
echo&nbsp;\2&gt;a
</code>
</pre>
writes the character
2
into file <b>a</b>.
If any part of
<i>redir-op</i>
is quoted, no redirection expression will be recognised.
For example:
<pre>
<code>
echo&nbsp;2\&gt;a
</code>
</pre>
writes the characters
2&gt;a
to standard output.
The optional number, redirection operator and
<i>word</i>
will not appear in the
arguments provided to the command to be executed (if any).
<p>
Open files are represented by decimal numbers
starting with zero.
The largest possible value is implementation-dependent;
however, all implementations support at least 0 to 9, inclusive,
for use by the application.
These numbers are called
<i>file descriptors</i>.
The values 0, 1 and 2
have special meaning and conventional uses
and are implied by certain redirection operations;
they are referred to as
<i>standard input</i>, <i>standard output</i>
and
<i>standard error</i>,
respectively.
Programs usually take their input from standard input,
and write output on standard output.
Error messages are usually written on standard error.
The redirection operators can be preceded by
one or more digits (with
no intervening
blank characters
allowed)
to designate the file descriptor number.
<p>
If the redirection operator is
&lt;&lt;
or
&lt;&lt;-,
the word that follows the redirection operator will be subjected to
quote removal;
it is unspecified whether any of the other expansions occur.
For the other redirection operators,
the word that follows the redirection operator will be subjected to
tilde expansion, parameter expansion, command substitution,
arithmetic expansion and quote removal.
Pathname expansion will not be performed on the word by a non-interactive shell;
an interactive shell may perform it, but will do so only when the
expansion would result in one word.
<p>
If more than one redirection operator is specified
with a command, the order of evaluation is from beginning to end.
<p>
A failure to open or create a file will cause the redirection to fail.
<h4><a name = "tag_001_007_001">&nbsp;</a>Redirecting Input</h4>
Input redirection will cause the file whose name results from the expansion of
<i>word</i>
to be opened for reading
on the designated file descriptor, or standard input if
the file descriptor is not specified.
<p>
The general format for redirecting input is:
<pre>
<code>
<b>[</b><i>n</i><b>]</b>&lt;<i>word</i>
</code>
</pre>
where the optional
<i>n</i>
represents the file descriptor number.
If the number is