gawk.texi

早期freebsd实现

along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
@end smallexample

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

@smallexample
Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details 
type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
@end smallexample

The hypothetical commands @samp{show w} and @samp{show c} should show
the appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than @samp{show w} and
@samp{show c}; they could even be mouse-clicks or menu items---whatever
suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a ``copyright disclaimer'' for the program, if
necessary.  Here is a sample; alter the names:

@smallexample
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.

@var{signature of Ty Coon}, 1 April 1989
Ty Coon, President of Vice
@end smallexample

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.

@node This Manual, Getting Started, Copying, Top
@chapter Using this Manual
@cindex manual, using this
@cindex using this manual
@cindex language, @code{awk}
@cindex program, @code{awk}
@cindex @code{awk} language
@cindex @code{awk} program

The term @code{awk} refers to a particular program, and to the language you
use to tell this program what to do.  When we need to be careful, we call
the program ``the @code{awk} utility'' and the language ``the @code{awk}
language.''  The term @code{gawk} refers to a version of @code{awk} developed
as part the GNU project.  The purpose of this manual is to explain
both the
@code{awk} language and how to run the @code{awk} utility.@refill

While concentrating on the features of @code{gawk}, the manual will also
attempt to describe important differences between @code{gawk} and other
@code{awk} implementations.  In particular, any features that are not
in the @sc{posix} standard for @code{awk} will be noted.  @refill

The term @dfn{@code{awk} program} refers to a program written by you in
the @code{awk} programming language.@refill

@xref{Getting Started, ,Getting Started with @code{awk}}, for the bare
essentials you need to know to start using @code{awk}.  

Some useful ``one-liners'' are included to give you a feel for the
@code{awk} language (@pxref{One-liners, ,Useful ``One-liners''}).

