gawk.texi

早期freebsd实现

awk -f hello
@end example

@noindent
Self-contained @code{awk} scripts are useful when you want to write a
program which users can invoke without knowing that the program is
written in @code{awk}.

@cindex shell scripts
@cindex scripts, shell
If your system does not support the @samp{#!} mechanism, you can get a
similar effect using a regular shell script.  It would look something
like this:

@example
: The colon makes sure this script is executed by the Bourne shell.
awk '@var{program}' "$@@"
@end example

Using this technique, it is @emph{vital} to enclose the @var{program} in
single quotes to protect it from interpretation by the shell.  If you
omit the quotes, only a shell wizard can predict the results.

The @samp{"$@@"} causes the shell to forward all the command line
arguments to the @code{awk} program, without interpretation.  The first
line, which starts with a colon, is used so that this shell script will
work even if invoked by a user who uses the C shell.
@c Someday: (See @cite{The Bourne Again Shell}, by ??.)

@node Comments, Statements/Lines, Running gawk, Getting Started
@section Comments in @code{awk} Programs
@cindex @samp{#}
@cindex comments
@cindex use of comments
@cindex documenting @code{awk} programs
@cindex programs, documenting

A @dfn{comment} is some text that is included in a program for the sake
of human readers, and that is not really part of the program.  Comments
can explain what the program does, and how it works.  Nearly all
programming languages have provisions for comments, because programs are
typically hard to understand without their extra help.

In the @code{awk} language, a comment starts with the sharp sign
character, @samp{#}, and continues to the end of the line.  The
@code{awk} language ignores the rest of a line following a sharp sign.
For example, we could have put the following into @file{th-prog}:@refill

@smallexample
# This program finds records containing the pattern @samp{th}.  This is how
# you continue comments on additional lines.
/th/
@end smallexample

You can put comment lines into keyboard-composed throw-away @code{awk}
programs also, but this usually isn't very useful; the purpose of a
comment is to help you or another person understand the program at
a later time.@refill

@node Statements/Lines, When, Comments, Getting Started
@section @code{awk} Statements versus Lines

Most often, each line in an @code{awk} program is a separate statement or
separate rule, like this:

@example
awk '/12/  @{ print $0 @}
     /21/  @{ print $0 @}' BBS-list inventory-shipped
@end example

But sometimes statements can be more than one line, and lines can
contain several statements.  You can split a statement into multiple
lines by inserting a newline after any of the following:@refill

@example
,    @{    ?    :    ||    &&    do    else
@end example

@noindent
A newline at any other point is considered the end of the statement.
(Splitting lines after @samp{?} and @samp{:} is a minor @code{gawk}
extension.  The @samp{?} and @samp{:} referred to here is the 
three operand conditional expression described in
@ref{Conditional Exp, ,Conditional Expressions}.)@refill

@cindex backslash continuation
@cindex continuation of lines
If you would like to split a single statement into two lines at a point
where a newline would terminate it, you can @dfn{continue} it by ending the
first line with a backslash character, @samp{\}.  This is allowed
absolutely anywhere in the statement, even in the middle of a string or
regular expression.  For example:

@example
awk '/This program is too long, so continue it\
 on the next line/ @{ print $1 @}'
@end example

@noindent
We have generally not used backslash continuation in the sample programs in
this manual.  Since in @code{gawk} there is no limit on the length of a line,
it is never strictly necessary; it just makes programs prettier.  We have
preferred to make them even more pretty by keeping the statements short.
Backslash continuation is most useful when your @code{awk} program is in a
separate source file, instead of typed in on the command line.  You should
also note that many @code{awk} implementations are more picky about where
you may use backslash continuation.  For maximal portability of your @code{awk}
programs, it is best not to split your lines in the middle of a regular
expression or a string.@refill

@strong{Warning: backslash continuation does not work as described above
with the C shell.}  Continuation with backslash works for @code{awk}
programs in files, and also for one-shot programs @emph{provided} you
are using a @sc{posix}-compliant shell, such as the Bourne shell or the
Bourne-again shell.  But the C shell used on Berkeley Unix behaves
differently!  There, you must use two backslashes in a row, followed by
a newline.@refill

@cindex multiple statements on one line
When @code{awk} statements within one rule are short, you might want to put
more than one of them on a line.  You do this by separating the statements
with a semicolon, @samp{;}.
This also applies to the rules themselves.
Thus, the previous program could have been written:@refill

@example
/12/ @{ print $0 @} ; /21/ @{ print $0 @}
@end example

@noindent
@strong{Note:} the requirement that rules on the same line must be
separated with a semicolon is a recent change in the @code{awk}
language; it was done for consistency with the treatment of statements
within an action.

@node When,  , Statements/Lines, Getting Started
@section When to Use @code{awk}

@cindex when to use @code{awk}
@cindex applications of @code{awk}
You might wonder how @code{awk} might be useful for you.  Using additional
utility programs, more advanced patterns, field separators, arithmetic
statements, and other selection criteria, you can produce much more
complex output.  The @code{awk} language is very useful for producing
reports from large amounts of raw data, such as summarizing information
from the output of other utility programs like @code{ls}.  
(@xref{More Complex, ,A More Complex Example}.)

Programs written with @code{awk} are usually much smaller than they would
be in other languages.  This makes @code{awk} programs easy to compose and
use.  Often @code{awk} programs can be quickly composed at your terminal,
used once, and thrown away.  Since @code{awk} programs are interpreted, you
can avoid the usually lengthy edit-compile-test-debug cycle of software
development.

Complex programs have been written in @code{awk}, including a complete
retargetable assembler for 8-bit microprocessors (@pxref{Glossary}, for
more information) and a microcode assembler for a special purpose Prolog
computer.  However, @code{awk}'s capabilities are strained by tasks of
such complexity.

If you find yourself writing @code{awk} scripts of more than, say, a few
hundred lines, you might consider using a different programming
language.  Emacs Lisp is a good choice if you need sophisticated string
or pattern matching capabilities.  The shell is also good at string and
pattern matching; in addition, it allows powerful use of the system
utilities.  More conventional languages, such as C, C++, and Lisp, offer
better facilities for system programming and for managing the complexity
of large programs.  Programs in these languages may require more lines
of source code than the equivalent @code{awk} programs, but they are
easier to maintain and usually run more efficiently.@refill

@node Reading Files, Printing, Getting Started, Top
@chapter Reading Input Files

@cindex reading files
@cindex input
@cindex standard input
@vindex FILENAME
In the typical @code{awk} program, all input is read either from the
standard input (by default the keyboard, but often a pipe from another
command) or from files whose names you specify on the @code{awk} command
line.  If you specify input files, @code{awk} reads them in order, reading
all the data from one before going on to the next.  The name of the current
input file can be found in the built-in variable @code{FILENAME}
(@pxref{Built-in Variables}).@refill

The input is read in units called records, and processed by the
rules one record at a time.  By default, each record is one line.  Each
record is split automatically into fields, to make it more
convenient for a rule to work on its parts.

On rare occasions you will need to use the @code{getline} command,
which can do explicit input from any number of files
(@pxref{Getline, ,Explicit Input with @code{getline}}).@refill

@menu
* Records::                     Controlling how data is split into records.
* Fields::                      An introduction to fields.
* Non-Constant Fields::         Non-constant Field Numbers.
* Changing Fields::             Changing the Contents of a Field.
* Field Separators::            The field separator and how to change it.
* Constant Size::               Reading constant width data.
* Multiple Line::               Reading multi-line records.
* Getline::                     Reading files under explicit program control
                                using the @code{getline} function.
* Close Input::                 Closing an input file (so you can read from
                                the beginning once more).
@end menu

@node Records, Fields, Reading Files, Reading Files
@section How Input is Split into Records

@cindex record separator
The @code{awk} language divides its input into records and fields.
Records are separated by a character called the @dfn{record separator}.
By default, the record separator is the newline character, defining
a record to be a single line of text.@refill

@iftex
@cindex changing the record separator
@end iftex
@vindex RS
Sometimes you may want to use a different character to separate your
records.  You can use a different character by changing the built-in
variable @code{RS}.  The value of @code{RS} is a string that says how
to separate records; the default value is @code{"\n"}, the string containing
just a newline character.  This is why records are, by default, single lines.

@code{RS} can have any string as its value, but only the first character
of the string is used as the record separator.  The other characters are
ignored.  @code{RS} is exceptional in this regard; @code{awk} uses the
full value of all its other built-in variables.@refill

@ignore
Someday this should be true!

The value of @code{RS} is not limited to a one-character string.  It can
be any regular expression (@pxref{Regexp, ,Regular Expressions as Patterns}).
In general, each record
ends at the next string that matches the regular expression; the next
record starts at the end of the matching string.  This general rule is
actually at work in the usual case, where @code{RS} contains just a
newline: a record ends at the beginning of the next matching string (the
next newline in the input) and the following record starts just after
the end of this string (at the first character of the following line).
The newline, since it matches @code{RS}, is not part of either record.@refill
@end ignore

You can change the value of @code{RS} in the @code{awk} program with the
assignment operator, @samp{=} (@pxref{Assignment Ops, ,Assignment Expressions}).
The new record-separator character should be enclosed in quotation marks to make
a string constant.  Often the right time to do this is at the beginning
of execution, before any input has been processed, so that the very
first record will be read with the proper separator.  To do this, use
the special @code{BEGIN} pattern
(@pxref{BEGIN/END, ,@code{BEGIN} and @code{END} Special Patterns}).  For
example:@refill

@example
awk 'BEGIN @{ RS = "/" @} ; @{ print $0 @}' BBS-list
@end example

@noindent
changes the value of @code{RS} to @code{"/"}, before reading any input.
This is a string whose first character is a slash; as a result, records
are separated by slashes.  Then the input file is read, and the second
rule in the @code{awk} program (the action with no pattern) prints each
record.  Since each @code{print} statement adds a newline at the end of
its output, the effect of this @code{awk} program is to copy the input
with each slash changed to a newline.

Another way to change the record separator is on the command line,
using the variable-assignment feature
(@pxref{Command Line, ,Invoking @code{awk}}).@refill

@example
awk '@{ print $0 @}' RS="/" BBS-list
@end example

@noindent
This sets @code{RS} to @samp{/} before processing @file{BBS-list}.

Reaching the end of an input file terminates the current input record,
even if the last character in the file is not the character in @code{RS}.

@ignore
@c merge the preceding paragraph and this stuff into one paragraph
@c and put it in an `expert info' section.
This produces correct behavior in the vast majority of cases, although
the following (extreme) pipeline prints a surprising @samp{1}.  (There
is one field, consisting of a newline.)

@example
echo | awk 'BEGIN @{ RS = "a" @} ; @{ print NF @}'
@end example

@end ignore

The empty string, @code{""} (a string of no characters), has a special meaning
as the value of @code{RS}: it means that records are separated only
by blank lines.  @xref{Multiple Line, ,Multiple-Line Records}, for more details.

@cindex number of records, @code{NR} or @code{FNR}
@vindex NR
@vindex FNR
The @code{awk} utility keeps track of the number of records that have
been read so far from the current input file.  This value is stored in a
built-in variable called @code{FNR}.  It is reset to zero when a new
file is started.  Another built-in variable, @code{NR}, is the total
number of input records read so far from all files.  It starts at zero
but is never automatically reset to