gawk.texi

早期freebsd实现

@end example

@noindent
we get the following output:

@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
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
sabafoo      555-2127     1200/300          C
Jan  21  36  64 620
Apr  21  70  74 514
@end example

@noindent
Note how the line in @file{BBS-list} beginning with @samp{sabafoo}
was printed twice, once for each rule.

@node More Complex, Running gawk, Two Rules, Getting Started
@comment  node-name,  next,  previous,  up
@section A More Complex Example

Here is an example to give you an idea of what typical @code{awk}
programs do.  This example shows how @code{awk} can be used to
summarize, select, and rearrange the output of another utility.  It uses
features that haven't been covered yet, so don't worry if you don't
understand all the details.

@example
ls -l | awk '$5 == "Nov" @{ sum += $4 @}
             END @{ print sum @}'
@end example

This command prints the total number of bytes in all the files in the
current directory that were last modified in November (of any year).
(In the C shell you would need to type a semicolon and then a backslash
at the end of the first line; in a @sc{posix}-compliant shell, such as the
Bourne shell or the Bourne-Again shell, you can type the example as shown.)

The @w{@samp{ls -l}} part of this example is a command that gives you a 
listing of the files in a directory, including file size and date.
Its output looks like this:@refill

@example
-rw-r--r--  1 close        1933 Nov  7 13:05 Makefile
-rw-r--r--  1 close       10809 Nov  7 13:03 gawk.h
-rw-r--r--  1 close         983 Apr 13 12:14 gawk.tab.h
-rw-r--r--  1 close       31869 Jun 15 12:20 gawk.y
-rw-r--r--  1 close       22414 Nov  7 13:03 gawk1.c
-rw-r--r--  1 close       37455 Nov  7 13:03 gawk2.c
-rw-r--r--  1 close       27511 Dec  9 13:07 gawk3.c
-rw-r--r--  1 close        7989 Nov  7 13:03 gawk4.c
@end example

@noindent
The first field contains read-write permissions, the second field contains
the number of links to the file, and the third field identifies the owner of
the file.  The fourth field contains the size of the file in bytes.  The
fifth, sixth, and seventh fields contain the month, day, and time,
respectively, that the file was last modified.  Finally, the eighth field
contains the name of the file.

The @code{$5 == "Nov"} in our @code{awk} program is an expression that
tests whether the fifth field of the output from @w{@samp{ls -l}}
matches the string @samp{Nov}.  Each time a line has the string
@samp{Nov} in its fifth field, the action @samp{@{ sum += $4 @}} is
performed.  This adds the fourth field (the file size) to the variable
@code{sum}.  As a result, when @code{awk} has finished reading all the
input lines, @code{sum} is the sum of the sizes of files whose
lines matched the pattern.  (This works because @code{awk} variables
are automatically initialized to zero.)@refill

After the last line of output from @code{ls} has been processed, the
@code{END} rule is executed, and the value of @code{sum} is
printed.  In this example, the value of @code{sum} would be 80600.@refill

These more advanced @code{awk} techniques are covered in later sections
(@pxref{Actions, ,Overview of Actions}).  Before you can move on to more
advanced @code{awk} programming, you have to know how @code{awk} interprets
your input and displays your output.  By manipulating fields and using
@code{print} statements, you can produce some very useful and spectacular
looking reports.@refill

@node Running gawk, Comments, More Complex, Getting Started
@section How to Run @code{awk} Programs

@ignore
Date: Mon, 26 Aug 91 09:48:10 +0200
From: gatech!vsoc07.cern.ch!matheys (Jean-Pol Matheys (CERN - ECP Division))
To: uunet.UU.NET!skeeve!arnold
Subject: RE: status check

The introduction of Chapter 2 (i.e. before 2.1) should include
the whole of section 2.4  -  it's better to tell people how to run awk programs
before giving any examples

ADR --- he's right.  but for now, don't do this because the rest of the
chapter would need some rewriting.
@end ignore

@cindex command line formats
@cindex running @code{awk} programs
There are several ways to run an @code{awk} program.  If the program is
short, it is easiest to include it in the command that runs @code{awk},
like this:

@example
awk '@var{program}' @var{input-file1} @var{input-file2} @dots{}
@end example

@noindent
where @var{program} consists of a series of patterns and actions, as
described earlier.

When the program is long, it is usually more convenient to put it in a file
and run it with a command like this:

@example
awk -f @var{program-file} @var{input-file1} @var{input-file2} @dots{}
@end example

@menu
* One-shot::                    Running a short throw-away @code{awk} program.
* Read Terminal::               Using no input files (input from 
                                terminal instead).
* Long::                        Putting permanent @code{awk} programs in files.
* Executable Scripts::          Making self-contained @code{awk} programs.
@end menu

@node One-shot, Read Terminal, Running gawk, Running gawk
@subsection One-shot Throw-away @code{awk} Programs