@ignore
@strong{I deleted four paragraphs here because they would confuse the
beginner more than help him.  They mention terms such as ``field,''
``pattern,'' ``action,'' ``built-in function'' which the beginner
doesn't know.}

@strong{If you can find a way to introduce several of these concepts here,
enough to give the reader a map of what is to follow, that might
be useful.  I'm not sure that can be done without taking up more
space than ought to be used here.  There may be no way to win.}

@strong{ADR: I'd like to tackle this in phase 2 of my editing.}
@end ignore

A sample @code{awk} program has been provided for you
(@pxref{Sample Program}).@refill

If you find terms that you aren't familiar with, try looking them
up in the glossary (@pxref{Glossary}).@refill

The entire @code{awk} language is summarized for quick reference in
@ref{Gawk Summary, ,@code{gawk} Summary}.  Look there if you just need
to refresh your memory about a particular feature.@refill

Most of the time complete @code{awk} programs are used as examples, but in
some of the more advanced sections, only the part of the @code{awk} program
that illustrates the concept being described is shown.@refill

@menu
* Sample Data Files::           Sample data files for use in the @code{awk} 
                                programs illustrated in this manual.
@end menu

@node Sample Data Files,  , This Manual, This Manual
@section Data Files for the Examples

@cindex input file, sample
@cindex sample input file
@cindex @file{BBS-list} file
Many of the examples in this manual take their input from two sample
data files.  The first, called @file{BBS-list}, represents a list of
computer bulletin board systems together with information about those systems.
The second data file, called @file{inventory-shipped}, contains
information about shipments on a monthly basis.  Each line of these
files is one @dfn{record}.

In the file @file{BBS-list}, each record contains the name of a computer
bulletin board, its phone number, the board's baud rate, and a code for
the number of hours it is operational.  An @samp{A} in the last column
means the board operates 24 hours a day.  A @samp{B} in the last
column means the board operates evening and weekend hours, only.  A
@samp{C} means the board operates only on weekends.

@example
aardvark     555-5553     1200/300          B
alpo-net     555-3412     2400/1200/300     A
barfly       555-7685     1200/300          A
bites        555-1675     2400/1200/300     A
camelot      555-0542     300               C
core         555-2912     1200/300          C
fooey        555-1234     2400/1200/300     B
foot         555-6699     1200/300          B
macfoo       555-6480     1200/300          A
sdace        555-3430     2400/1200/300     A
sabafoo      555-2127     1200/300          C
@end example

@cindex @file{inventory-shipped} file
The second data file, called @file{inventory-shipped}, represents
information about shipments during the year.  
Each record contains the month of the year, the number
of green crates shipped, the number of red boxes shipped, the number of
orange bags shipped, and the number of blue packages shipped,
respectively.  There are 16 entries, covering the 12 months of one year
and 4 months of the next year.@refill

@example
Jan  13  25  15 115
Feb  15  32  24 226
Mar  15  24  34 228
Apr  31  52  63 420
May  16  34  29 208
Jun  31  42  75 492
Jul  24  34  67 436
Aug  15  34  47 316
Sep  13  55  37 277
Oct  29  54  68 525
Nov  20  87  82 577
Dec  17  35  61 401

Jan  21  36  64 620
Feb  26  58  80 652
Mar  24  75  70 495
Apr  21  70  74 514
@end example

@ifinfo
If you are reading this in GNU Emacs using Info, you can copy the regions
of text showing these sample files into your own test files.  This way you
can try out the examples shown in the remainder of this document.  You do
this by using the command @kbd{M-x write-region} to copy text from the Info
file into a file for use with @code{awk}
(@xref{Misc File Ops, , , emacs, GNU Emacs Manual},
for more information).  Using this information, create your own
@file{BBS-list} and @file{inventory-shipped} files, and practice what you
learn in this manual.
@end ifinfo

@node Getting Started, Reading Files, This Manual, Top
@chapter Getting Started with @code{awk}
@cindex script, definition of
@cindex rule, definition of
@cindex program, definition of
@cindex basic function of @code{gawk}

The basic function of @code{awk} is to search files for lines (or other
units of text) that contain certain patterns.  When a line matches one
of the patterns, @code{awk} performs specified actions on that line.
@code{awk} keeps processing input lines in this way until the end of the
input file is reached.@refill

When you run @code{awk}, you specify an @code{awk} @dfn{program} which
tells @code{awk} what to do.  The program consists of a series of
@dfn{rules}.  (It may also contain @dfn{function definitions}, but that
is an advanced feature, so we will ignore it for now.
@xref{User-defined, ,User-defined Functions}.)  Each rule specifies one
pattern to search for, and one action to perform when that pattern is found.

Syntactically, a rule consists of a pattern followed by an action.  The
action is enclosed in curly braces to separate it from the pattern.
Rules are usually separated by newlines.  Therefore, an @code{awk}
program looks like this:

@example
@var{pattern} @{ @var{action} @}
@var{pattern} @{ @var{action} @}
@dots{}
@end example

@menu
* Very Simple::                 A very simple example.
* Two Rules::                   A less simple one-line example with two rules.
* More Complex::                A more complex example.
* Running gawk::                How to run @code{gawk} programs; 
                                includes command line syntax.
* Comments::                    Adding documentation to @code{gawk} programs.
* Statements/Lines::            Subdividing or combining statements into lines.
* When::                        When to use @code{gawk} and 
                                when to use other things.
@end menu

@node Very Simple, Two Rules, Getting Started, Getting Started
@section A Very Simple Example

@cindex @samp{print $0}
The following command runs a simple @code{awk} program that searches the
input file @file{BBS-list} for the string of characters: @samp{foo}.  (A
string of characters is usually called, a @dfn{string}.
The term @dfn{string} is perhaps based on similar usage in English, such
as ``a string of pearls,'' or, ``a string of cars in a train.'')

@example
awk '/foo/ @{ print $0 @}' BBS-list
@end example

@noindent
When lines containing @samp{foo} are found, they are printed, because
@w{@samp{print $0}} means print the current line.  (Just @samp{print} by
itself means the same thing, so we could have written that
instead.)

You will notice that slashes, @samp{/}, surround the string @samp{foo}
in the actual @code{awk} program.  The slashes indicate that @samp{foo}
is a pattern to search for.  This type of pattern is called a
@dfn{regular expression}, and is covered in more detail later
(@pxref{Regexp, ,Regular Expressions as Patterns}).  There are
single-quotes around the @code{awk} program so that the shell won't
interpret any of it as special shell characters.@refill

Here is what this program prints:

@example
@group
fooey        555-1234     2400/1200/300     B
foot         555-6699     1200/300          B
macfoo       555-6480     1200/300          A
sabafoo      555-2127     1200/300          C
@end group
@end example

@cindex action, default
@cindex pattern, default
@cindex default action
@cindex default pattern
In an @code{awk} rule, either the pattern or the action can be omitted,
but not both.  If the pattern is omitted, then the action is performed
for @emph{every} input line.  If the action is omitted, the default
action is to print all lines that match the pattern.

Thus, we could leave out the action (the @code{print} statement and the curly
braces) in the above example, and the result would be the same: all
lines matching the pattern @samp{foo} would be printed.  By comparison,
omitting the @code{print} statement but retaining the curly braces makes an
empty action that does nothing; then no lines would be printed.

@node Two Rules, More Complex, Very Simple, Getting Started
@section An Example with Two Rules
@cindex how @code{awk} works

The @code{awk} utility reads the input files one line at a
time.  For each line, @code{awk} tries the patterns of each of the rules.
If several patterns match then several actions are run, in the order in
which they appear in the @code{awk} program.  If no patterns match, then
no actions are run.

After processing all the rules (perhaps none) that match the line,
@code{awk} reads the next line (however,
@pxref{Next Statement, ,The @code{next} Statement}).  This continues
until the end of the file is reached.@refill

For example, the @code{awk} program:

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

@noindent
contains two rules.  The first rule has the string @samp{12} as the
pattern and @samp{print $0} as the action.  The second rule has the
string @samp{21} as the pattern and also has @samp{print $0} as the
action.  Each rule's action is enclosed in its own pair of braces.

This @code{awk} program prints every line that contains the string
@samp{12} @emph{or} the string @samp{21}.  If a line contains both
strings, it is printed twice, once by each rule.

If we run this program on our two sample data files, @file{BBS-list} and
@file{inventory-shipped}, as shown here:

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