Once you are familiar with @code{awk}, you will often type simple
programs at the moment you want to use them.  Then you can write the
program as the first argument of the @code{awk} command, like this:

@example
awk '@var{program}' @var{input-file1} @var{input-file2} @dots{}
@end example

@noindent
where @var{program} consists of a series of @var{patterns} and
@var{actions}, as described earlier.

@cindex single quotes, why needed
This command format instructs the shell to start @code{awk} and use the
@var{program} to process records in the input file(s).  There are single
quotes around @var{program} so that the shell doesn't interpret any
@code{awk} characters as special shell characters.  They also cause the
shell to treat all of @var{program} as a single argument for
@code{awk} and allow @var{program} to be more than one line long.@refill

This format is also useful for running short or medium-sized @code{awk}
programs from shell scripts, because it avoids the need for a separate
file for the @code{awk} program.  A self-contained shell script is more
reliable since there are no other files to misplace.

@node Read Terminal, Long, One-shot, Running gawk
@subsection Running @code{awk} without Input Files

@cindex standard input
@cindex input, standard
You can also run @code{awk} without any input files.  If you type the
command line:@refill

@example
awk '@var{program}'
@end example

@noindent
then @code{awk} applies the @var{program} to the @dfn{standard input},
which usually means whatever you type on the terminal.  This continues
until you indicate end-of-file by typing @kbd{Control-d}.

For example, if you execute this command:

@example
awk '/th/'
@end example

@noindent
whatever you type next is taken as data for that @code{awk}
program.  If you go on to type the following data:

@example
Kathy
Ben
Tom
Beth
Seth
Karen
Thomas
@kbd{Control-d}
@end example

@noindent
then @code{awk} prints this output:

@example
Kathy
Beth
Seth
@end example

@noindent
@cindex case sensitivity
@cindex pattern, case sensitive
as matching the pattern @samp{th}.  Notice that it did not recognize
@samp{Thomas} as matching the pattern.  The @code{awk} language is
@dfn{case sensitive}, and matches patterns exactly.  (However, you can
override this with the variable @code{IGNORECASE}.
@xref{Case-sensitivity, ,Case-sensitivity in Matching}.)

@node Long, Executable Scripts, Read Terminal, Running gawk
@subsection Running Long Programs

@cindex running long programs
@cindex @samp{-f} option
@cindex program file
@cindex file, @code{awk} program
Sometimes your @code{awk} programs can be very long.  In this case it is
more convenient to put the program into a separate file.  To tell
@code{awk} to use that file for its program, you type:@refill

@example
awk -f @var{source-file} @var{input-file1} @var{input-file2} @dots{}
@end example

The @samp{-f} instructs the @code{awk} utility to get the @code{awk} program
from the file @var{source-file}.  Any file name can be used for
@var{source-file}.  For example, you could put the program:@refill

@example
/th/
@end example

@noindent
into the file @file{th-prog}.  Then this command:

@example
awk -f th-prog
@end example

@noindent
does the same thing as this one:

@example
awk '/th/'
@end example

@noindent
which was explained earlier (@pxref{Read Terminal, ,Running @code{awk} without Input Files}).
Note that you don't usually need single quotes around the file name that you
specify with @samp{-f}, because most file names don't contain any of the shell's
special characters.  Notice that in @file{th-prog}, the @code{awk}
program did not have single quotes around it.  The quotes are only needed
for programs that are provided on the @code{awk} command line.

If you want to identify your @code{awk} program files clearly as such,
you can add the extension @file{.awk} to the file name.  This doesn't
affect the execution of the @code{awk} program, but it does make
``housekeeping'' easier.

@node Executable Scripts,  , Long, Running gawk
@c node-name, next, previous, up
@subsection Executable @code{awk} Programs
@cindex executable scripts
@cindex scripts, executable
@cindex self contained programs
@cindex program, self contained
@cindex @samp{#!}

Once you have learned @code{awk}, you may want to write self-contained
@code{awk} scripts, using the @samp{#!} script mechanism.  You can do
this on many Unix systems @footnote{The @samp{#!} mechanism works on
Unix systems derived from Berkeley Unix, System V Release 4, and some System
V Release 3 systems.} (and someday on GNU).@refill

For example, you could create a text file named @file{hello}, containing
the following (where @samp{BEGIN} is a feature we have not yet
discussed):

@example
#! /bin/awk -f

# a sample awk program
BEGIN    @{ print "hello, world" @}
@end example

@noindent
After making this file executable (with the @code{chmod} command), you
can simply type:

@example
hello
@end example

@noindent
at the shell, and the system will arrange to run @code{awk} @footnote{The
line beginning with @samp{#!} lists the full pathname of an interpreter
to be run, and an optional initial command line argument to pass to that
interpreter.  The operating system then runs the interpreter with the given
argument and the full argument list of the executed program.  The first argument
in the list is the full pathname of the @code{awk} program.  The rest of the
argument list will either be options to @code{awk}, or data files,
or both.} as if you had typed:@refill

@example