[Index]

General Introduction

This file documents awk, a program that you can use to select particular records in a file and perform operations upon them.

This is Edition 3 of GAWK: Effective AWK Programming: GNU Awkのためのユーザーズガイド, for the 3.1.5 (or later) version of the GNU implementation of AWK.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the Invariant Sections being "GNU General Public License", the Front-Cover texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the section entitled "GNU Free Documentation License".

"A GNU Manual"
"You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development."


序文		Some nice words about this Web ページ.
前書き		What this Web ページ is about; 簡単な歴史と謝辞
1. Getting Started with `awk`		A basic introduction to using `awk`. `awk`プログラムの実行の仕方。コマンドラインの構文。
2. 正規表現
3. 入力ファイルを読む
4. Printing Output		`awk` を使ったプリントの仕方。 `print` 文と `printf` 文の説明。同様に出力のリダイレクションの説明。
5. 式
6. パターン、アクション、変数
7. `awk` における配列		配列の説明と使用。配列指向の制御文を含む。
8. 関数
9. `gawk`の国際化
10. `gawk` の高度な機能
11. Running `awk` and `gawk`		`gawk`をどのように実行するか。
12. A Library of `awk` 関数		`awk` 関数のライブラリ。
13. Practical `awk` Programs		Many `awk` programs with complete explanations.
A. `awk` 言語の進化
B. Installing `gawk`		さまざまなオペレーティングシステムでの `gawk`のインストール。
C. Implementation Notes		`gawk` の拡張や将来に向けての作業に関するノート。
D. Basic Programming Concepts		A very quick intoduction to programming concepts.
用語集
GNU General Public License		`gawk` をコピーしたり配布したりするあなたの権利。
GNU 一般公衆利用許諾契約書		Copyingの日本語訳
GNU Free Documentation License		このWeb ページのライセンス。
GNU フリー文書利用許諾契約書		ライセンスの日本語訳。
Index		Concept and Variable Index.
`awk` と `gawk` の歴史		`gawk` と `awk` の歴史。
0.1 A Rose by Any Other Name		What name to use to find `awk`.
0.2 この本を使う		Using this Web ページ. Includes sample input files that you can use.
0.3 Typographical Conventions
GNU プロジェクトとこの本		GNU プロジェクトとこの Web ページの簡単な歴史。
貢献の仕方
謝辞
1.1 `awk` プログラムの実行の仕方		コマンドライン構文を含めた `gawk` プログラムの実行の仕方。
1.1.1 使い捨ての一発`awk`プログラム
1.1.2 `awk` を入力ファイルなしで実行する		入力ファイルを使わない (代わりに端末から入力する)。
1.1.3 長いプログラムを実行する		恒久的な `awk`プログラムをファイルにする。
1.1.4 実行可能な `awk` プログラム		Making self-contained `awk` programs.
1.1.5 `awk` プログラム中のコメント		`gawk` プログラムにドキュメントを付加する。
1.1.6 シェルのクォーティングについて		More discussion of shell quoting issues.
1.2 例のためのデータファイル		Sample data files for use in the `awk` programs illustrated in this Web ページ.
1.3 幾つかの単純な例
1.4 二つのルールの例
1.5 より複雑な例
1.6 `awk` Statements Versus Lines		Subdividing or combining statements into lines.
1.7 `awk` のその他の機能
1.8 `awk` を使うとき		When to use `gawk` and when to use other things.
2.1 正規表現の使い方
2.2 エスケープシーケンス
2.3 正規表現演算子
2.4 キャラクタリストの使用		What can go between `[...]'.
2.5 `gawk`固有の正規表現演算子		GNUソフトウェアに固有の演算子。
2.6 Case Sensitivity in Matching		大小文字を無視したマッチングをどう行うか。
2.7 どのくらいテキストがマッチするか?
2.8 動的正規表現を使う
2.9 Where You Are Makes A Difference		ロカールがどのように影響するか。
3.1 入力がどのようにレコードに分割されるか
3.2 フィールドを検査する
3.3 定数でないフィールド番号
3.4 フィールドの内容を変更する
3.5 フィールドがどのように分割されるかを特定する
3.5.1 フィールド分割のために正規表現を使う
3.5.2 ここのキャラクタを別個のフィールドにする
3.5.3 コマンドラインから `FS` を設定する
3.5.4 フィールド分割のまとめ		Some final points and a summary table.
3.6 固定長データを読む
3.7 複数行レコード
3.8 `getline`を使った入力		Reading files under explicit program control using the `getline` function.
3.8.1 引数なしで `getline` を使う
3.8.2 変数に`getline`の結果を格納する
3.8.3 `getline`を使ったファイルからの入力
3.8.4 `getline`を使ってファイルから変数へ格納
3.8.5 Using `getline` from a Pipe		パイプからの `getline` を使う。
3.8.7 Using `getline` into a Variable from a Pipe		パイプから読み込み変数に代入する `getline` を使う。
3.8.9 `getline` を使ってコプロセスから入力する
3.8.10 `getline`を使ってコプロセスから変数に格納する
3.8.11 Points to Remember About `getline`		`getline` に関して知っておくべき重要なこと
3.8.13 `getline` の変種のまとめ
4.1 `print` 文
4.2 `print` 文の例
4.3 出力セパレータ
4.4 `print`の数値出力を制御する
4.5 `printf`を使って出力を整える
4.5.1 Introduction to the `printf` Statement		`printf` 文の構文。
4.5.2 書式制御文字
4.5.3 `printf` の書式の修飾子		書式修飾子。
4.5.4 `printf` を使った例		いくつかの例。
4.6 `print` や `printf`の出力のリダイレクト		複数のファイルやパイプへの出力をどのようにリダイレクトするか。
4.7 `gawk` における特殊なファイル名		`gawk` に解釈される名前。 `gawk` は継承したファイル記述子へのアクセスを許可する。
4.7.1 標準ディスクリプタのためのスペシャルファイル
4.7.2 プロセスに関連した情報のためのスペシャルファイル
4.7.3 スペシャルファイル for Network Communications		ネットワークコミュニケーションのためのスペシャルファイル。
4.7.4 Special ファイル名 Caveats		気をつけるべきこと。
4.8 入出力のリダイレクトをクローズする
5.1 定数式
5.1.1 数値定数と文字列定数
5.1.2 八進数字および十六進数字
5.1.3 正規表現定数
5.2 正規表現定数を使う
5.3 変数
5.3.1 プログラム中での変数の使用
5.3.2 コマンドライン上で変数に代入する		Setting variables on the command-line and a summary of command-line syntax. This is an advanced method of input.
5.4 文字列と数値の変換
5.5 数学的演算子		数学的操作 (`+', `-', etc.)
5.6 文字列連接
5.7 代入式
5.8 インクリメント/デクリメント演算子
5.9 `awk` における真と偽		"true"とは何か、また、"false"とは何か。
5.10 変数の型付けと比較式		How variables acquire types and how this affects comparison of numbers and strings with `<', etc.
5.11 ブール式		ブール演算子 `\|\|' ("または")、 `&&' ("かつ")、`!' ("でない") を使って比較式を組み合わせる。
5.12 条件式		Conditional expressions select between two subexpressions under control of a third subexpression.
5.13 関数呼び出し
5.14 演算子の優先順位 (How Operators Nest)		様々な演算子をどのようにネストするか。
6.1 パターンの要素		What goes into a pattern.
6.1.1 パターンとしての正規表現
6.1.2 パターンとしての式
6.1.3 パターンを使ってレコードの範囲を指定する
6.1.4 特殊パターン `BEGIN` と `END`		初期化と終了処理のルールを指定する。
6.1.4.1 スタートアップとクリーンアップのアクション		どのように、またなぜBEGIN/END ルールを使うのか。
6.1.4.2 `BEGIN`/`END`ルールでの入出力		BEGIN/END ルール中の入出力に関して。
6.1.5 空パターン
6.2 プログラム中でシェル変数を使う		`awk` でのシェル変数の使い方。
6.3 アクション		What goes into an action.
6.4 アクション中の制御文
6.4.1 `if`-`else` 文		幾つかの `awk` 文を条件次第で実行する。
6.4.2 The `while` Statement		ある条件が満足されるまでループする。
6.4.3 `do`-`while` 文		ある条件が満足されるまで特定のアクションを実行する。
6.4.4 `for` 文		もうひとつのループ文で、初期化部分とインクリメント部分を持つ。
6.4.5 `switch` 文		値に基づいて文の実行を振り分ける。
6.4.6 `break` 文		最も内側のループから脱出する。
6.4.7 `continue` 文		最も内側のループの終端にスキップする。
6.4.8 `next` 文		カレントの入力レコードの処理を止める。
6.4.9 Using `gawk`'s `nextfile` Statement		カレントファイルの処理を止める。
6.4.10 `exit` 文		`awk` の実行を停止する。
6.5 組み込み変数
6.5.1 `awk`を制御する組み込み変数		組み込み変数 that you change to control `awk`.
6.5.2 情報を伝達する組み込み変数		組み込み変数 where `awk` gives you information.
6.5.3 `ARGC` と `ARGV` を使う
7.1 配列の序論
7.2 配列要素への参照
7.3 配列要素の代入
7.4 基本的な配列の例
7.5 配列の全要素を走査する		A variation of the `for` statement. It loops through the indices of an array's existing elements.
7.6 `delete` 文		The `delete` statement removes an element from an array.
7.7 配列の添え字として数値を使う		`awk` での添え字として数値をどう使うか。
7.8 添え字として初期化されていない変数を使う
7.9 多次元配列		`awk`で多次元配列をエミュレートする。
7.10 多次元配列の走査
7.11 `gawk` で配列の値や添え字をソートする		配列の値や添え字をソートする。
8.1 組み込み関数
8.1.1 組み込み関数を呼び出す
8.1.2 数値関数		関数 that work with numbers, including `int`, `sin` and `rand`.
8.1.3 文字列操作関数		`split`, `match`, `sprintf`のような文字列操作関数。
8.1.3.1 More About `\' and `&' with `sub`, `gsub`, and `gensub`		More than you want to know about `\' and `&' with `sub`, `gsub`, and `gensub`.
8.1.4 Input/Output 関数		ファイルやシェルコマンドのための関数。
8.1.5 Using `gawk`'s Timestamp 関数		タイムスタンプを扱うための関数。
8.1.6 `gawk` のビット操作関数		ビット演算のための関数。
8.1.7 `gawk`の文字列翻訳関数を使う		文字列の翻訳のための関数。
8.2 ユーザー定義関数
8.2.1 関数定義の構文
8.2.2 関数定義の例
8.2.3 ユーザー定義関数の呼び出し
8.2.4 `return` 文		関数が返す値を指定する。
8.2.5 変数の型付けに関する関数とその効果
9.1 国際化と地域化
9.2 GNU `gettext`
9.3 `awk` プログラムの国際化		プログラマのための機能。
9.4 Translating `awk` Programs		翻訳者のための機能。
9.4.1 印付けされた文字列の抽出
9.4.2 Rearranging `printf` Arguments		`printf` の引数を再アレンジする。
9.4.3 `awk` Portability Issues		`awk`-level portability issues.
9.5 単純な国際化の例		単純な i18n の例。
9.6 `gawk` Can Speak Your Language		`gawk` is also internationalized.
10.1 十進でない入力データを許す
10.2 Two-Way Communications with Another Process		別プロセスとの双方向通信。
10.3 Using `gawk` for Network Programming		ネットワークプログラミングに `gawk` を使う。
10.4 Using `gawk` with BSD Portals		Using `gawk` with BSD portals.
10.5 `awk` プログラムをプロファイリングする
11.1 `awk`を起動する
11.2 コマンドラインオプション
11.3 その他のコマンドライン引数
11.4 `AWKPATH` 環境変数		`awk`プログラムを探すディレクトリ。
11.5 なくなったオプションと機能
11.6 ドキュメント化されていないオプションと機能
11.7 `gawk`の既知のバグ
12.1 ライブラリ関数にグローバルな変数に対する命名		ライブラリ関数中のプライベート変数やグローバル変数の良い名前の付け方。 in library functions.
12.2 一般的なプログラミング
12.2.1 `nextfile` の関数としての実装
12.2.3 表明(Assertion)		`awk` プログラム中で表明を行うための関数。
12.2.4 数値の丸め		`sprintf` が正しく丸めを行わない場合に丸めを行う関数。
12.2.5 Cliff の乱数生成器
12.2.6 キャラクタと数値の間での変換
12.2.7 配列を文字列へとマージする
12.2.8 Managing the Time of Day		書式付けされた時間を得るための関数。
12.3 データファイルの管理
12.3.1 Noting データファイル Boundaries		A function for handling data file transitions.
12.3.2 カレントファイルを再読み込みする
12.3.3 読み込み可能なデータファイルのチェック
12.3.4 長さゼロのファイルをチェックする
12.3.5 ファイル名として代入を扱う
12.4 コマンドラインオプションを処理する
12.5 Reading the User Database		ユーザー情報を取得するための関数。
12.6 Reading the Group Database		グループ情報を取得するための関数。
13.1 例示されたプログラムを実行する
13.2 Reinventing Wheels for Fun and Profit		一般的なユーティリティのクローン。
13.2.1 フィールドとカラムを切り出す		`cut` ユーティリティ。
13.2.2 ファイルの中で正規表現を探す		`egrep` ユーティリティ。
13.2.3 Printing out User Information		`id` ユーティリティ。
13.2.4 Splitting a Large File into Pieces		`split` ユーティリティ。
13.2.5 Duplicating Output into Multiple Files		`tee` ユーティリティ。
13.2.6 Printing Nonduplicated Lines of Text		`uniq` ユーティリティ。
13.2.7 Counting Things		`wc` ユーティリティ。
13.3 A Grab Bag of `awk` Programs		幾つかの興味深い `awk` プログラム。
13.3.1 ドキュメント中の重複した単語を探し出す
13.3.2 アラーム時計プログラム
13.3.3 キャラクタの変換		`tr` ユーティリティに似たプログラム。
13.3.4 メイルのラベルを出力する
13.3.5 Generating Word-Usage Counts		単語の使用頻度を生成するプログラム。
13.3.6 ソートされていないテキストから重複したものを取り除く
13.3.7 Texinfo のソースファイルからプログラムを取り出す
13.3.8 単純なストリームエディタ
13.3.9 An Easy Way to Use ライブラリ関数		ファイルを取り込む `awk` のラッパー。
A.1 Major Changes Between V7 and SVR3.1		V7 と System V Release 3.1 の間での大きな変更。
A.2 SVR3.1 と SVR4 の間の変更		System V Release 3.1 と 4の間での小さな変更。
A.3 SVR4 と POSIX `awk` の間での変更		POSIX 標準からの新たな機能
A.4 Extensions in the Bell Laboratories `awk`		ベル研バージョンの`awk`からの新たな機能。
A.5 POSIXの `awk` にない `gawk`の拡張
A.6 `gawk` に対する主要な貢献者たち
B.1 The `gawk` Distribution		What is in the `gawk` distribution.
B.1.1 Getting the `gawk` Distribution		配布物の入手の方法。
B.1.2 Extracting the Distribution		配布物の展開の方法。
B.1.3 Contents of the `gawk` Distribution		配布物の中にあるもの。
B.2 Compiling and Installing `gawk` on Unix		Installing `gawk` under various versions of Unix.
B.2.1 Compiling `gawk` for Unix		Compiling `gawk` under Unix.
B.2.2 付加的なコンフィグレーションオプション
B.2.3 The Configuration Process		How it's all supposed to work.
B.3 インストール on Other Operating Systems
B.3.1 Installing `gawk` on an Amiga
B.3.2 Installing `gawk` on BeOS
B.3.3 インストール on PC Operating Systems		Installing and Compiling `gawk` on MS-DOS and OS/2.
B.3.3.1 Installing a Prepared Distribution for PC Systems		Installing a prepared distribution.
B.3.3.2 Compiling `gawk` for PC Operating Systems		Compiling `gawk` for MS-DOS, Windows32, and OS/2.
B.3.3.4 Using `gawk` on PC Operating Systems		Running `gawk` on MS-DOS, Windows32 and OS/2.
B.3.3.3 Compiling `gawk` For Dynamic Libraries		Compiling `gawk` for dynamic libraries.
B.3.3.5 Cygwin 環境における `gawk` の使用		Building and running `gawk` for Cygwin.
B.3.4 VMS での `gawk` のコンパイルとインストール		Installing `gawk` on VMS.
B.3.4.1 Compiling `gawk` on VMS		How to compile `gawk` under VMS.
B.3.4.2 VMS に `gawk`をインストールする		How to install `gawk` under VMS.
B.3.4.3 Running `gawk` on VMS		How to run `gawk` under VMS.
B.3.4.4 Building and Using `gawk` on VMS POSIX		Alternate instructions for VMS POSIX.
B.4 Unsupported Operating System Ports		Systems whose ports are no longer supported.
B.4.1 Installing `gawk` on the Atari ST
B.4.1.1 Compiling `gawk` on the Atari ST		Compiling `gawk` on Atari.
B.4.1.2 Running `gawk` on the Atari ST		Running `gawk` on Atari.
B.4.2 Installing `gawk` on a Tandem
B.5 問題点やバグを報告する
B.6 他の自由に入手することのできる `awk` 処理系
C.1 Downward Compatibility and Debugging		`gawk` の拡張機能の禁止の仕方。
C.2 Making Additions to `gawk`		Making Additions To `gawk`.
C.2.1 Adding New Features		Adding code to the main body of `gawk`.
C.2.2 Porting `gawk` to a New Operating System		Porting `gawk` to a new operating system.
C.3 新たな組み込み関数を`gawk`に追加する
C.3.1 A Minimal Introduction to `gawk` Internals		A brief look at some `gawk` internals.
C.3.2 Directory and File Operation Built-ins		新たな関数の例。
C.3.2.1 Using `chdir` and `stat`		新たな関数が行うこと。
C.3.2.2 C Code for `chdir` and `stat`		内部的なファイル操作のためのコード。
C.3.2.3 Integrating the Extensions		外部拡張の使い方。
C.4 Probable Future Extensions		いつの日か実装されるかもしれない新たな機能。
D.1 What a Program Does		The high level view.
D.2 Data Values in a Computer		A very quick intro to data types.
D.3 浮動小数点数に関する警告

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

序文

Arnold Robbins and I are good friends. We were introduced 11 years ago by circumstances--and our favorite programming language, AWK. The circumstances started a couple of years earlier. I was working at a new job and noticed an unplugged Unix computer sitting in the corner. No one knew how to use it, and neither did I. However, a couple of days later it was running, and I was root and the one-and-only user. That day, I began the transition from statistician to Unix programmer.

On one of many trips to the library or bookstore in search of books on Unix, I found the gray AWK book, a.k.a. Aho, Kernighan and Weinberger, The AWK Programming Language, Addison-Wesley, 1988. AWK's simple programming paradigm--find a pattern in the input and then perform an action--often reduced complex or tedious data manipulations to few lines of code. I was excited to try my hand at programming in AWK.

Alas, the awk on my computer was a limited version of the language described in the AWK book. I discovered that my computer had "old awk" and the AWK book described "new awk." I learned that this was typical; the old version refused to step aside or relinquish its name. If a system had a new awk, it was invariably called nawk, and few systems had it. The best way to get a new awk was to ftp the source code for gawk from prep.ai.mit.edu. gawk was a version of new awk written by David Trueman and Arnold, and available under the GNU General Public License.

(Incidentally, it's no longer difficult to find a new awk. gawk ships with Linux, and you can download binaries or source code for almost any system; my wife uses gawk on her VMS box.)

My Unix system started out unplugged from the wall; it certainly was not plugged into a network. So, oblivious to the existence of gawk and the Unix community in general, and desiring a new awk, I wrote my own, called mawk. Before I was finished I knew about gawk, but it was too late to stop, so I eventually posted to a comp.sources newsgroup.

A few days after my posting, I got a friendly email from Arnold introducing himself. He suggested we share design and algorithms and attached a draft of the POSIX standard so that I could update mawk to support language extensions added after publication of the AWK book.

Frankly, if our roles had been reversed, I would not have been so open and we probably would have never met. I'm glad we did meet. He is an AWK expert's AWK expert and a genuinely nice person. Arnold contributes significant amounts of his expertise and time to the Free Software Foundation.

This book is the gawk reference manual, but at its core it is a book about AWK programming that will appeal to a wide audience. It is a definitive reference to the AWK language as defined by the 1987 Bell Labs release and codified in the 1992 POSIX Utilities standard.

On the other hand, the novice AWK programmer can study a wealth of practical programs that emphasize the power of AWK's basic idioms: data driven control-flow, pattern matching with regular expressions, and associative arrays. Those looking for something new can try out gawk's interface to network protocols via special `/inet' files.

The programs in this book make clear that an AWK program is typically much smaller and faster to develop than a counterpart written in C. Consequently, there is often a payoff to prototype an algorithm or design in AWK to get it running quickly and expose problems early. Often, the interpreted performance is adequate and the AWK prototype becomes the product.

The new pgawk (profiling gawk), produces program execution counts. I recently experimented with an algorithm that for n lines of input, exhibited ~ C n^2 performance, while theory predicted ~ C n log n behavior. A few minutes poring over the `awkprof.out' profile pinpointed the problem to a single line of code. pgawk is a welcome addition to my programmer's toolbox.

Arnold has distilled over a decade of experience writing and using AWK programs, and developing gawk, into this book. If you use AWK or want to learn how, then read this book.

Michael Brennan
Author of mawk

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

前書き

幾つかの種類のタスクはテキストファイルを処理するときに繰り返し現れる。あなたは特定の行を取り出して残りを捨てたいと考えるかもしれない。あるいは特定のパターンが現れたところでは変更を行うようにしたいが残りはそのままにしておきたいと考えるかもしれない。これらのタスク行うためにをCやC++、Pascalのような言語で専用のプログラムを記述することは時間を浪費するし非効率である。このような仕事はawkでは簡単にできる。 awkユーティリティは単純なデータの再フォーマットのような仕事を簡単に扱うことのできる特殊用途プログラミング言語を解釈する。

GNU の実装による awk はgawk と呼ばれ、 System V Release 4 version の awk に対して完全上位コンパチブルである。 gawk はまた、POSIX の定めた awk 言語の規定に対しても上位互換である。これは、きちんと書かれたawk のプログラムは gawkでも動作する。ということである。したがって、このマニュアルでは gawk と他の awkとの実装上の違いを述べるようなことはしない。

awkを使ってできることは:

小さく個人的なデータベースの管理
レポートの生成
データの検証
インデクスの作成と他のドキュメントのための準備
後で他のコンピュータ言語で適用できるアルゴリズムの検査

それに加えて、gawkは以下のようなことも簡単にできる機能を提供している:

処理のためにビットやデータの一部を取り出す
データのソート
単純なネットワーク通信

このWeb ページではawk言語そのものについてと、その効果的な使い方を教えるものである。 catやls(1) のような基本的なシステムコマンドや、入出力リダイレクトやパイプのような基本的なシェルの機能ついて慣れ親しんでいたほうがよい。

awk言語の処理系は多くの異なる環境において使用可能である。このWeb ページでは一般にawk言語全般についての説明を行い、同様に gawk(which stands for "GNU Awk") と呼ばれるある特定のawkの実装についての説明を行う。 gawkは多くのUNIXシステム、 - 下は80386 搭載のPCベースのコンピュータから、上はCrayのような大きなシステムにいたるまで - で稼動している。 gawkはまたMac OS Xや、MS-DOSやOS/2が動作するPC、Atari、 Amigaなどのマイクロコンピュータ、BeOS、Tandem D20、そしてVMSにも移植されている。

`awk` と `gawk` の歴史		`gawk` と `awk` の歴史
0.1 A Rose by Any Other Name		What name to use to find `awk`.
0.2 この本を使う		Using this Web ページ. Includes sample input files that you can use.
0.3 Typographical Conventions
GNU プロジェクトとこの本		GNU プロジェクトとこの Web ページの簡単な歴史。
貢献の仕方
謝辞

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

`awk` と `gawk` の歴史

Recipe For A Programming Language

	1 part `egrep`	1 part `snobol`
	2 parts `ed`	3 parts C

Blend all parts well using lex and yacc. Document minimally and release.

After eight years, add another part egrep and two more parts C. Document very well and release.

awkの名前はその開発者達の名前、Alfred V. Aho, Peter J. Weinberger そして Brian W. Kernighanから来ているものである。 awk のオリジナルバージョンは1977年にAT&Tのベル研究所で開発された。 1985年にはユーザー定義関数、複数の入力ストリーム、動的正規表現の導入によってより強力なプログラミング言語となったバージョンが開発された。この新しいバージョンは一般的には UNIX System V Release 3.1で使えるようになった。 System V Release 4での新 awk では幾つかの新しい機能追加と、言語の"暗い隅"をきれいにする作業が行われた。 POSIXのコマンド言語およびユーティリティの標準は gawkのデザイナーとオリジナルを開発したベル研究所のawk 開発者の両方からのフィードバックが反映されている。

Paul Rubinは1986年にGNUによる実装であるgawkを作成した。 Jay FenlasonがそれをRichard Stallmanのアドバイスを受けつつ完成した。 John Woodsはコードの一部分に寄与した。 1988年と1989年に、David Truemanはわたし(Arnold Robbins)の助けの元に gawk*に新しい awk*との互換性を持たせるための作業をおこなった。 1995年頃、わたしは主たるメンテナーとなった。現在の開発の主たる点はバグの修正、パフォーマンスの向上、標準に対する準拠であり、そして随時新しい機能の追加を行っている。

1997年5月に、Jürgen Kahrs はawkにネットワークアクセスの機能の必要性を感じ、わたしのちょっとした助けを伴って gawkに機能を追加した。このとき、彼は TCP/IP Internetworking with gawk というドキュメントも書いた(別のドキュメント。これはgawkの配布に含まれている)。彼のコードは最終的にgawkの一部分となり gawkのバージョン 3.1 で統合された。

See section gawk に対する主要な貢献者たち, for a complete list of those who made important contributions to gawk.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

0.1 A Rose by Any Other Name

awk言語は何年にも渡って発展してきた。その詳しい説明はawk 言語の進化で述べられている。このWeb ページで説明されている言語はほとんどが "new awk"(nawk)として知られているものである。

このため、多くのシステムでは複数のバージョンのawkが存在する。一部のシステムはオリジナルバージョンのawk言語のインプリメントである awkユーティリティと、新しいバージョンであるnawkユーティリティを持っている。他の一部は"古いawk"であるoawkを持っている。残りのものは一つのみ、通常は新しいほうをawkとして持っている。 (2)

重要な事は、このことによってあなたが書いたプログラムをどのバージョンの awkで実行すればよいかということを知ることが難しくなるということである。ここで私達ができる最善のアドバイスは、あなたのシステムのドキュメントを確かめて欲しい。ということである。gawkに対してと同じくらい awk, oawk, nawkを見て欲しい。あなたが使っているシステムには新しいバージョンのawkがあり、あなたのプログラムを実行するときにはそれを使ったほうがよい局面があるかもしれない (もちろん、あなたがこのWeb ページを読めば、gawkを持つ機会があるわけだ!)。

このWeb ページを通じて、POSIXでのawkの実装が備えている言語の機能を示すときには、単純にawkという語を使う。 GNUでの実装に特有な機能を示すときにはgawkという語を使用する。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

0.2 この本を使う

awkという語は特定のプログラムを示していると同時にあなたが実行しようとしているプログラムの言語を示している。気をつける必要がある場合には、プログラムを"awkユーティリティ"と呼び、もう一方を"awk言語"と呼ぶ。 gawkという語はGNUプロジェクトが開発したawkを表している。このWeb ページの目的はawk言語と、 awkユーティリティの実行の仕方の両方を説明することである。

このWeb ページの主な目的はPOSIXの標準で定められているawk の機能を説明することである。それはある特定の実装やgawkを説明しているときに行っている。その説明では同様に、gawkと他のawkの実装との重要な差違を説明することを試みる。(3) さらに、POSIX標準のawkにはないような gawkの機能を説明する。

このWeb ページはチュートリアルとリファレンスの両方の役目を果たすという難しい立場のものであるが、もし、あなたが初心者ならば難しすぎると感じるような記述の部分は好きに読み飛ばしてかまわない。そういった部分はエキスパートユーザーと、このマニュアルのオンラインInfo バージョンで参照されるためのものだからだ。

There are subsections labelled as Advanced Notes scattered throughout the Web ページ. They add a more complete explanation of points that are relevant, but not likely to be of interest on first reading. All appear in the index, under the heading ``advanced features.''

Most of the time, the examples use complete awk programs. In some of the more advanced sections, only the part of the awk program that illustrates the concept currently being described is shown.

While this Web ページ is aimed principally at people who have not been exposed to awk, there is a lot of information here that even the awk expert should find useful. In particular, the description of POSIX awk and the example programs in A Library of awk 関数, and in Practical awk Programs, should be of interest.

Getting Started with awkにはawkを使い始めるにあたって知っておく必要があることの概要がある。

正規表現では一般的な正規表現を紹介し、それに加えて POSIX awkやgawkに固有のものを紹介している。

入力ファイルを読むではawkがどのようにデータを読むのかを説明している。レコードとフィールドのコンセプトを導入し、getline コマンドについても説明している。入出力のリダイレクションは最初にここで説明している。

Printing Outputではawkプログラムがどのようにprintやprintfを使って出力を行うことができるのか説明している。

式ではプログラムにおいて基本的なものである式について説明している。

パターン、アクション、変数ではレコードのマッチングのためのパターンやレコードがマッチしたときのアクションをどのように記述するかを説明し、awkやgawkが使う組み込み変数についても述べている。

awk における配列ではawkのただ一つのデータ構造である連想配列についてカバーしている。配列の要素や配列全体を削除することや gawkで配列をソートすることについても述べている。

関数ではawkとgawkで提供されている組み込み関数について説明していて、さらに自分用の関数の定義の仕方についても述べている。

gawkの国際化では、の異なる言語への実行時のプログラムメッセージの gawkの翻訳機能について述べている。

gawk の高度な機能では、 gawkに固有の幾つかの先端的機能である他のプロセスとの間の双方向通信、TCP/IPネットワーキング、 awkプログラムのプロファイリングについて説明している。

Running awk and gawkでは、gawkの実行の仕方、コマンドラインオプションの意味、awkプログラムソースファイルの見つけ方について説明している。

A Library of awk 関数とPractical awk Programsでは、数多くのサンプルawkプログラムを集めている。ここを読むことであなたがawkを使って実際の問題を解決できるようになるだろう。

awk 言語の進化では、awk言語が最初のリリースからどのように発展してきたのかを説明する。また、gawkが機能を拡張してきた経緯についても述べる。

Installing gawkでは、gawkの入手の仕方、 Unixでのコンパイルの仕方、非Unixシステムでのコンパイルの仕方と使い方について説明する。また、gawkのバグの報告の仕方や他の三つの自由に入手することのできるawk処理系についても述べている。

Implementation Notesでは、 gawk固有の拡張の抑制の仕方、 gawkへの貢献の方法、拡張ライブラリの記述の仕方、いくつかのgawkの開発における将来の方向性について述べている。

Basic Programming Conceptsでは、コンピュータプログラミングにあまり親しんでいない人たち向けに非常に大まかにバックグラウンドについて説明している。また、浮動小数点数に関することがらについて幾つかの議論をまとめている。

用語集には、すべてではないけれどもこの本を通して使われている特長的な単語の定義を集めている。もし見慣れない単語を見つけたら、ここで確認してみて欲しい。

GNU General Public LicenseとGNU Free Documentation Licenseには gawkのソースコードと、このDOCUMENTをカバーしているライセンスがある (GNU 一般公衆利用許諾契約書とGNU フリー文書利用許諾契約書はそれぞれの日本語参考訳)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

0.3 Typographical Conventions

This Web ページ is written using Texinfo, the GNU documentation formatting language. A single Texinfo source file is used to produce both the printed and online versions of the documentation. Because of this, the typographical conventions are slightly different than in other books you may have read.

Examples you would type at the command-line are preceded by the common shell primary and secondary prompts, `$' and `>'. Output from the command is preceded by the glyph ``-|''. This typically represents the command's standard output. Error messages, and other output on the command's standard error, are preceded by the glyph ``error-->''. For example:

$ echo hi on stdout
-| hi on stdout
$ echo hello on stderr 1>&2
error--> hello on stderr

In the text, command names appear in this font, while code segments appear in the same font and quoted, `like this'. Some things are emphasized like this, and if a point needs to be made strongly, it is done like this. The first occurrence of a new term is usually its definition and appears in the same font as the previous occurrence of ``definition'' in this sentence. ファイル名s are indicated like this: `/path/to/ourfile'.

Characters that you type at the keyboard look like this. In particular, there are special characters called ``control characters.'' These are characters that you type by holding down both the CONTROL key and another key, at the same time. For example, a Ctrl-d is typed by first pressing and holding the CONTROL key, next pressing the d key and finally releasing both keys.

Dark Corners

Dark corners are basically fractal --- no matter how much you illuminate, there's always a smaller but darker one. Brian Kernighan

Until the POSIX standard (and The Gawk Manual), many features of awk were either poorly documented or not documented at all. Descriptions of such features (often called ``dark corners'') are noted in this Web ページ with ``(d.c.)''. They also appear in the index under the heading ``dark corner.''

As noted by the opening quote, though, any coverage of dark corners is, by definition, something that is incomplete.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

GNU プロジェクトとこの本

フリーソフトウェア財団(Free Software Foundation, FSF)は非営利団体で、自由に配布することのできるソフトウェアの作成と配布を目的としている。Emacs エディターのオリジナルの作者である Richard M. Stallman によって設立された。 GNU Emacs は今日最も広く使われている Emacsである。

GNU(4) プロジェクトはフリーソフトウェア財団によって作業が行われている完全な、自由に配布することのできるPOSIXコンパチブルなコンピューティング環境の作成を目指したものである FSFは"GNU General Public License-- GNU一般公有許諾 --" (またはGPL)を使って、そのソフトウェアのソースコードが常にエンドユーザーにとって入手可能な状態にあることを保証している。 GPLのコピーはこのNo value for DCOUMENTにも含まれている (see section GNU General Public License)。 GPLはCで書かれているgawkのソースコードに適用されている。 FSFやGNUプロジェクトについての情報をオンラインでもっと見つけるには the GNU Project's home pageを見て欲しい。このドキュメント(の原文)は their web siteにもある。

シェル、エディター(Emacs)、高度な移植性を備えたC、C++、Objective-C コンパイラー、シンボリックデバッガー、その他(gawkのような) 大小たくさんのユーティリティがすでに完成しており、自由に入手できる。 GNUオペレーティングシステムのカーネル(HURD)は既にリリースされている。しかし、これはまだ開発の初期段階にとどまっている。

GNUオペレーティングシステムの開発がさらに進むまでは、自由に配布することができ、80386、DEC alpha、 Sun SPARC、IBM S/390 などで動作するUNIXに似たオペレーティングシステムであるGNU/Linuxを使うのがよいだろう (5)。 GNU/Linuxに関しては多くの書籍があり、その中の一つにMatt Welshによる自由に入手できる(freely availabke）な Linux Installation and Getting Startedがある。コンピュータストアやCD-ROMが添付されたLinuxに関する書籍を通じ、多くの GNU/Linux配布が入手可能になっている。 (二つの自由に入手可能なUnixライクな80386等向けのオペレーティングシステム、 NetBSDとFreeBSDがある。これらは両方とも4.4-Lite Berkeley Software Distribution に基づいたものであり、それら用のawkとして gawkの最新バージョンが使用されている)。

今あなたが読んでいるこのWeb ページはフリーである。ここにある情報や、このWeb ページの元となった gawkに付随する機械読み取り可能なソースコードは誰もが自由に入手できるものであり、そして誰もがこのマニュアルを好きなだけコピーすることができる (ちょっと時間を取って GNU Free Documentation LicenseでFree Documentation Licenseをチェックしてみて欲しい。訳注: 日本語訳はGNU フリー文書利用許諾契約書)。

自分で印刷するよりも、製本された本の方が読みやすいし使いやすい。それに加えて、この本の売上による利益はFSFがより一層の自由なソフトウェア(free software)を開発する助けとなる。

このWeb ページそれ自身は以前からあったいくつかの版を通しての結果である。 Paul Rubinは The GAWK Manualの非常に初期のドラフトを書いたがそれは40ページほどのものだった。 Diane Close と Richard Stallmanはそれを改良し、90ページほどのものになったがオリジナルの``古い''バージョンのawkに関する説明がほとんどなかった。

わたしは1988年の秋にそのバージョンを本に作業を始めた。 FSFはいくつかのpreliminary バージョン (0.xという数字のついたもの) を出版した。 1996年に、gawk 3.0.0と共に第1版がリリースされた。 FSFはその最初の二つの版をThe GNU Awk User's Guideというタイトルで出版した。

gawk で配列の値や添え字をソートする, as well as gawk のビット操作関数, gawkの国際化, and also gawk の高度な機能, and 新たな組み込み関数をgawkに追加する. この版では基本的な部分は第一版のものから構成されているが、 gawkのバージョン 3.1での新しい機能の説明などが追加されている。 gawk で配列の値や添え字をソートする、 gawk のビット操作関数、 gawkの国際化、 gawk の高度な機能、新たな組み込み関数をgawkに追加するなどがそうである。

GAWK: Effective AWK Programmingは進化しつづけている。電子バージョンはFSFからgawkと共に配布されている。もしこのWeb ページに間違いを見つけたら、どうかそれを知らせて欲しい! 問題の報告の方法はSee section 問題点やバグを報告するにある。あるいは、出版社気付でわたしに手紙を書いて欲しい。訳注: 日本語版に関しての間違いは訳者まで。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

貢献の仕方

GNU awkのメンテナーとして、わたしは公的に入手可能なawkプログラムを集め始めた。詳細は ftp://ftp.freefriends.org/arnold/Awkstuffを参照のこと。もしあなたが面白いawkプログラムや gawk拡張を書いて、それを世界の人々と分かち合いたいと思ったなら、どうぞわたし(arnold@skeeve.com)に連絡して欲しい。インターネットでできることはgawkの配布を制御可能なサイズにする。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

謝辞

The GAWK Manualの初期のドラフトでは、以下のような謝辞があった。

このマニュアルの作成にあたって、多くの人々の協力があった。 Jay Fenlasonは多くのアイデアと、サンプルプログラムを寄付してくれた。 Richard Mlynarik と Robert Chassellはこのマニュアルの草稿について有用な助言をくれた。 UC San DiegoのChemistry DepartmentのJohn W. Pierceによる A Supplemental Document for awkという論文は awkの実装とこのマニュアルの両方に関連した幾つかの問題点を指摘しており、我々にとって有益であった。

ここでRichard M. Stallmanと、彼のより良き世界へのビジョン、そしてフリーソフトウェア財団を設立し GNUプロジェクトを開始した彼の勇気を認めたい。

The following people (in alphabetical order) provided helpful comments on various versions of this book, up to and including this edition. Rick Adams, Nelson H.F. Beebe, Karl Berry, Dr. Michael Brennan, Rich Burridge, Claire Cloutier, Diane Close, Scott Deifik, Christopher (``Topher'') Eliot, Jeffrey Friedl, Dr. Darrel Hankerson, Michal Jaegermann, Dr. Richard J. LeBlanc, Michael Lijewski, Pat Rankin, Miriam Robbins, Mary Sheehan, and Chuck Toporek.

Karl Berry helped significantly with the TeX part of Texinfo. Robert J. ChassellはTexinfoの使用についての助言をしてくれた。彼はこのWeb ページのタイトルを How To Gawk Politely というタイトルにしないよう助言をしてくれた。 Karl Berryは TexinfoのTeX部分に際立った助力をしてくれた。

I would like to thank Marshall and Elaine Hartholz of Seattle and Dr. Bert and Rita Schreiber of Detroit for large amounts of quiet vacation time in their homes, which allowed me to make significant progress on this Web ページ and on gawk itself.

Phil Hughes of SSC contributed in a very important way by loaning me his laptop GNU/Linux system, not once, but twice, which allowed me to do a lot of work while away from home.

David Truemanは特別に賞賛を受けるに値する。彼はgawkを性能がよく、バグがないものとする不屈な仕事を行った。彼はもうgawkに関係していないが、このプロジェクトで彼とともに作業したことは非常に喜ばしいことであった。

The intrepid members of the GNITS mailing list, and most notably Ulrich Drepper, provided invaluable help and feedback for the design of the internationalization features.

Nelson Beebe, Martin Brown, Andreas Buening, Scott Deifik, Darrel Hankerson, Isamu Hasegawa, Michal Jaegermann, Jürgen Kahrs, Pat Rankin, Kai Uwe Rommel, and Eli Zaretskii (順不同) は長期間にわたりgawkの "crack portability team"のメンバーである。彼らの作業と助けを抜きにしてgawkは今日あるような優秀なプログラムにはならなかっただろう。このチームの素晴らしい面々と作業を行うことは喜ばしいことであった。

gawkのテストとデバッグの間貴重な助言を寄せてくれ、言語に関する幾つかの疑問点を明確にするための助けをしてくれた Bell研究所の Brian Kernighan に感謝する。彼の助けなくして我々はgawkやこのドキュメントの作業において良い結果は得られなかっただろう。

Chuck Toporek, Mary Sheehan, and Claire Coutier of O'Reilly & Associates contributed significant editorial help for this Web ページ for the 3.1 release of gawk.

I must thank my wonderful wife, Miriam, for her patience through the many versions of this project, for her proofreading, and for sharing me with the computer. I would like to thank my parents for their love, and for the grace with which they raised and educated me. Finally, I also must acknowledge my gratitude to G-d, for the many opportunities He has sent my way, as well as for the gifts He has given me with which to take advantage of those opportunities. Arnold Robbins Nof Ayalon ISRAEL March, 2001

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1. Getting Started with `awk`

awkの基本的な機能は、ファイルからあるパターンを含んでいる行 (もしくは他のテキストの構成単位)を検索することである。ある行がパターンの一つにマッチしたとき、 awkは特定のアクションをその行に対して実行する。 awkはこのようにして入力ファイルの最後の行までそれぞれの行を処理し続ける。

awkのプログラムは他の大部分の言語とは異なっていて、データ駆動(data-driven)である。これは処理したいと思うデータについて記述し、さらにそれを見つけたときにどのようなことをするのかということについて記述する。ということである。他のほとんどの言語は手続き型(procedural)である。それらにおいては、事細かに、プログラムの各ステップ毎にどのようにするかを記述しなければならない。手続き型言語を使用しているときは、あなたがプログラムで処理しようとしているデータがどのような構造をしているかを明確に記述することは、一般的には簡単ではない。このため、awkプログラムは、しばしば書くのも読むのもやさしいということになるのである。

See section ユーザー定義関数.) Each rule specifies one pattern to search for and one action to perform upon finding the pattern. awk を実行したときにawk がどのように動作するかを awk プログラムで指定できる。プログラムはrulesの集まりからなる(関数定義も含まれるが、高度な機能なので今のところは無視する。 See section ユーザー定義関数.)。個々のルールはある特定のパターンを探し、見つかったパターンで定義されたアクションを実行する。

文法的には、ルールはパターンとそれに続くアクションから構成される。アクションはカーリーブレースによってアクションと区切られる。ルールは一般的には改行によって区切られる。その結果、 awk プログラムは以下のような形式となる。

パターン { アクション }
パターン { アクション }
…

1.1 `awk` プログラムの実行の仕方		コマンドライン構文を含めた `gawk` プログラムの実行の仕方。
1.2 例のためのデータファイル		Sample data files for use in the `awk` programs illustrated in this Web ページ.
1.3 幾つかの単純な例
1.4 二つのルールの例
1.5 より複雑な例
1.6 `awk` Statements Versus Lines		Subdividing or combining statements into lines.
1.7 `awk` のその他の機能
1.8 `awk` を使うとき		When to use `gawk` and when to use other things.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1 `awk` プログラムの実行の仕方

awkプログラムを実行するには幾つかの方法がある。プログラムが短いのならば、下の例のようにawkを実行するコマンドに含めてしまうのがもっとも簡単である:

awk 'プログラム' 入力ファイル1 入力ファイル2 …

プログラムが長い場合、プログラムをファイルにしてしまい、次のようにしてコマンドと一緒に実行するのが一般的には便利である:

awk -f プログラムファイル 入力ファイル1 入力ファイル2 …

このセクションでは両方のメカニズムについてバリエーションも含めて説明する。

1.1.1 使い捨ての一発`awk`プログラム
1.1.2 `awk` を入力ファイルなしで実行する		入力ファイルを使わない (代わりに端末から入力する)。
1.1.3 長いプログラムを実行する		恒久的な `awk`プログラムをファイルにする。
1.1.4 実行可能な `awk` プログラム		Making self-contained `awk` programs.
1.1.5 `awk` プログラム中のコメント		`gawk` プログラムにドキュメントを付加する。
1.1.6 シェルのクォーティングについて		More discussion of shell quoting issues.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.1 使い捨ての一発`awk`プログラム

一度awkに慣れ親しんでしまえば、単純なプログラムを必要とするときにタイプするようになるだろう。そのようなとき、そんなプログラムはawkコマンドの最初の引数として記述できる。このように:

awk 'プログラム' 入力ファイル1 入力ファイル2 …

プログラムは先に説明したように、パターンとアクションの並びからなる。

このコマンドはシェルやコマンドインタープリターに対してawk を起動させ、プログラムが入力ファイル中のレコードを処理するように指示するものである。プログラムの周りには引用符があり、これによってシェルは、シェルにとってのスペシャルキャラクタとなるawkのキャラクタを誤って解釈することがなくなる。同時にこれは、シェルに対してプログラムがawkに対する一つの引数にし、またプログラムが複数行に渡ることも可能にする。

この書式はawkプログラムを別のファイルに分ける必要がないので、短いものから中程度の大きさのawkプログラムをシェルスクリプトから実行するのに便利である。自己完結した(self-contained)シェルスクリプトは分割されているファイルを間違った場所に置くことがないので、より信頼性がある。

この章の後の方にある幾つかの単純な例に幾つかの短い自己完結したプログラムがある。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.2 `awk` を入力ファイルなしで実行する

awkを入力ファイルなしで実行することもできる。それにはこうコマンドラインでタイプすればよい。

awk 'プログラム'

このとき、awkはプログラムの入力を標準入力にする。標準入力は通常、あなたが端末からタイプしたものである。これはあなたがCtrl-dをタイプしてファイルの終端を指示するまで続く (他のオペレーティングシステムではファイルの終端を示すキャラクタは違ったものである。例えばOS/2やMS-DOSでは Ctrl-zである)。

(BEGIN is a feature we haven't discussed yet): 以下の例にあるプログラムは親切なアドバイスを出力し (Douglas Adamsの The Hitchhiker's Guide to the Galaxyより)、コンピュータプログラミングの複雑さに対して恐れないようにする (BEGINはまだ説明していない機能である):

$ awk "BEGIN { print \"Don't Panic!\" }"
-| Don't Panic!

このプログラムは何の入力も読まない。ダブルクォートの前にある `\'は、シェルのクォートルールのために、特にダブルクォートとシングルクォートを混ぜて使う場合に必要である。(6)

次なる単純なawkプログラムはcatユーティリティを模倣するものである。これはキーボードからタイプしたものすべてを標準出力にコピーする(こんなに短いのにちゃんと働くのだ)。

$ awk '{ print }'
Now is the time for all good men
-| Now is the time for all good men
to come to the aid of their country.
-| to come to the aid of their country.
Four score and seven years ago, ...
-| Four score and seven years ago, ...
What, me worry?
-| What, me worry?
Ctrl-d

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.3 長いプログラムを実行する

ときとしてawkプログラムが非常に大きくなることがある。この場合、プログラムを別のファイルに分けて置くのが便利である。 awkに対してプログラムの入ったファイルを指定するには次のようにタイプする:

awk -f ソースファイル 入力ファイル1 入力ファイル2 …

`-f'はawkユーティリティに対してawkプログラムをソースファイルというファイルから受け取るということを指定する。任意の名前をソースファイルに使うことができる。たとえば、次のようなプログラムを:

BEGIN { print "Don't Panic!" }

`advice'という名前のファイルに置くことができ、次のようなコマンドで使う。

awk -f advice

これは次の例とおなじことである。

awk "BEGIN { print \"Don't Panic!\" }"

こちらは既に説明した (see section awk を入力ファイルなしで実行する)。大部分のファイル名はシェルのスペシャルキャラクタを含んでいないので、通常は`-f'で指定するファイル名を引用符で括る必要はない。 `advice' 中では、awkプログラムは引用符で括られていない。引用符をつける必要があるのはawkのコマンドライン上でプログラムを与える場合だけである。

もしawkプログラムのファイルの確認を明確にしたいのなら、ファイル名に`.awk'という拡張子を追加することができる。これはawkプログラムの実行には影響を及ぼさないが、 "housekeeping"を容易にする。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.4 実行可能な `awk` プログラム

For example, you could update the file `advice' to look like this: 一度awkを学んでしまえば、シェルの`#!' 構文を使って、独立した awk スクリプトを書いてみたくなるだろう。多くのUnixシステム(7) でこれが可能である(そしていつかはGNUシステムでも)。

#! /bin/awk -f

BEGIN { print "Don't Panic!" }

このファイルを(chmodユーティリティを使って)実行可能にした後で、シェルから単純に`advice'とタイプするだけで、`awk -f advice' とタイプしたのと同じようにシステムがawkを実行するようアレンジする (8):

$ chmod +x advice
$ advice
-| Don't Panic!

(ここで、あなたの使っているシェルの検索パス変数(典型的には$PATH)にカレントディレクトリが含まれていることを仮定している。もしそうでなければシェル上で`./advice'とタイプする必要があるだろう)

自己完結したawkスクリプトは、それを使う人がそのプログラムを awkで書かれたものであることを知ることなしに起動できるプログラムを書きたいと思うときに便利である。

Advanced Notes: Portability Issues with `#!'

一部のシステムでは、インタープリターの名前の長さは32キャラクタまでに制限されている。しばしば、これはシンボリックリンクを使って回避することが可能である。

`#!'の行でawkのパスの後に二つ以上の引数を置くべきではない。これをしてしまうと正しく動作しないだろう。オペレーティングシステムは行の残りの部分を一つの引数として取り扱い、それをawkに渡す。これによって混乱した動作がもたらされる。ありがちなのは、 awkのusageメッセージの類が出力されることだろう。

最後に、ARGV[0](see section 組み込み変数)はあなたの使っているオペレーティングシステムによって様々なものになることを述べておく。あるシステムでは`awk'がそこに入り、別のあるシステムではawkのフルパス(`/bin/awk' のように)が入り、また別のシステムではスクリプトの名前(ここでは`advice') が入る。スクリプトの名前を得るためにARGV[0]の値を当てにしてはいけない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.5 `awk` プログラム中のコメント

コメントとはプログラム中で、人が（プログラムを）読みやすくするために含められるテキストであり、プログラムにとって必要不可欠というものではない。コメントはプログラムが書けるところならどこでも置けるが、何の働きもしない。身近な全てのプログラミング言語はその様な目的のためにコメントを使える様になっているが、それは典型的なプログラムというものは何らかの助けなしには理解するのが非常に難しいからである

awk言語のコメントは`#'で始まり、その行の終わりまで続く。 awk言語は`#'に続く部分を無視する。例えば、`advice'に次のように追加を行うことができる。

# This program prints a nice friendly message.  It helps
# keep novice users from being afraid of the computer.
BEGIN    { print "Don't Panic!" }

awkプログラムをキーボードから直接入力しているような場合でもコメント行を入力することは可能であるけれども、これはあまり有効なことではないだろう。なぜならコメントを使う目的が、後日あなたか、あるいは他の人がそのプログラムを読んだときに理解するのを助けるためだからだ。

警告: 使い捨ての一発awkプログラムで言及したように、小規模のプログラムをシングルクォートでくくることが可能であり、それによってあなたのシェルスクリプトをself-containdなものにできる。これを行ったとき、アポストロフィ(シングルクォート)をコメント中(もしくはプログラムのどこかで)で使ってはいけない。シェルはそのようなクォートをプログラム全体をくくるクォートとして扱ってしまう。結果として、通常はシェルがクォートのバランスが取れていないといったメッセージを出力する。そして、awk が実際に実行されたならば、構文エラーのような妙なメッセージを出力するだろう。例を挙げる:

$ awk '{ print "hello" } # let's be cute'
>

シェルは最初の二つのクォートのマッチを見て、コマンドラインの終わりにあるのが新たなクォートオブジェクトの始まりであるとみなす。したがって二次プロンプトが表示されて入力待ちとなる。 Unixのawkでは、クォートを閉じると以下の結果となる:

$ awk '{ print "hello" } # let's be cute'
> '
error--> awk: can't open file be
error-->  source line number 1

`let's'の中のシングルクォートの前にバックスラッシュを置くことは助けにはならない。なぜなら、バックスラッシュはシングルクォートの中では特別なものではないからである。次のサブセクションではシェルのクォーティングルールについて説明する。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.1.6 シェルのクォーティングについて

訳注:Windows(コマンドプロンプト)には関係しない部分なので後回し。

For short to medium length awk programs, it is most convenient to enter the program on the awk command line. This is best done by enclosing the entire program in single quotes. This is true whether you are entering the program interactively at the shell prompt, or writing it as part of a larger shell script:

awk 'program text' input-file1 input-file2 …

Once you are working with the shell, it is helpful to have a basic knowledge of shell quoting rules. The following rules apply only to POSIX-compliant, Bourne-style shells (such as bash, the GNU Bourne-Again Shell). If you use csh, you're on your own.

Quoted items can be concatenated with nonquoted items as well as with other quoted items. The shell turns everything into one argument for the command.
Preceding any single character with a backslash (`\') quotes that character. The shell removes the backslash and passes the quoted character on to the command.
Single quotes protect everything between the opening and closing quotes. The shell does no interpretation of the quoted text, passing it on verbatim to the command. It is impossible to embed a single quote inside single-quoted text. Refer back to awk プログラム中のコメント, for an example of what happens if you try.
Double quotes protect most things between the opening and closing quotes. The shell does at least variable and command substitution on the quoted text. Different shells may do additional kinds of processing on double-quoted text.
Since certain characters within double-quoted text are processed by the shell, they must be escaped within the text. Of note are the characters `$', ``', `\', and `"', all of which must be preceded by a backslash within double-quoted text if they are to be passed on literally to the program. (The leading backslash is stripped first.) Thus, the example seen previously in awk を入力ファイルなしで実行する, is applicable:
$ awk "BEGIN { print \"Don't Panic!\" }" -| Don't Panic!
Note that the single quote is not special within double quotes.
Null strings are removed when they occur as part of a non-null command-line argument, while explicit non-null objects are kept. For example, to specify that the field separator FS should be set to the null string, use:
awk -F "" 'program' files # 正しい
Don't use this:
awk -F"" 'program' files # 間違い!
In the second case, awk will attempt to use the text of the program as the value of FS, and the first ファイル名 as the text of the program! This results in syntax errors at best, and confusing behavior at worst.

Mixing single and double quotes is difficult. You have to resort to shell quoting tricks, like this:

$ awk 'BEGIN { print "Here is a single quote <'"'"'>" }'
-| Here is a single quote <'>

This program consists of three concatenated quoted strings. The first and the third are single-quoted, the second is double-quoted.

This can be ``simplified'' to:

$ awk 'BEGIN { print "Here is a single quote <'\''>" }'
-| Here is a single quote <'>

Judge for yourself which of these two is the more readable.

Another option is to use double quotes, escaping the embedded, awk-level double quotes:

$ awk "BEGIN { print \"Here is a single quote <'>\" }"
-| Here is a single quote <'>

This option is also painful, because double quotes, backslashes, and dollar signs are very common in awk programs.

A third option is to use the octal escape sequence equivalents for the single- and double-quote characters, like so:

$ awk 'BEGIN { print "Here is a single quote <\47>" }'
-| Here is a single quote <'>
$ awk 'BEGIN { print "Here is a double quote <\42>" }'
-| Here is a double quote <">

This works nicely, except that you should comment clearly what the escapes mean.

A fourth option is to use command-line variable assignment, like this:

$ awk -v sq="'" 'BEGIN { print "Here is a single quote <" sq ">" }'
-| Here is a single quote <'>

If you really need both single and double quotes in your awk program, it is probably best to move it into a separate file, where the shell won't be part of the picture, and you can say what you mean.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.2 例のためのデータファイル

このWeb ページでの例の多くは、二つのサンプルデータファイルから入力を取る。一番目は `BBS-list'と呼ばれるものであり、 BBSのリストとその情報が記述されているファイルである。二番目のデータファイルは`inventory-shipped' と呼ばれるもので月毎の船積みの量が記述されているファイルである。これらのファイルの各行には、一つのレコード(record)だけが置かれている。

`BBS-list'中の各レコードは、BBSの名称とその電話番号、ボーレート、そして運営時間を表すコードから構成される。最終カラムの `A'はBBSが終日運営されていることを示し、同様に `B'は BBSの運営が夜間と週末のみであることを、 `C'は週末のみの運営である事を示す。

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

二番目のデータファイルは`inventory-shipped'と呼ばれるもので、年間の積込量を記述したものである。各レコードは、月と、緑色のかごの積込量、赤い箱の積込量、オレンジ色のバッグの積込量、そして青い包みの積込量から構成されている。ファイルには16のエントリがあり、ある年の12ヶ月と、その翌年の4ヶ月分のデータが記述されている。

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

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.3 幾つかの単純な例

以下に例示したコマンドは`BBS-list'という入力ファイルから `foo'という文字列を検索する単純なawkプログラムである。

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

`foo'を含んでいる行が見つかったとき、その行は出力される。なぜなら`print $0'がカレント行の出力を意味しているからである (`print'だけでも同じ意味になるのでそう書くこともできる)。

スラッシュ(`/')が文字列`foo'の周りにあることが気になっただろう。このスラッシュは`foo'が検索対象のパターンであることを示すものである。このタイプのパターンは正規表現 (regular expression)と呼ばれるもので、詳しくは後で(see section 正規表現) 説明する。パターンは単語の一部分にマッチするものでも良い。 awkプログラムの周りにはシングルクォートがあるのでシェルはシェルの特殊キャラクタを解釈することはない。

以下はこのプログラムの出力したものである。

$ awk '/foo/ { print $0 }' BBS-list
-| 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

awkのルールでは、パターンかアクションのいずれかを省略することができるが両方を一度に省略することはできない。パターンが省略された場合、そのアクションはすべての入力行に対して適用される。アクションが省略された場合のデフォルトのアクションはパターンにマッチしたすべての行を出力するというものである。

したがって、先の例ではアクション(print文とカーリーブレース)を省略することができ、その場合でも同じ結果、つまりパターン`foo'にマッチしたすべての行が出力される。対照的に、print文を省略したがカーリーブレースを残した場合には空アクションとなりなにもしない(つまり何も出力されない)。

多くの有用なawkプログラムは短く、一行か二行のものである。ここに集めたのはそういった、便利で短いプログラムである。これらのプログラムのうちの幾つかは、まだ説明していない機能を使っている (プログラムの説明は何かをするための良いアイデアをあなたにもたらすだろうが、どうかこのWeb ページの残りを読んで欲しい。あなたがawkのエキスパートとなるために!)。例の大部分は`data'という名前のデータファイルを使っている。これは単にプレースホルダーである。これらのプログラムを実際に使うなら、 `data'をあなたのファイル名で置き換えること。将来のリファレンスのため、awkでの複数のやり方が載っている。幾つかのポイントでは、これらの例を見るために後戻りしてここで例示されていることを行う異なるやり方を見出すかもしれない。

最も長い入力行を出力する

awk '{ if (length($0) > max) max = length($0) }
     END { print max }' data

80キャラクタを越える長さの行をすべて出力する
awk 'length($0) > 80' data
このただ一つのルールはパターンとしての関係式を持ち、アクションを持たない(したがって、デフォルトアクションであるレコードの出力が適用される)。
`data'の中で最も長い行を出力する
expand data | awk '{ if (x < length()) x = length() } END { print "maximum line length is " x }'
タブをスペースに置き換えるためにexpandユーティリティで入力に対する前処理を行っているので、実際の長さで比較が行われる。
少なくとも一つのフィールドを持つすべての行を出力する
awk 'NF > 0' data
これはあるファイルから空行を取り除く (もしくは古いファイルから空行を除いた新しいファイルを作成する)簡単な方法である

このプログラムは0から100の間にある乱数を七つ出力する。

awk 'BEGIN { for (i = 1; i <= 7; i++)
                 print int(101 * rand()) }'

filesで使われているバイト数の合計を出力する

ls -l files | awk '{ x += $5 }
                  END { print "total bytes: " x }'

filesで使われているバイト数の合計をキロバイト単位で出力する

ls -l files | awk '{ x += $5 }
   END { print "total K-bytes: " (x + 1023)/1024 }'

すべてのユーザーのログイン名をソートして出力する
awk -F: '{ print $1 }' /etc/passwd | sort
ファイルの行数を数える
awk 'END { print NR }' data
データファイルの偶数行を出力する
awk 'NR % 2 == 0' data
式を`NR % 2 == 1'にすると、プログラムは奇数行を出力するようになる

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.4 二つのルールの例

awkユーティリティは一度のファイル入力で一行だけ入力する。入力された個々の行に対して、awkプログラムで記述されている各ルールのパターンとの照合を行う。パターンとマッチすればアクションが実行され、マッチするパターンがなければ何も実行されない。

すべてのルールを処理した後でawkは次の入力行の読み込みを行う (しかし例外はある。see section next 文、see section Using gawk's nextfile Statement)。この動作はファイルの終端に達するまで繰り返される。

/12/  { print $0 }
/21/  { print $0 }

このawkプログラムは二つのルールから構成されている。一つ目のルールは`12'という文字列を持ち、アクションは`print $0'である。二番目のルールは`21'という文字列を持ち、アクションとして `print $0'を持っている。各ルールのアクションはそれぞれブレースのペアで囲まれている。

この awk プログラムは、文字`12'か文字列`21'を含むすべての行を出力する。もし行の中に両方ともあれば、その行はそれぞれのルール毎に出力が行われるので結果として二回出力されることになる。

このプログラムを`BBS-list' と `inventory-shipped' の二つのサンプルデータファイルに対して実行した場合の結果はこうなる

$ awk '/12/ { print $0 }
>      /21/ { print $0 }' BBS-list inventory-shipped
-| 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

`BBS-list'の中の`sabafoo'で始まる行が二回出力されていることに注目。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.5 より複雑な例

以下の例は、あなたにawkプログラムの行うことの典型的なアイデアを与えるためのものである。この例はawkに対して、他のユーティリティの出力を要約し、選択し、アレンジするための方法を示している。まだ説明がされていない機能が使われているが、 (スクリプトの)全てが理解できなくても心配することはない。

ls -l | awk '$6 == "Nov" { sum += $5 }
             END { print sum }'

このコマンドはカレントディレクトリにある11月（年は何年でもよい）に最後の修正がなされたファイルの大きさの合計バイト数を出力する。 (9) 例の`ls -l' の部分は、あるディレクトリ中のファイルをそのサイズと最終修正日付とともにリストアウトするためのコマンドであり、その出力は以下のような形である。

-rw-r--r--  1 arnold   user   1933 Nov  7 13:05 Makefile
-rw-r--r--  1 arnold   user  10809 Nov  7 13:03 awk.h
-rw-r--r--  1 arnold   user    983 Apr 13 12:14 awk.tab.h
-rw-r--r--  1 arnold   user  31869 Jun 15 12:20 awkgram.y
-rw-r--r--  1 arnold   user  22414 Nov  7 13:03 awk1.c
-rw-r--r--  1 arnold   user  37455 Nov  7 13:03 awk2.c
-rw-r--r--  1 arnold   user  27511 Dec  9 13:07 awk3.c
-rw-r--r--  1 arnold   user   7989 Nov  7 13:03 awk4.c

最初のフィールドは読み書きの許可フラグ、二番目のフィールドはそのファイルへリンクしているリンクの数、三番目のフィールドはそのファイルのオーナーのID、四番目がファイルのグループ、五番目がそのファイルの大きさをバイトで表したもの、六,七,八番目のフィールドは最後にそのファイルが修正された月、日、時間である。最後の九番目のフィールドはファイルの名前である。 (10)

このawkプログラムの`$6 == "Nov"'という式は、 `ls -l'の出力の六番目のフィールドが`Nov'という文字列とマッチするかどうかをテストしている。 `Nov'という文字列を六番目のフィールドに持つ行が読み込まれるたびに ` sum += $5 'というアクションが実行される。このアクションでは、五番目のフィールド（ファイルサイズ）をsum という変数に足し込んでいる。結果として、 sumはパターンにマッチした行のファイルの大きさの合計を表す (awkの変数は、自動的に 0で初期化されている)。

ls の出力から渡される最後の行が処理された後で ENDルールが実行され、 sumの値が出力される。この例では、 sumの値は80600になるだろう。

こういった類の高度なawkの使い方は後の方のセクションで述べられている (see section アクション)けれども、その様な使い方を覚える前にどのように入力が解釈され、どのように出力が表示されるかを知ったほうがよいだろう。フィールドを操作し、print文を使うことによって、有用なそして華やかな見栄えのするレポートを作成することができる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.6 `awk` Statements Versus Lines

ほとんどの場合、awkプログラムの各行は次の例にみられるように独立した文、あるいは独立したルールである。

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

しかし、gawkは以下に挙げるものに続く改行は無視する。

,    {    ?    :    ||    &&    do    else

その他の場所にある改行は文の終端として認識される。 (11)

一つの文を二つの行に改行で分けたいときに、行末にバックスラッシュ`\'(訳注: 日本語環境では円記号) を置くことによって行を継続することができる。このバックスラッシュによる行の継続はどこにでも置くことができる。たとえ文字列や正規表現の途中であっても可能である。例えば

awk '/This regular expression is too long, so continue it\
 on the next line/ { print $1 }'

このWeb ページにあるサンプルプログラムでは、通常はバックスラッシュによる継続を使用しない。なぜなら、gawkには一行の長さに制限がなく継続の必要が全くないからである。また、継続を使わないことによってプログラムがより読みやすくなるということもある。同じ理由によって、サンプルプログラムではほとんどの文を短く保っている。バックスラッシュによる継続は、あなたのawkプログラムがコマンドライン上でタイプされるものの代わりに分割されたソースファイルであるときに非常に便利である。ここで、バックスラッシュによる行継続は各awk処理系の実装に依存するものであることに注意するべきである。たとえば、文字列定数を行継続を使って分割することを許していない処理系がある。したがって、あなたの作成するawkプログラムの移植性を最大限に保つためには、正規表現や文字列の途中での行の分割を行わないことが最良の手段である。

警告: バックスラッシュによる行の継続は Cシェルではこのマニュアルに書かれている通りには動作しない。バックスラッシュによる行継続はファイルに記述された awkプログラムや Bourne シェル、 Bash(GNU Bourne-Again shell)等のPOSIX に従ったシェルでの one-shot programsでは働くが、 Cシェル(csh)ではそうではない! Cシェルの場合はバックスラッシュを改行の前に二つ続けて書かなければならない。同様に、Cシェルを使っているときには awkプログラムのすべての行の改行をバックスラッシュでエスケープしなければならないことに気をつけること。例を挙げよう。

% awk 'BEGIN { \
?   print \\
?       "hello, world" \
? }'
-| hello, world

ここで、`%' や `?'はそれぞれCシェルの一次プロンプトと二次プロンプトである (標準シェルでは `$'と`>')。

POSIX準拠のシェルではどうなるか対比してみよう

$ awk 'BEGIN {
>   print \
>       "hello, world"
> }'
-| hello, world

awkは行指向の言語である。各々のルールのアクションはパターンとして同じ行に置かねばならない。パターンとアクションを分割した行に置くには、バックスラッシュによる行継続を使わなければならない。

バックスラッシュによる継続とコメントとを混ぜないように気をつけよう。 awkは`#'を見つけるやいなやコメントが始るとみなし、そこから、行の後のほうはすべて無視する。例を挙げる。

$ gawk 'BEGIN { print "dont panic" # a friendly \
>                                    BEGIN rule
> }'
error--> gawk: cmd. line:2:                BEGIN rule
error--> gawk: cmd. line:2:                ^ parse error

In this case, it looks like the backslash would continue the comment onto the next line. However, the backslash-newline combination is never even noticed because it is ``hidden'' inside the comment. Thus, the BEGIN is noted as a syntax error. ここで、バックスラッシュはコメントを次の行に継続しているようにみえる。どんなやり方でも、バックスラッシュと改行の組み合わせは決して (awkには) 気づかれない。なぜなら、それ(バックスラッシュ）が、コメントの内部に“隠れた”からである。したがって、BEGINは文法エラーとして指摘される。

一つのルールの中にあるawkの文が短いときには、それを一行にいくつもまとめて書きたいと考えるだろう。そのためにはセミコロン`;'を使って文を区切る。これはルールそれ自身にも適用できる。したがって、このセクションの最初にあった例はこのように書くこともできる。

/12/ { print $0 } ; /21/ { print $0 }

注意: オリジナルのawk言語では、同じ行にあるルールをセミコロンで区切らなくても良かった。これ(セミコロンでルールを区切ること)はアクション中にあるステートメントの扱いとの一貫性をとるために付け加えられたものである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.7 `awk` のその他の機能

awkは、作成したプログラムがawkから情報を得るための組込みであらかじめ定義されている幾つかの変数を提供している。その他にも、プログラム中でawkがどのようにデータを処理するかを制御するための変数がある。

さらに、awkは一般的な計算や文字列操作をおこなうための組込み関数を提供している。 gawkはタイムスタンプ、ビット操作、実行時の文字列変換を行うための組み込み関数を提供している。

我々はawk言語を開発するときに、変数の大部分と多くの関数を導入した。それらは組み込み変数と組み込み関数にシステマチックに定義されている。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

1.8 `awk` を使うとき

(See section より複雑な例.) あなたは、awkがあなたにとって役に立つのかどうかを疑問に思うかもしれない。ユーティリティプログラムやパターン、フィールドの分割、算術文、などの選択基準を使って、より複雑な出力を作成することができる。 awk言語はls のようなほかのユーティリティの出力からの情報を要約するような、大きな生データからレポートを生成するような作業に便利である。

awkで書かれたプログラムは、通常は他の言語で書いたものよりも小さくなる。これはawkプログラムの作成と使用を簡単にする。しばしば、awkプログラムはターミナルで即座に作成し、一度だけ使って捨ててしまうということもできる。 awkプログラムはインタープリットされるために、エディット-コンパイル-テスト-デバッグというソフトウェア開発の典型的なサイクルを避けることができるのである。

完全にretargetableな8ビットマイクロプロセッサ用のアセンブラ (詳しくはsee section 用語集)や、特殊目的用Prologコンピュータ用のマイクロコードアセンブラのような複雑なプログラムがawkを使って記述されたことがある。最近では、gawkがWikiクローンを記述するのに用いられた(12)。オリジナルのawkの能力はそのような複雑なことをこなすには機能が制限されていたが、最近のバージョンではより多機能になっている。 Bell研バージョンのawkでさへ幾つかのあらかじめ決められた制限があるが以前のものよりゆるいものになっているのである。

2、300行以上のawkスクリプトを書くようになったとき、違ったプログラミング言語の使用を考えていることに気がつくだろう。 Emacs Lisp は、文字列やパターンマッチングを扱う高度な能力を必要とするときにはよい選択といえる。シェルもまた文字列やパターンマッチングを扱う能力があり、それに加えて強力で便利なシステムユーティリティを使う事ができる。より伝統的な言語、CやC++、Javaといったものは、システムプログラミングや大きなプログラムの複雑さを管理するのに便利であるだろう。これらの言語で記述したプログラムは、同じ作業をする awk プログラムよりも多くの行数を必要とするかも知れないが、より有効に実行したり、簡単にメンテナンスできる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2. 正規表現

正規表現(regular expression または regexp)とは、文字列の集合を表現する方法である。正規表現はawkプログラミングにおいて非常に基本的な部分であるので、その書式と使い方は章を分けて説明するに値する。

スラッシュ(`/')に囲まれた正規表現は、その正規表現が示す集合に属するテキストが含まれる全ての入力レコードにマッチする awkのパターンである。もっとも単純な正規表現は、文字や数字、もしくはその両方の並びである。このような正規表現はそのような並びを含む任意の文字列にマッチする。したがって、`foo'という正規表現は`foo'を含む任意の文字列にマッチすることになる。それにより、/foo/というパターンはレコードのどこであっても `foo'という三文字を含む入力レコードにマッチすることになるのである。他の種類の正規表現は、あなたがより複雑な文字列の集合を指定できるようにするものである。

Initially, the examples in this 章 are simple. As we explain more about how regular expressions work, we will present more complicated instances.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.1 正規表現の使い方

正規表現はスラッシュで囲まれたパターンとして使うことができる。そのような正規表現は各レコードのテキスト全体に対してのテストが行われる (通常は、成功かどうかを決めるにはテキストの一部分だけ見れば良い)。以下に挙げる例は`foo'を含むレコードの第二フィールドを出力する。

$ awk '/foo/ { print $2 }' BBS-list
-| 555-1234
-| 555-6699
-| 555-6480
-| 555-2127

~ (tilde), ~ operator 正規表現はまた、マッチング式として使うことができる。これらの式はマッチングを試みる文字列を特定することを許し、カレント入力レコード全体とマッチングすることをしないで済むようにできる。 `~'と `!~'という二つの演算子は正規表現の比較をおこなう。これらの演算子を使った式はパターンとしてや使ったり、 if、 while、for、do文中で使うこととができる (See section アクション中の制御文)。

exp ~ /regexp/

これはexp(文字として扱われる)という式がregexp とマッチするときに真となる。以下に挙げる例は、第一フィールドに大文字の`J' を含んでいる入力レコードをすべて選択するものである。

$ awk '$1 ~ /J/' inventory-shipped
-| Jan  13  25  15 115
-| Jun  31  42  75 492
-| Jul  24  34  67 436
-| Jan  21  36  64 620

こう書いても良い。

awk '{ if ($1 ~ /J/) print }' inventory-shipped

以下の例はexp(文字列として扱われる)という式が regexpにマッチしないときに真となる。次に挙げる例では、最初のフィールドに大文字の `J'を含まない入力レコードすべてを選択する。

exp !~ /regexp/

以下の例は、すべての入力レコードのうち第一フィールドに大文字の`J'を含んでいないものを取り出す。

$ awk '$1 !~ /J/' inventory-shipped
-| Feb  15  32  24 226
-| Mar  15  24  34 228
-| Apr  31  52  63 420
-| May  16  34  29 208
…

正規表現が/foo/のようにスラッシュで囲まれて記述されたとき、これを正規表現定数(regexp constant)と呼ぶ。これは5.27のような数値定数や "foo"のような文字列定数のようなものである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.2 エスケープシーケンス

一部のキャラクタは、"foo"のような文字列定数や /foo/のような正規表現定数にそのままの形で含める事ができない。このようなキャラクタは、キャラクタそのものではなくバックスラッシュ(`\'で始まるエスケープシーケンス)を代わりに使うことで文字列などに含めることができる。エスケープシーケンスの一つの用途は文字列定数に二重引用符を含めるためである。生の二重引用符は文字列の終端になってしまうため、それが二重引用符のキャラクタそのものであることを明示するために `\"'を使わなければならない。例を挙げよう。

$ awk 'BEGIN { print "He said \"hi!\" to her." }'
-| He said "hi!" to her.

バックスラッシュキャラクタそれ自身は、そのまま含むことのできないキャラクタである。文字列や正規表現中にバックスラッシュを一つ含めるには、 `\\' と記述する。したがって、 `"' と `\'という二つのキャラクタからなる文字列は "\"\\"と記述しなければならない。

もう一つのバックスラッシュの用途は、タブとか改行のような非印字キャラクタ (unprintable characters)を表すためのものである。非印字キャラクタをそのまま文字列定数や正規表現定数に含めてしまうと多分見づらくなってしまう。

以下にawkで使われる全てのエスケープシーケンスを挙げる。特に断りがない限り、これらのエスケープシーケンス全ては文字列定数と正規表現定数の両方に適用される。

\\: `\'そのもの。
\a: ``警告''キャラクター。Ctrl-gであり、ASCIIのcode 7 (BEL) (通常は何らかの音が出る')。
\b: 後退。Ctrl-hであり、ASCII の code 8 (BS)
\f: 改ページ。Ctrl-lであり、ASCII の code 12 (FF)
\n: 改行。Ctrl-jであり、ASCII の code 10 (LF)
\r: 復帰。Ctrl-mであり、ASCII の code 13 (CR)
\t: 水平タブ。Ctrl-iであり、ASCII の code 9 (HT)
\v: Vertical tab, Ctrl-k, ASCII code 11 (VT). 垂直タブ。Ctrl-kであり、ASCII の code 11 (VT)
\nnn: 八進数値nnnの値。nnnは`0'から`7'までの数字の一つから三つの並び。 ASCIIのESC(エスケープ)キャラクタのコードは `\033'である。
\xhh…: 十六進数値hhの値。 hhは十六進文字(`0'から`9' までと、 `A'から`F'もしくは`a'から`f')。 ISO Cと同様に、最初の非十六進文字が見つかるまでエスケープシーケンスは連続しているものとみなされる。しかしながら、二文字を越える十六進文字列はどのような結果になるかは未定義である (`\x'エスケープシーケンスはPOSIXのawkでは許されていない)。
\/: 文字としてのスラッシュ(正規表現定数に対してのみ必要)。これはスラッシュを正規表現定数に含めたいときに使用する。正規表現がスラッシュで終端するので、 awkに残りの正規表現を処理し続けるのを指示するのにエスケープしてスラッシュをパターンの一部にする必要がある。
\": 二重引用符そのもの(文字列定数に対してのみ必要)。これは二重引用符を文字列定数に含めたいときに使用する。文字列が二重引用符で終端するので、文字列の残りを awkに処理し続けるのを指示するのに、エスケープしてダブルクォートを文字列の一部にする必要がある。

gawkでは、正規表現中で特別な意味を持つバックスラッシュで始まる二文字のエスケープシーケンスが幾つか追加されている。 See section gawk固有の正規表現演算子.

正規表現では、gawk固有の正規表現演算子のリストにも先のリストにもないバックスラッシュが先行したキャラクタはそれが通常は正規表現演算子であるとしてもリテラルとして扱われる。たとえば、/a\+b/は三つのキャラクタの並び`a+b'にマッチする。

完全な互換性を保つため、先のリストにないキャラクタの前にバックスラッシュを置かないこと。

まとめ

先の一覧にあるエスケープシーケンスは文字列でも正規表現でも常に最初に処理される。これは非常に早い段階、awkがプログラムを読み込んだ時点で行われる。
gawkは正規表現定数と動的正規表現(see section 動的正規表現を使う)の両方でgawk固有の正規表現演算子にある特別な演算子を処理する。
バックスラッシュが前置されたその他のキャラクタはそのキャラクタそのものとして扱われる。

Advanced Notes: Backslash Before Regular Characters

もしバックスラッシュを先のリストにはないキャラクタの前に置いた場合、 POSIX のawkではその場合の動作は未定義である。このとき二つの選択肢がある。

Strip the backslash out
バックスラッシュを取り除く。: これはUnixのawkとgawkの両方が行っている。たとえば、"a\qc" は "aqc"と等しい (これは安易なバグを持ち込みやすく、間違いやすいのでgawkは警告する)。フィールドセパレータとして空白に囲まれた垂直バーを使おうとして `FS = "[ \t]+\|[ \t]+"'としたときを考えてみよう。これは`FS = "[ \t]+\\|[ \t]+"'と二つのバックスラッシュを使うべきである。
バックスラッシュをそのままにしておく: その他の一部のawkの実装でこれが使われている。この場合、"a\qc"はa\\qc"としたときと同じになる。

Advanced Notes: メタキャラクタのエスケープシーケンス

八進や十六進のエスケープを使用して正規表現のメタキャラクタを表すシーケンスを記述したとき (正規表現演算子)、 awkはそのようなキャラクタを文字として見るのだろうか? それとも正規表現の演算子と見るのだろうか?

このようなキャラクタは伝統的にその文字そのものとして扱われる。 (d.c.) しかし、POSIX標準ではこれはメタキャラクタであるかのように扱うよう指示されており、 gawkの振る舞いもそうなっている。ただし互換モード (see section コマンドラインオプション)では、 gawkは正規表現定数中で八進や十六進のエスケープシーケンスによって表現されたキャラクタは文字そのものとして扱われる。したがって、/a\52b/は/a\*b/と等価である。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.3 正規表現演算子

以下に挙げるような正規表現演算子(regular expression operators) とかメタキャラクタ(metacharacters) と呼ばれる正規表現の記述力を増加させるようなキャラクタを使って、正規表現式を組み合わせることができる。

エスケープシーケンスで説明されているエスケープシーケンスは正規表現の中でも使うことができる。それらは先頭に`\'が置かれている。正規表現の処理に先立ってこのようなエスケープシーケンスは解析されて、そのシーケンスの表すキャラクタに置きかえられる。

以下はメタキャラクタの一覧である。エスケープシーケンスではなくかつこの一覧にないキャラクタはすべて、それ自身を表すキャラクタである。

\

これはマッチングのときにあるキャラクタの特殊な意味を抑制するために使用する。例えば、`\$'は`$'というキャラクタにマッチする。

^

これは文字列の先頭にマッチする。例えば、`^@chapter' は文字列の先頭にある`@chapter'にマッチする。これは Texinfoファイルで章の先頭を見つけるのに使用できる。 `^'は文字列の先頭部分にのみマッチさせるのに使う目印であるので、アンカー(anchor)として知られている。

`^'は文字列中にある行(line embedded in a string)の先頭にはマッチしないことに注意。次の例の条件式は真にはならない。

if ("line1\nLINE 2" ~ /^L/) …

$

これは`^'に似ているが、文字列の最後にマッチする。例えば、 `p$' は`p'で終わるレコードにマッチする。 `$'もアンカーであり、文字列中の行末にはマッチしない。例えば、

if ("line1\nLINE 2" ~ /1$/) …

この条件式は真にはならない。

.

ピリオド、あるいはドットは改行を含む任意のキャラクタにマッチする。例えば、`.P' は`P'が後に続く任意の一文字にマッチする。連接を使うことによって、`U.A'のような `U'で始まり`A'で終わる任意の三文字の並びにマッチするような正規表現を作ることができる。

厳密なPOSIXモード(see section コマンドラインオプション)では、 `.'はすべてのビットが0であるキャラクタ、NULにはマッチしない。しかしながら、NULは単にもう一つのキャラクタである。他のバージョンのawkでは、 NULキャラクタにはマッチさせることができない。

[…]

これはキャラクタリスト(character list)と呼ばれるものである (13)。これはブラケットに囲まれているキャラクタのいずれか一つとマッチする。例えば、`[MVX]' は文字列中にある`M', `V', `X'のいずれかのキャラクタとマッチする。キャラクタリストの使用にブラケットの内側で使うことのできるものの詳細な説明がある。

[^ …]

これはキャラクタリストの補集合(complmented character list)である。 `['の直後のキャラクタは `^'でなければならない。これはブラケットの中にあるキャラクタ以外の任意のキャラクタにマッチする。たとえば`[^awk]'は`a'、`w'、`k'以外のキャラクタにマッチする。

|

これは選択演算子(alternation operator)であり、選択を行うのに使用する。 `|'は正規表現演算子の中で最も低い優先順位を持つ。たとえば、`^P|[[:digit:]]'は`^P'か`[[:digit:]]'のいずれかにマッチする。つまり、`P'で始まるものか数字を含むものにマッチする。

選択はその両辺の可能な限り大きな部分式に対して適用される。

(…)

カッコは正規表現を(算術式のときと同じ様に)グループとする為に使用される。これは選択演算子`|'を含んだ正規表現を連結する為に使う事ができる。たとえば、`@(samp|code)\{[^}]+\}'は `@code{foo}'にも`@samp{bar}'にもマッチする (これはTexinfoのフォーマット制御シーケンスである。`+'は後述する)。

*

このシンボルはその前に置かれている正規表現の必要な限りのくり返しにマッチする。例えば `ph*'では`*'はその前にある`h'に適用され、一文字の`p'に続いて任意の数の`h'がある文字列にマッチする。これは`p'だけで`h'が一個もないようなパターンにもマッチする。

`*'のくり返しは可能なかぎり最も小さな式が採用される (もしより大きな式を繰り返したいのならば括弧を使えばよい) 。そしてその式は可能な限り大きなくり返しを見つけだす。例えば、 `awk '/$c[ad][ad]*r x$/ { print }' sample' は `sample'中のレコードのうち、 `(car x)', `(cdr x)', `(cadr x)' のような文字列を含むものを全て出力する。カッコの前にバックスラッシュをつけてエスケープしていることに注意。

+

このシンボルは`*'と似ているが、先行する部分正規表現が少なくとも一回マッチしなければならない。つまり、 `wh+y' でいうと、`wh*y'ではすべてマッチしていた `why' や `whhy'、`wy'のうち、前者二者にはマッチするが、最後のものにはマッチしないということである。次の例は、`*'で最後に挙げた例を書き直したものである。

awk '/\(c[ad]+r x\)/ { print }' sample

?

このシンボルは`*'と似ているが、先行する部分正規表現がないか、一回だけのときにマッチする。例えば `fe?d' は `fed'や`fd'にマッチするが、それ以外にはマッチしない。

{n}

{n,}

{n,m}

interval expresionのブレースの内側には、一つか二つの数値がある。もしブレースの中に数値が一つだけならば、直前の正規表現がn回繰り返される。もしカンマに区切られて数値が二つあれば、直前の正規表現が n回からm回繰り返される。カンマの後ろに数値が一つだけならば、直前の正規表現が少なくともn回繰り返される。

wh{3}y: これは`whhhy' にマッチするが、 `why' や `whhhhy'にはマッチしない。
wh{3,5}y: これは `whhhy' か `whhhhy' か `whhhhhy'のいずれかのみにマッチする。
wh{2,}y: `whhy' や `whhhy'などにマッチする。

POSIX標準の一部として、 awkとegrepとほかのユーティリティとの一貫性のためこれが追加された。

しかしながら、古いプログラムでは`{'や`}'を正規表現定数の中で使っているかもしれないので、 gawkはデフォルトでは正規表現中の interval expressionsはマッチしない。 `--posix'オプションか `--re-interval'オプション (see section コマンドラインオプション) が指定されると、 interval expressionsを正規表現として使うことができるようになる。

正規表現定数で`{'や`}'を使った新しいプログラムでは、それらを常にバックスラッシュでエスケープすると良いだろう。こうすることによりその正規表現定数はどのバージョンのawkを使ってもあなたの望んだとおりに動くようになる。 (14)

正規表現では、`*', `+', `?'といった演算子は `{' や `}'と同じ優先順位を持ち、最も高い。続いて連接があり、最後に`|'がある。算術式と同じように、カッコはそれで括った演算子の優先順位を変更することができる。

POSIXのawkとgawkでは、`*'、`+'、`?' といった演算子はそれに先行する正規表現がない場合にはそれ自身を表す。たとえば`/+/'はリテラルの`+'にマッチする。しかしながら、他の多くのawk処理系ではこれは構文エラーとみなされる。

gawkが互換モード(see section コマンドラインオプション)で動作している場合には、 POSIXキャラクタクラスとinterval式は正規表現中で使うことができなくなる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.4 キャラクタリストの使用

キャラクタリストの中では、範囲式(range expression)はハイフンで区切られた二つのキャラクタからなる。これは現在のロカールの照合シーケンスとキャラクタセットを使って、二つのキャラクタの間に存在する任意の1キャラクタにマッチする。たとえば、デフォルトのC ロカールでは、`[a-dx-z]' は `[abcdxyz]' と等価である。多くのロカールはキャラクタを辞書順にソートしているので、そういったロカールでは`[a-dx-z]' は `[abcdxyz]'と等価ではなくなる。その代わりにたとえば `[aBbCcDdxXyYz]' と等価になる。伝統的なブラケット式の解釈を得るために、環境変数 LC_ALLに値 `C'を設定することによってC ロカールを使うことができる。

`\', `]', `-', `^' といったキャラクタをキャラクタリスト中に置くには、その前に`\'を置く。例を挙げよう:

[d\]]

これは `d' か `]'にマッチする。

キャラクタリスト中の `\' の扱いは他の awk の実装や POSIX の要求に従ったものである。awk の正規表現は POSIX の定義する拡張正規表現(Extended Regular Expressions、 EREs)のスーパーセットである。POSIX の拡張正規表現は伝統的な egrep ユーティリティが受け付ける正規表現に基づいている。

キャラクタクラスは POSIX 標準によって導入された新しい機能である。キャラクタクラスは特別な属性を持つキャラクタリストを表す特殊な記法であるが、実際のキャラクタは国ごと、またはキャラクタセットごとに異なるものとなる可能性がある。たとえば、アルファベットは米国とフランスでは異なるものである。

キャラクタクラスはキャラクタリストのブラケットの内側でのみ正当である。キャラクタクラスは`[:'、クラスを表すキーワード、`:]'から構成される。table-char-classesは POSIX 標準で定義されるキャラクタクラスのリストである。

`Class`	`Meaning`

`[:alnum:]`	`アルファベットまたは数字。`
`[:alpha:]`	`アルファベット。`
`[:blank:]`	`スペースまたはタブ。`
`[:cntrl:]`	`制御文字。`
`[:digit:]`	`数字。`
`[:graph:]`	印字可能かつ可視のキャラクタ。 (スペースは印字可能であるが可視ではない。`a' は印字可能かつ可視である)
`[:lower:]`	`アルファベットの小文字。`
`[:print:]`	`印字可能なキャラクタ (制御文字でないキャラクタ)。`
`[:punct:]`	`Punctuation characters (文字、数字、制御文字、スペースでないキャラクタ)。`
`[:space:]`	`空白 (スペース、タブ、改ページ)。`
`[:upper:]`	`アルファベットの大文字。`
`[:xdigit:]`	`十六進の数字。`

Table 2.1: POSIX Character Classes

たとえば、POSIX 標準以前は、アルファベットと数字にマッチさせるのに /[A-Za-z0-9]/と記述する必要があった。もし別のアルファベットがあった場合にはそれはマッチしなかったし、ASCII ではないキャラクタセットを照合している場合には ASCII の alphanumeric なキャラクタにマッチしなかったかもしれない。POSIX のキャラクタクラスを使うことによって、使用しているキャラクタセットにおけるアルファベットとキャラクタにマッチするものとして /[[:alnum:]]/と記述することができる。

さらにキャラクタリスト中に現れる二つの特殊なシーケンスがある。これらは非ASCIIキャラクタセットに適用され、二文字以上で表される単一のシンボル(照合要素 collating elements)を持つことができる。これらはまた照合や並び替えのための等価なキャラクタを持つ (たとえばフランス語では、生の ``e'' と grave-accent のついた ``è'' は等価である)。これらのシーケンスは以下のとおり:

照合要素(Collating symbols): [ch] is a regexp that matches either `c' or `h'. 複数キャラクタの照合要素は`[.' と `.]' に囲まれる。たとえば`ch' が照合要素であった場合、[[.ch.]] はこの照合要素にマッチする正規表現であるのに対して [ch] は`c'もしくは`h'にマッチする正規表現である。
等価クラス(Equivalence classes): キャラクタの等価なもののリストのためのロカール固有の名前である。この名前は `[=' と `=]' で囲まれる。たとえば、`e' という名前は ``e''、 ``è'' 、``é'' のすべてを表すのに使われるかもしれない。この場合、[[=e=]] は`e', `é', `è' のいずれかにマッチする正規表現である。

これらの機能は非英語圏のロカールにおいて非常に便利である。

警告: gawkが使っている正規表現マッチングのためのライブラリ関数は現在のところPOSIXのキャラクタクラスのみを認識し、照合要素や等価クラスは認識しない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.5 `gawk`固有の正規表現演算子

正規表現を扱う GNU ソフトウェアは多くの正規表現演算子を追加している。これらの演算子はこのセクションで説明され、gawkに固有のものである。これらの演算子は他の awk 処理系では使うことができない。追加された演算子のほとんどは単語マッチングを扱うものである。ここで、単語とは、一つ以上の文字、数字、アンダースコア(`_')の並びである:

\w: 任意の単語を構成するキャラクタ --- つまり、任意の文字、数字、アンダースコアにマッチする。[[:alnum:]_]の短縮記法と考えるとよい。
\W: 単語を構成しない任意のキャラクタにマッチする。 [^[:alnum:]_]の短縮記法。
\<: 単語の先頭にある空文字列にマッチする。たとえば、/\<away/ は `away' にマッチするが `stowaway'にはマッチしない。
\>: 単語の終端にある空文字列にマッチする。たとえば、/stow\>/ は `stow' にマッチするが `stowaway' にはマッチしない。
\y: 単語の先頭もしくは終端にある空文字列にマッチする。たとえば、 `\yballs?\y' は独立した単語の `ball' もしくは `balls' にマッチする。
\B: 単語を構成するキャラクタ二つの間の空文字列にマッチする。 /\Brat\B/ は `crate' にマッチするが `dirty rat' にはマッチしない。`\B' は `\y' の反対である。

バッファ上で働く二つの演算子がある。Emacs では、バッファは Emacs のバッファである。gawk の正規表現ライブラリルーチンはバッファとして文字列全体を扱う。二つの演算子は次の通り:

\`: バッファ(文字列)の先頭にある空文字列にマッチする。
\': バッファ(文字列)の終端にある空文字列にマッチする。

`^' や `$' は常に文字列の先頭や終端に対して働くので、これらの演算子は何の機能もawkに追加しない。これらは他の GNU ソフトウェアとの互換のために提供されている。

他の GNU ソフトウェアでは、単語境界の演算子は `\b' である。しかしながら、これはバックスペーストして定義されている awk 言語と衝突する。このため、gawk は別の文字を使っている。別の選択肢としては、GNU の演算子には二つのバックスラッシュを要求するというやり方もあったが、これは混乱を招く。現在の、GNU の `\b'を `\y' で代替するのはややましな方法である。

control how gawk interprets characters in regexps: gawk での正規表現中のキャラクタの解釈を制御する幾つかのコマンドラインオプションがある(see section コマンドラインオプション):

オプションなし: デフォルトでは、POSIX の正規表現と先に説明した GNU の正規表現演算子正規表現演算子で説明した GNU の正規表現演算子が使える。しかしながら、interval expressions はサポートされない。
--posix: POSIX の正規表現だけがサポートされる。GNU の演算子は特別な意味を持たない(たとえば、`\w' がリテラルの `w'にマッチする)。 Interval expression を使うことができる。
--traditional: 伝統的な Unix の awk の正規表現が使える。 GNU の演算子は特別な意味を持たず、interval expressions や POSIX のキャラクタクラス ([[:alnum:]]など)は使えない。八進表記や十六進表記のエスケープシーケンスは、それが正規表現のメタキャラクタを表すものであってもリテラルとして扱われる。
--re-interval: `--traditional' が指定された場合でもinterval expressionの使用を許可する(`--posix' は自動的にinterval expressionsを有効にする。このため、`--posix'が使われている場合には`--re-interval'は余計である)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.6 Case Sensitivity in Matching

正規表現における大小文字の違いは、通常のキャラクタ(メタキャラクタでないもの) とキャラクタセットのマッチング両方で区別される。したがって、正規表現中の`w'は小文字の`w'にのみマッチし、大文字の`W'にはマッチしない。

大小文字を区別しないマッチングの最も簡単な方法は、`[Ww]'のようにキャラクタリストを使うというものである。しかしながらこれは頻繁に使うときには扱いにくいものであり、正規表現を読みづらいものにしてしまう。より良いであろう回避策が二つある。

プログラムの特定の場所で大小文字を区別しないマッチングを行う方法の一つが対象となるデータの大小文字をtolowerやtoupperといった組み込みの文字列関数(まだ説明していない。see section 文字列操作関数)を使って正規化してしまうということである。たとえば

tolower($1) ~ /foo/  { … }

これは第一フィールドを、それに対してマッチングを行う前に小文字に変換している。これはPOSIX準拠のawkで動作する。

もう一つの、gawkに固有のやり方は IGNORECASEという変数(see section 組み込み変数)にゼロ以外の値をセットするというものである。 IGNORECASEにゼロ以外がセットされたとき、すべての正規表現演算及び文字列演算において大小文字の違いが無視される。 IGNORECASEの値の変更はプログラムの実行時に大小文字に関する動作を動的に制御する。 IGNORECASEはほとんどの変数がそうであるように初期値がゼロであるので、デフォルトでは大小文字の違いは有効である。

x = "aB"
if (x ~ /ab/) …   # このテストは失敗する

IGNORECASE = 1
if (x ~ /ab/) …   # 今度は成功する

一般的には、IGNORECASSEを一部のルールで大小文字の違いを無視し、それ以外のルールでは違いを有効にするようにするために使うことはできない。なぜなら、IGNORECASEを特定のルールのパターンのためにセットする直接のやり方がないからである。 (15)

IGNORECASEは、コマンドラインやBEGINルールの中で設定することができる(see section その他のコマンドライン引数、see section スタートアップとクリーンアップのアクション)。コマンドラインからIGNORECASEを設定することはプログラムを編集することなく大小文字を無視するようにする方法である。

gawkの3.0より前では、IGNORECASEの値は正規表現操作に対してのみ影響を及ぼしていて、 `=='や`!='などの文字列比較には影響しなかった。バージョン 3.0 から、正規表現と文字列比較の両方の操作に IGNORECASEが影響するようになった。

gawk 3.0から、大文字と小文字の間の等価性はISO-8859-1(ISO Latin-1) キャラクタセットに基づいたものになっている。このキャラクタセットは伝統的な128のASCIIキャラクタセットのスーパーセットであり、ヨーロッパで使われるキャラクタの多くを提供している。

gawk 3.1.4 では、大小文字の違いはロカールを意識するようになった。これはisalpha()やtouuper()のような、 Cの<ctype.h>機能に基づくものである。

IGNORECASEの値はgawkが互換モード(see section コマンドラインオプション) のときは何の効果も及ぼさない。互換モードでは大小文字は常に区別される。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.7 どのくらいテキストがマッチするか?

以下の例について考えてみよう

echo aaaabcd | awk '{ sub(/a+/, "<A>"); print }'

これはsub関数(まだこれは説明していない。see section 文字列操作関数) を使って入力レコードを変更する例である。ここで、/a+/という正規表現は``一つ以上の`a'''を表しており、それにマッチするテキストを``<A>'に置き換えるというものである。

入力には四つの`a'がある。出力はどうなるだろうか? awk(とPOSIX)の正規表現は、常にマッチするもののうち最も左にあり、最も長いキャラクタの並びにマッチする (最左最長一致)。したがって、この例では四つの連続した`a'が(一つの)`<A>'に置き換えられる。

$ echo aaaabcd | awk '{ sub(/a+/, "<A>"); print }'
-| <A>bcd

単純にマッチする/しないをテストするときには今述べた事はさして重要ではない。しかし、正規表現に基づいたフィールドやレコードの分割、そしてmatch, sub, gsub, gensub といった関数を使用してテキストのマッチングや置き換えをする場合には非常に重要である。この原則を理解する事は正規表現に基づいたレコード/フィールドの分割のためにも重要である (see section 入力がどのようにレコードに分割されるかおよびsee section フィールドがどのように分割されるかを特定する)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.8 動的正規表現を使う

`~'演算子や`!~'演算子の右辺に置くものは正規表現定数 (スラッシュの間に置かれた文字列)である必要はなく、任意の式を置くことができる。そのような式は評価され、必要があれば文字列に変換される。評価され変換が行なわれた結果は正規表現として扱われる。このように演算が行われる正規表現は動的正規表現(dynamic regular expression)と呼ばれる。例を挙げよう。

BEGIN { digits_regexp = "[[:digit:]]+" }
$0 ~ digits_regexp    { print }

これはdigits_regexpに一つ以上の数字を表す正規表現をセットしてそれを入力レコードに対してマッチングしている。

警告: `~'演算子や`!~'演算子を使った場合、スラッシュで囲まれた正規表現定数と二重引用符で囲まれた文字列定数とでは違いがある。文字列定数を使おうとする場合、文字列が二度走査されることを理解する必要がある。一度目はawkがプログラムを読み込んだときで、二度目は演算子の左側に置かれた文字列と右側のパターンとのマッチングを行うときである。これは式として評価される(先の例で言う digits_regexpのように) 任意の文字列において真であり、文字列定数そのものにはあてはまらない。

文字列が二度走査されることによる違いとはなんだろうか? その答えはエスケープシーケンス、特にバックスラシュの振る舞いにある。正規表現を通して文字列中にあるバックスラッシュを得るには、二つのバックスラッシュを置かなければならない。

例えば、/\*/ は `*'という文字にマッチする正規表現定数であり、これはバックスラッシュ一つを必要とする。同じものを文字列を使って行うには、"\\*"としなければならないだろう。最初のバックスラッシュは二個めのバックスラッシュをエスケープするものであり、これによってこの文字列は`\'と`*'という二つのキャラクタからなる文字列となる。

正規表現を記述するのに正規表現定数と文字列定数の両方が使えるとき、どちらを使ったほうが良いのだろうか? その答えは``正規表現定数''である。以下にその理由を挙げる。

文字列定数のほうが記述するのに面倒であり、また読みにくい。正規表現定数を使うことはエラーを招きにくくする。これら二種類の定数の違いを理解しないことはエラーの発生源である。
正規表現定数を使ったほうが効率が良い。そうすることでawkはあなたが記述した正規表現に注意することができ、そしてそれをより効果的にパターンマッチングするための内部的な表現で格納する事ができるようになる。文字列定数を使った場合、awkはまず初めに文字列を内部表現に変換しなければならず、その後でパターンマッチングを行う。
正規表現定数を使ったほうが良いスタイルであり、そのほうが正規表現のマッチで何をさせようとしているかが明確になる。

Advanced Notes: 動的正規表現のキャラクタリストで `\n` を使う

一部の商用 awk では動的正規表現のキャラクタリストの中で改行を使うことを許していない:

$ awk '$0 ~ "[ \t\n]"'
error--> awk: newline in character class [
error--> ]...
error-->  source line number 1
error-->  context is
error-->          >>>  <<<

しかし正規表現定数中の改行には問題はない:

$ awk '$0 ~ /[ \t\n]/'
here is a sample line
-| here is a sample line
Ctrl-d

gawk does not have this problem, and it isn't likely to occur often in practice, but it's worth noting for future reference.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

2.9 Where You Are Makes A Difference

[訳注] Windows版では関係ありません。

現代的なシステムでは、ロカール(locales)をサポートしている: システムに対してその地域のキャラクタセットや言語を知らせるものである。カレントのロカール設定は正規表現マッチングの動作に影響を及ぼし、しばしば驚きの元となる。特に、多くのロカールではあなたが大小文字いずれかのキャラクタを特定していたとしても大小文字の違いを無視したマッチングを行う。

以下に挙げた例はsub関数を使ったもので、テキストの置き換えを行うものである(see section 文字列操作関数)。ここで、行末にある大文字のキャラクタ列を取り除こうとしている:

$ echo something1234abc | gawk '{ sub("[A-Z]*$", ""); print }'
-| something1234

`something1234abc'の末尾にある`abc'は通常は`[A-Z]*'にマッチすべきでないのでこの結果は予期しないものである。これはロカール設定によるものである(したがってあなたの使っているシステムによってはこのような結果にはならないだろう)。対応策は二つある。一つ目はPOSIXのキャラクタクラス`[[:upper:]]'を `[A-Z]'の代わりに使うというものである。二つ目は、ロカール設定をgawkを実行する前に変更してしまうというものである:

LANG=C LC_ALL=C
export LANG LC_ALL

`C'という設定はgawkに伝統的なUnixでのやり方、つまり大小文字を区別するという動作を強制する。あなたはこれらの文をシェルのスタートアップファイル(`$HOME/.profile'など) に追加しようと考えるかもしれない。

同様なことが別の範囲についても存在する。たとえば、 `["-/]'はASCIIにおいては完全に合法なものであるが、 `en_US.UTF-8'のような多くのUnicodeロカールにおいては正当なものではない (一般的には、このような範囲は使うべきではない。代わりにここのキャラクタを並べたリストか、`[[:punct:]]'のような POSIXのキャラクタクラスを使用する)。

`RS = "\n"'は通常の場合、ロカールは無関係なものである。 `LC_ALL=C'を使ったその他の単一バイトのレコードセパレータはレコードの読み込みの際によりよいパフォーマンスをもたらすだろう。そうでなければ、gawkはレコードを区切りを探すために入力されるキャラクタごとに幾つかの関数呼び出しを行わねばならない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3. 入力ファイルを読む

典型的なawkプログラムでは、すべての入力は標準入力 (デフォルトではキーボードだが、ほとんどの場合は他のコマンドからのパイプ)かコマンドラインで指定した名前を持つファイルのどちらかから読み込まれる。入力ファイルを指定している場合、 awkは指定した順番に従ってすべてのファイルからデータの読み込みを行う。ある時点で処理している入力ファイルのファイル名は組込み変数FILENAME(see section 組み込み変数)から得ることができる。

入力はレコードと呼ばれる単位で読み込まれ、プログラムに記述されたルールに従い、一度に一つのレコードを処理する。デフォルトでは各レコードはひとつの行である。各レコードはフィールドと呼ばれる塊に自動的に分割される。これはあるレコードの一部分について作業を行うプログラムに便利である。

まれに特別な場合に、getlineコマンドを使う必要にせまられることがあるだろう。 getlineコマンドは任意の数のファイルから陽に入力を行うことを可能にし、コマンドライン上で名前を指定しなくてもファイルから読み込みができるので重宝する (see section getlineを使った入力)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.1 入力がどのようにレコードに分割されるか

awkユーティリティはawkプログラムに対する入力をレコードとフィールドに分割する。 awkは現在処理している入力ファイルから読み出したレコードの数を記録している。この値は組み込み変数FNRに格納されている。これは新たなファイルを処理し始めたときにはゼロにリセットされる。別の組み込み変数にNRがある。これはすべてのデータファイルから読み出した入力レコードの数を格納している。変数の値はゼロから始まるがリセットされることはない。

レコードはレコードセパレータと呼ばれるキャラクタによって分割される。デフォルトでは、レコードセパレータは改行キャラクタである。これはデフォルトではレコードが単一の行であるからである。組込み変数のRSに値をセットすることによって、レコードセパレータを別のキャラクタにすることができる。

他の変数と同じように、RSはawkプログラムの中で代入演算子`='(see section 代入式)を使うことによってその値を変更することができる。新たなレコードセパレータのキャラクタは文字列定数を表すクォーテーションマークで囲まれているべきである。代入を行う正しいタイミングはほとんどの場合実行の最初、何らかの入力が行われる前である。これにより一番最初のレコードが正しい区切りによって読み込まれる。これを行うためには、特殊なBEGINパターンを使用する (see section 特殊パターン BEGIN と END)。例えば:

awk 'BEGIN { RS = "/" }
     { print $0 }' BBS-list

この例では、入力を行う前にRSに値を"/"に変更している。これはスラッシュが先頭にある文字列であり、結果としてレコードはスラッシュで分割される。その後で入力ファイルが読み込まれ、 awkプログラムの二番目のルール(パターンのないアクション) によって各レコードが出力される。各print文はその出力の最後に改行を追加するので、このawkプログラムは入力のスラッシュを改行に変換してコピーする。次にこのプログラムを `BBS-list'に対して実行したときの結果を示す:

$ awk 'BEGIN { RS = "/" }
>      { print $0 }' BBS-list
-| 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
-|

the line looks like this: `camelot' BBS のエントリが分割されていないことに注意。元のデータファイル (see section 例のためのデータファイル)では、このような行だった。

camelot      555-0542     300               C

他の二つ以上のボーレートを持つところとは異なりそこにはボーレートが一つだけしかなく、スラッシュがレコード中にない。事実、このレコードは`core' BBSのためのレコードの一部として扱われている。出力の中で区切っている改行は元々データファイルの中にあった改行で、awkがレコードを出力するときに付加したものではない!

レコードセパレータを変更するもう一つのやり方は、コマンドライン上で変数代入の機能を使うことである (see section その他のコマンドライン引数):

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

これは`BBS-list'を処理する前にRSに`/'をセットする。

`/'のような一般的でないキャラクタをレコードセパレータに使うことは、ほとんどすべての場合に正しい結果を生じる。しかしながら、以下の様な(極端な)パイプラインでは、意外にも`1'が出力される。そこには改行からなる一つのフィールドがある。

$ echo | awk 'BEGIN { RS = "a" } ; { print NF }'
-| 1

ここには改行からなる一つのフィールドがある。組込み変数 NF の値はカレントレコードのフィールドの数である。

入力ファイルの終端に達すると、そのファイルの最後のキャラクタが RSにあるキャラクタでなくてもカレント入力レコードを終端する (d.c.)。

空文字列""(キャラクタが何もない文字列)は、 RSの値としては特別な意味を持っている。それは、レコードを一行以上の空行で区切るということである。詳しくはSee section 複数行レコード.。

awkの実行中にRSの値を変更した場合、その新しい値は後続のレコードの区切りに使用されるが、現在処理されているレコード(と既に処理されたレコード) にはなんの影響も及ぼさない。

レコードの区切りが終了した後で、gawkは RSにマッチした入力中のテキストを RT という変数にセットする。 gawkを使っているときにはRSの値は一文字に限定されるものではなく、任意の正規表現 (see section 正規表現)を使用することができる。一般的には各レコードの終端にはその正規表現にマッチした文字列が続いており、次のレコードはマッチした文字列の終端の次から始まる。この一般的なルールは通常のRSが改行だけからなっているようなときにはうまく働く。レコードは次のマッチする文字列の先頭(入力の次の改行)で終わり、続くレコードはこの文字列のすぐ後(続く行の先頭のキャラクタ)から始まる。改行はRS にマッチするので、いずれのレコードの一部分にもならない。

RSが単一のキャラクタであったとき、 RTはそれと同じキャラクタ一文字になる。しかし、RSが正規表現であるとき、RTはもっと便利になる。つまり、実際に正規表現にマッチした入力テキストが格納されるのである。

次に挙げる例はこれらの機能を両方とも説明している。RSは改行にも、 (前後に連続した空白が付いてもよい)一つ以上の連続した大文字にもマッチする正規表現がセットされている:

$ echo record 1 AAAA record 2 BBBB record 3 |
> gawk 'BEGIN { RS = "\n|( *[[:upper:]]+ *)" }
>             { print "Record =", $0, "and RT =", RT }'
-| Record = record 1 and RT =  AAAA
-| Record = record 2 and RT =  BBBB
-| Record = record 3 and RT =
-|

of RS as a regexp and RT. 出力の最後の行は余計な空白行がある。これは、RTの値が改行で、さらにprint文が改行を最後につけているからである。正規表現としてのRSとRTの便利な例は See section 単純なストリームエディタ.

RSに、`RS = "abc(XYZ)?"'のような省略可能な末尾を持つ正規表現をセットした場合、これは可能であるけれども実装上の制限により、gawkは正規表現の先行する部分にマッチして末尾部分を無視してしまう。特に入力テキストが長い場合。gawkはこのような問題を避けようと努力するけれども、絶対にこのような事態にならないとはいえないのである。

NOTE: awkでは、`^'や`$'といったアンカーメタキャラクターはそれぞれ文字列の始端と終端にマッチし、行の始端と終端にマッチするわけではない。結果として、`RS = "^[[:upper:]]"' のような正規表現はファイルの先頭にのみマッチする。これはgawkが入力ファイルを一つの長い文字列としてみているためで単にその中に改行が含まれているというだけのことである。したがってRSの値としてアンカーキャラクターを使わないことが一番である。

RSを正規表現として使ったりすることや、RT変数は gawkの拡張である。これらは互換モード(see section コマンドラインオプション)で使うことはできない。互換モードでは、RSの先頭のキャラクターだけがレコードの終端を決めるのに使われる。

Advanced Notes: `RS = "\0"` Is Not Portable

データファイル全体を一つのレコードとして扱いたいときがあるかもしれない。これを行うただ一つの方法は、RSに入力ファイルの中に決して現れない値を設定するというものである。これは任意の入力ファイルに対して常に動作するプログラムのような一般的なものには難しい方法である。

あなたはこの場合に、テキストファイルに対しては、全てのビットがゼロのキャラクターである NULキャラクターをRSに対して使うことが良いと考えるかもしれない:

BEGIN { RS = "\0" }  # ファイル全体が一つのレコードになる?

gawkは実際にこれを受け付け、NULキャラクターをレコードセパレーターとして使うことができる。しかしながら、このような使い方は他の実装のawkに対してポータブルなものではない。

他の全てのawkの実装(16)は文字列を内部的にはC形式の文字列として格納している。 C形式の文字列はNULキャラクターを文字列の終端として使用している。このため、`RS = "\0"' は `RS = ""'と等価となる。 (d.c.)

ファイル全体を一つのレコードとして扱う最も良いやり方は、単純にファイルを一度に一レコード読み、各レコードをひとつ前の終端につなげてしまうというものである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.2 フィールドを検査する

awkが入力レコードを読み込んだとき、そのレコードは自動的にインタープリタによって解析され、フィールドと呼ばれる塊に分割される。デフォルトではフィールドの分割は行の中にある単語のように、空白(whitespace)によって行われる。 awkでの空白は、スペースかタブ、あるいは改行の一つ以上の連なりである (17)。ほかの言語では空白とみなされるようなフォームフィードや垂直タブなどのキャラクタは、 awkの場合は空白としてはみなされない。

フィールドの目的は、レコードのこういった塊を参照するのに便利なようにするためであり、フィールドを使わなければならないというものではない。望むならレコード全体を処理することもできる。しかし、フィールドはパワフルなawkプログラムを簡単にするのである。

awkプログラム中でフィールドを参照するには、ドル記号(`$')に続けて参照したいフィールドの番号を続けることによっておこなう。したがって、$1は最初のフィールドを、$2は二番目のフィールドを参照する (Unixのシェルとは異なり、フィールド番号は一桁に限らない。$127はレコードの127番目のフィールドである)。例えば次のような行が入力されたとすると、

This seems like a pretty nice example.

この例の場合、最初のフィールドである$1の内容は`This'である。二番目のフィールド、$2の内容は`seems'というようになる。最後のフィールド$7が`example.'であることに注意して欲しい。これは、`e' と `.' の間にスペースがないためで、ピリオドは七番目のフィールドの一部であるとみなされているのである。

NFはカレントレコードにあるフィールドの数を保持する組み込み変数である。 awkはレコードの読み込みのたびにNFの値を自動的に更新する。フィールドが幾つあるかにかかわらず、あるレコードの最後のフィールドは $NFで表わすことができる。だから先程の例でいうと、$NFは $7と同じことであり、内容は `example.' になる。レコード中にフィールドが七個しかないときに $8のように最後の要素を越えて参照しようとしたときには、空の文字列が返ってくる (数値オペレーションで使用した場合にはゼロが得られる)。

$0は"0番目"のフィールドを参照するように見えるが、これは特別なケースで入力レコード全体を表わす。 $0はフィールドを気にしたくないときに使用する。さらに幾つかの例を挙げよう:

$ awk '$1 ~ /foo/ { print $0 }' BBS-list
-| 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

この例では、`BBS-list' というファイル中のレコードで、レコードの第一フィールドに `foo'という文字列を含んでいるものを出力している。 `~'という演算子はマッチング演算子(matching operator) (see section 正規表現の使い方)と呼ばれ、ある文字列(ここではフィールド$1)と与えられた正規表現とがマッチするかを検査する。

一方次の例は、レコード全体から`foo'を探して、それが見つかった入力レコードの第一フィールドと最終フィールドを出力する:

$ awk '/foo/ { print $1, $NF }' BBS-list
-| fooey B
-| foot B
-| macfoo A
-| sabafoo C

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.3 定数でないフィールド番号

フィールドの番号は定数である必要はない。あるフィールドを参照するために、 awk言語での任意の式を`$'の後で使うことができる。その式の値はフィールド番号として扱われる。このとき式が数値ではなく文字列であった場合、その式の値は数値へと変換される。例を挙げよう:

awk '{ print $NR }'

NRはそれまでに読み込んだレコードの数だということを思い出そう。一番目のレコードでは1、二番目では2…というようになる。したがってこの例は、一番目のレコードの一番目のフィールド、二番目のレコードの二番目のフィール…と出力していく。二十番目のレコードでは二十番目のフィールドが出力されることになるが、ほとんどの場合はレコードには20未満のフィールドしかないから、空白行が出力されるだろう。もう一つフィールド番号として式を使った例を挙げる:

awk '{ print $(2*2) }' BBS-list

awk は`(2*2)'という式を評価し、それからその値を出力すべきフィールドの番号として使用する。 `*'は乗算を表すので、`2*2' という式を評価すると4となる。括弧は`$'のオペレーションより先に掛け算を行わせるためである。フィールド番号を指定する式で二項演算子を使うときは常にこのようにする必要がある。この例では`BBS-list'というファイル中の全ての行の、運営時間(4番目のフィールド)を出力する (awkで使える演算子の全ては演算子の優先順位 (How Operators Nest) に一覧がある)。

フィールド番号が0になるような式を与えると、その結果はレコード全体となる。だから、 `$(2-2)'の値は$0と同じである。負の数によるフィールド番号の指定は許されおらず、もしそういったフィールドを参照しようとすると、通常はawkプログラムの実行が中断される (POSIXの標準では、負のフィールド番号を参照したときの動作は定義されていない。 gawkではこれを通知して、プログラムを終了する。他のawk処理系では違った動作をするかもしれない)。

フィールドを検査するで述べられているように、カレントレコードのフィールド数は組込み変数の NF (see section 組み込み変数)に格納されている。 $NFという式は特別な機能ではなく、NFを評価して、その値をフィールド番号として使った結果である。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.4 フィールドの内容を変更する

awkプログラムの中でフィールドの構成を変更することができ、それによってawkはカレント入力レコードが変更されたと認識する (実際の入力には影響ない。awkは決して入力ファイルを変更しない)。以下のプログラムの出力を考えてみよう:

$ awk '{ nboxes = $3 ; $3 = $3 - 10
>        print nboxes, $3 }' inventory-shipped
-| 25 15
-| 32 22
-| 24 14
…

このプログラムは最初に変数nboxesに三番目のフィールドの元の値を保存している。`-'記号は減算の記号であるので、このプログラムは三番目のフィールド$3に`$2 - 10'、つまり二番目のフィールドの値から10を引いた値をセットする (See section 数学的演算子.)。それから二番目のフィールドと新しい三番目のフィールドが出力される (Someone in the warehouse made a consistent mistake while inventorying the red boxes.)。

これがきちんと動作するには、フィールド$2のテキストは数として意味のあるものでなければならない。 (フィールドの)文字列は算術演算を行うために数値に変換される。引き算の結果(の数値)は再度文字列に変換されて、第三フィールドになる。 See section 文字列と数値の変換.

あるフィールドの値を変更した(awkがそう認識した)とき、入力レコードのテキストは新しいフィールドが古いフィールドのところにあるように再演算が行われる。そのため、 $0がフィールドの変更を反映して変化するのである。したがって、次のプログラムは、入力ファイルのデータの各行の第二フィールドが入力ファイルにあったものから10を引いたものに置き換えられた結果を出力するのである:

$ awk '{ $2 = $2 - 10; print $0 }' inventory-shipped
-| Jan 3 25 15 115
-| Feb 5 32 24 226
-| Mar 5 24 34 228
…

最大のフィールド番号より大きい、存在しないフィールドに対する代入も可能である。例を挙げよう

$ awk '{ $6 = ($5 + $4 + $3 + $2)
>        print $6 }' inventory-shipped
-| 168
-| 297
-| 301
…

ここでは$6が新たに作り出されて、 $2, $3, $4, $5の各フィールドの合計が格納される。 `+'は足し算の記号である。 `inventory-shipped'というファイルを使って各月ごとの積込量の合計を $6に設定する。

新しいフィールドを作成すると、awk内部にあるカレントレコードのコピーが変更される。したがって、フィールドを付け加えた後で`print $0'を出力するとその結果には以前から存在していたフィールドと新たなフィールドとの間に適切な数のフィールドセパレータと、新しいフィールドが含まれている。

この再計算の効果と再計算を行う機能についての説明はまだされていない。フィールドの区切りを指定する出力フィールド指定子OFSや NF (フィールドの数。see section フィールドを検査する）についての説明もまだである。例えば、NFの値は新たに作り出されたフィールドのフィールド番号の最大のものがセットされる。 $0の正確なフォーマットもまたまだ説明していない機能 -- 出力ファイルセパレータ(OFS)がフィールドを区切るものとして使われる(see section 出力セパレータ) -- に影響を受けている。

しかし気をつけなければならないのは、範囲外のフィールドに対する参照は $0の値もNFの値も変更しないということである。範囲外のフィールドに対する参照は単に空文字列を生成するだけである。例を挙げよう:

if ($(NF+1) != "")
    print "can't happen"
else
    print "everything is normal"

これは`everything is normal'が出力されるはずだ。なぜなら、NF+1は範囲の外にあるからである (awkのif-else文についての詳しい情報は See section if-else 文、 `!='演算子に関する詳しい情報は See section 変数の型付けと比較式.)。

既に存在するフィールドに何かを代入することによって $0の値は変化するがたとえフィールドに空文字列を代入したとしても NFの値は変化しないということは重要である。例えば:

$ echo a b c d | awk '{ OFS = ":"; $2 = ""
>                       print $0; print NF }'
-| a::c:d
-| 4

フィールドは空の値を持って存在しつづけている。それは`a'と`c'の間に二つのコロンがあることで示されている。以下の例は新たなフィールドを生成したときに起こることを説明している:

$ echo a b c d | awk '{ OFS = ":"; $2 = ""; $6 = "new"
>                       print $0; print NF }'
-| a::c:d::new
-| 6

$5が間に入って空の値で作成されていて (二つめの並んだコロンによって判断できる)、 NFの値が6に更新されている。

NFの値を減じることによって新たなNFの値より後ろのフィールドの値は失われることとなり、$0の再計算が行なわれる。 (d.c.) 以下はその例である:

$ echo a b c d e f | awk '{ print "NF =", NF;
>                            NF = 3; print $0 }'
-| NF = 6
-| a b c

警告: 一部のバージョンのawkは NFを減じたときに$0の再構築を行わない。 Caveat emptor。

結局のところ、awkにレコード全体の再構築を強制したときにはその時点でのフィールドの値とOFSが使われる。再構築を行うためには、何らかの無害な代入を行う:

$1 = $1   # force record to be reconstituted
print $0  # or whatever else with $0

これはawkにレコードの再構築を強制する。上記の例のように、コメントを付加して理解の助けにしている。

$0とフィールドとの間には関係がある。$0に対する代入は FSのその時点での値を使ったレコードからフィールドへの再構築を引き起こす。これはまたsubやgsub(see section 文字列操作関数)のような任意の組み込み関数の適用による$0の更新にも適用される。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.5 フィールドがどのように分割されるかを特定する

The field separator, which is either a single character or a regular expression, controls the way awk splits an input record into fields. awk scans the input record for character sequences that match the separator; the fields themselves are the text between the matches. フィールドセパレータはある一文字か、あるいは正規表現であり、 awkが入力レコードをどのようにフィールドに分割するかを制御する。 awkは入力レコード中にそのセパレータにマッチするキャラクタの並びがないか検索する。フィールドそのものはマッチしたものの間にあるテキストである

次に挙げる例では、出力中の空白を表すのにbullet symbol (•)を使っている。フィールドセパレータが`oo'であるとき以下の行が与えられたとすると:

moo goo gai pan

三つのフィールドに分割される: `m', `•g', `•gai•pan'。二番目と三番目のフィールドの先頭に空白があることに注意すること。

フィールドセパレータは組込み変数のFSで示される。シェルプログラマは注意すること! awkは (Unix Bourne シェル、shやbashのような) POSIX互換のシェルが使っているIFSという名前の変数は使わない。

awkプログラム中で代入演算子`=' (see section 代入式) を使ってFSの値を変更することができる。ほとんどの場合、これ(FSの値を変更すること)を行うのに正しいタイミングは実行の開始時、入力が処理される以前である。これは一番最初のレコードが適切なセパレータで読み込みが行われるからである。このタイミングで変更を行うためにはBEGINスペシャルパターンを使う (see section 特殊パターン BEGIN と END)。例えば、次の例ではFSの値を","という文字列に設定している。

awk 'BEGIN { FS = "," } ; { print $2 }'

入力として次のものを与える:

John Q. Smith, 29 Oak St., Walamazoo, MI 42139

先のawkプログラムは `•29•Oak•St.' という文字列をレコードから取り出し、出力する。

ときとして、セパレートキャラクタを含んではいるがそれを分割したくはないというデータを扱いたいときがあるかもしれない。例えば、先の例の中にある人名は以下のようにタイトルやサフィックスがついている可能性がある:

John Q. Smith, LXIX, 29 Oak St., Walamazoo, MI 42139

先のサンプルプログラムは`•29•Oak•St.'ではなく、 `•LXIX'を取り出す。もしプログラムが住所を出力すると期待していたならば、その結果に驚かされるかもしれない。だから、この様な問題を避けるためにデータのレイアウトと、セパレータとなるキャラクタは慎重に選択せねばならない (もしデータが簡単に処理できるような書式でないのなら、まず最初に別のawkプログラムで整形することができるだろう)。

FS is a special case---it is taken to specify the default manner 通常、フィールドは一つの空白ではなく空白の並び(スペースかタブか改行)で区切られる。行にある二つのスペースは空のフィールドを区切らない。フィールドセパレータのデフォルトの値は " "という文字列であるが、もしこの値を普通通り使ったとしたら、二つの空白からなるような行は空白は二つのフィールドセパレータとして扱われ、結果として awkは空のフィールドを作りだすのだろうか? 実際には以下の理由によってこのようなことは行われない。 FSの値が一つの空白であった場合には特殊な場合として、フィールドの分割のルールをデフォルトと同じ様にする

FSの値が他のキャラクタが一文字、例えば","の様な場合にはそのキャラクタは二つのフィールドを分割する様な結果となる。二つの連続したキャラクタは空のフィールドを分割する。もし、行の先頭や末尾に（区切りの）キャラクタがあった場合には空のフィールドがあるように区切る。スペースはこのルールに従わないただ一つのキャラクタである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.5.1 フィールド分割のために正規表現を使う

先のサブセクションでは単一のキャラクタや単純な文字列を FSの値として用いることについて述べた。より一般的には、FSの値は正規表現を構成する文字列にすることができる。この場合、レコードの中でそれにマッチするものがフィールドを分割する。たとえば:

FS = ", \t"

このような代入は、カンマ、スペース、タブが後ろに続いている領域がフィールドになる。

正規表現のあまり重要でない例として、先の例のカンマのように、一つのスペースでフィールド分割を行いたいという状況を考えよう。これは、FSに"[ ]" (左ブラケットスペース、右ブラケット) をセットすることでできる。この正規表現は一つのスペースにマッチし、他のものにはマッチしない(see section 正規表現)。

`FS = " "'(一つのスペース)と、 `FS = "[ \t\n]+"' (一つ以上のスペース、タブにマッチする正規表現)の間の違いは重要である。これら両方のFSの値は、共にフィールド分割をスペース、タブ、改行(の連続)で行う。しかし、FSが" "であったとき、awkは最初に、先頭や末尾で連続している空白のはぎ取りを行い、それからフィールド分割を実行する。例を挙げると、次のパイプラインでは`b'が出力される:

$ echo ' a b c d ' | awk '{ print $2 }'
-| b

しかし、次のパイプラインでは`a'が出力される (それぞれの文字の回りには余計なスペースが付いていないことに注意):

$ echo ' a  b  c  d ' | awk 'BEGIN { FS = "[ \t\n]+" }
>                                  { print $2 }'
-| a

この場合、第一フィールドは空(null、empty)である。

先頭や末尾にある空白は$0が再構成されたときにはいつでも取り除かれる。例えば次のパイプラインで:

$ echo '   a b c d' | awk '{ print; $2 = $2; print }'
-|    a b c d
-| a b c d

最初のprint文は読み込んだレコードをレコードの先頭にある空白も含めてそのまま出力する。$2に対する代入は、$1から $NFまでをOFSの値で分割されたものとして連結して $0を再構成する。先頭の空白は$1に注目したときには無視されているので、新しい$0には含まれない。そして、最後のprint文は新しい$0を出力する。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.5.2 ここのキャラクタを別個のフィールドにする

レコード中の個々のキャラクタを別個にチェックしたいと思うことはままあるだろう。 gawkでは、それを簡単に行える。単に空文字列("")を FSにセットするに代入すればよい。この場合、レコード中の個々の独立したキャラクタがそれぞれ一つのフィールドとなる。例を挙げると:

$ echo a b | gawk 'BEGIN { FS = "" }
>                  {
>                      for (i = 1; i <= NF; i = i + 1)
>                          print "Field", i, "is", $i
>                  }'
-| Field 1 is a
-| Field 2 is
-| Field 3 is b

伝統的に、FSが""にセットされているときの振る舞いは未定義だった。この場合UNIXのawkは、単にレコード全体を一つのフィールドであるように扱う (d.c.) gawkは互換モード(see section コマンドラインオプション)では、 FSが空文字列の場合にはこのような動作をするようになる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.5.3 コマンドラインから `FS` を設定する

FSはコマンドライン上でセットすることができる。それには`-F'オプションを使用する。例を挙げよう:

awk -F, 'program' input-files

この例ではFSを`,'というキャラクタにセットしている。このオプションが小文字の`f'ではなく大文字の`F'を使っていることに注意。後者の`-f'というオプションは、 awkプログラムが入っているファイルを指定するものである。コマンドラインオプションの大小文字は区別されるので、 `-F'と `-f'という二つのオプションはまったく別のものである。これら両方のオプションを同時に使って、変数FSに(セパレータを)セットするのと同時に awkプログラムをファイルから得ることができる。

`-F'の引数として使った値は、組込み変数FS に代入したときとまったく同じように扱われる。どういうことかというと、もしフィールドセパレータがスペシャルキャラクタを含んでいたら、それを適切にエスケープしなければならないということである。例えば、`\'をフィールドセパレータとして使おうとするなら、次のようにタイプする必要がある:

# same as FS = "\\"
awk -F\\\\ '…' files …

`\'はシェルによってクォーティングされるので、awkには `-F\\'が実際には渡される。awkはそれからエスケープシーケンスの処理を`\\'に対して行うので、最終的にはただ一つの`\'がフィールドセパレータとして使われることになる。

特殊なケースとして、互換モード(see section コマンドラインオプション)において `-F'の引数が`t'であったとき、FSにはタブキャラクタがセットされる。シェルにおいて`-F\t'とクォートなしに入力したとき、 `\'は削除されるのでawkはあなたは実際にはフィールドが`t'ではなくてタブで区切られているのだろうと判断するのである。本当に`t'でフィールドを区切りたいのならコマンドライン上で`-v FS="t"' か `-F"[t]"'とする。

たとえば、`baud.awk'という名前の/300/というパターンと `print $1'というアクションからなるプログラムファイルを使ってみよう:

/300/   { print $1 }

`BBS-list'に対して実行するときに`-'をFSにセットしたとする。以下はコマンドが出力した300ボーで運営されている BBSの名前とその電話番号の最初の三桁のリストである:

$ awk -F- -f baud.awk BBS-list
-| aardvark     555
-| alpo
-| barfly       555
-| bites        555
-| camelot      555
-| core         555
-| fooey        555
-| foot         555
-| macfoo       555
-| sdace        555
-| sabafoo      555

出力の二行目に注目してほしい。オリジナルのファイルの二行目は以下のようになっていた:

alpo-net     555-3412     2400/1200/300     A

システムの名前の一部にある`-'が電話番号の`-'の代わりにフィールドセパレータとして見なされてしまっている。これはあなたがフィールドセパレータやレコードセパレータを選択するときには注意深くあらねばならないということの実例である。

単一のキャラクタをフィールドセパレータとする最も一般的なのは多分Unixシステムのパスワードファイルを処理するときだろう。多くのUNIXシステムでは、ユーザーはシステムのパスワードファイル中にユーザー一人当り一行のエントリをそれぞれ所有している。そこにある情報はコロン(`:')によって区切られていて、最初のフィールドにはユーザーのログオン名が、二番目のフィールドにはそのユーザーの暗号化されたパスワードがある。パスワードファイルのエントリはおおむね次のようなものである。

arnold:xyzzy:2076:10:Arnold Robbins:/home/arnold:/bin/bash

次のプログラムはシステムのパスワードファイルを検索して、パスワードが設定されていないエントリを出力する:

awk -F: '$2 == ""' /etc/passwd

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.5.4 フィールド分割のまとめ

FSの値として文字列定数を代入するときに心に留めておくべき重要なことは、通常のawkの文字列処理が行われるということである。たとえばUnixのawkやgawkでは、 `FS = "\.."'という代入はFSに".."という文字列を代入する(バックスラッシュが取り除かれる)。これは “フィールドは任意のキャラクタ二つの並びによって分割される”という正規表現を生成する。もしフィールドを任意のキャラクタが後続するピリオドによって分割したいのなら、`FS = "\\.."'を使用する。

次のテーブルはFSの値に基づいてどのようにフィールド分割が行われるかまとめたものである(`=='は“に等しい”を意味する):

FS == " ": フィールドは空白の並びによって分割される。先行する空白や末尾の空白は無視される。これはデフォルトである。
FS == 他の任意の単一キャラクタ: フィールドはそのキャラクタによって分割される。キャラクタの並びは空白のフィールドを生成し、先行するものや末尾のものも処理される。キャラクタは正規表現のメタキャラクタであってもよい。これはエスケープする必要はない。
FS == 正規表現: フィールドは正規表現にマッチした(単一、もしくは複数の)キャラクタによって分割される。正規表現にマッチした先行するものや末尾のものは空のフィールドを分割する。
FS == "": レコード中の各キャラクタが分割されたフィールドとなる (これはgawkの拡張である。POSXI標準では規定されていない)。

Advanced Notes: `FS` の変更はフィールドに影響しない

POSIXの標準に従えば、awkはレコードを読み込んだときにフィールドの分割をするように動作することになっている。これはレコードの読み込みが終わった後でFSの値を変更できるということであり、フィールドの値(どのように分割されたか、ということ)は新しいものではなく、古い変更前のFS の値を反映したものであるべきであるということである。

しかし、多くのawk処理系でこの動作をしておらず、実際にフィールドが参照されるまで分割を遅らせている。この場合、フィールドは新しいFSの値を使って分割されるのだ!(d.c.) この振る舞いは調べるのが難しい。以下の例はこれら二つのやり方の違いを説明するものである (このsed(18) コマンドは`/etc/passwd'の最初の一行だけを出力する)。

sed 1q /etc/passwd | awk '{ FS = ":" ; print $1 }'

これは正しくない実装のawkでは以下の出力を行う:

root

一方gawkでは以下のような出力となる:

root:nSijPlPhZZwgE:0:0:Root:/:

Advanced Notes: `FS` と `IGNORECASE`

IGNORECASE変数(see section awkを制御する組み込み変数)は FSが正規表現であるときにのみフィールド分割に影響を及ぼす。 FSが単一キャラクタであるときにはたとえそれが通常の文字であったとしても影響しない。したがって:

FS = "c"
IGNORECASE = 1
$0 = "aCa"
print $1

この出力は`aCa'となる。本当に大小文字の区別を無視してアルファベットでフィールド分割を行いたいのなら、それを表す正規表現、たとえば`FS = "[c]"'を使用する。この場合にはIGNORECASEは影響を及ぼすことになる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.6 固定長データを読む

注意: このセクションセクションでは、先進的なgawkの機能について説明している。もしあなたがawk初心者なら、初めて読んだときにはここを飛ばしたくなるかもしれない。

gawk 2.13 で新たに、幅が固定されていてセパレータを持っていないフィールドを扱うための機能を導入した。そこで想定されているデータは典型的には古いFORTRANプログラムに対する数値の入力として、あるいは他のプログラムの入力として扱われることを考慮していないプログラムの出力の二つのうちのいずれかだろう。

後で挙げる例は、全てのカラムが可変数のスペースを使用して整列されていて、空のフィールドがスペースで構成されているデータのテーブルである。現実に、 awkの通常のFSに基づいて行うフィールド分割はこの様なケースではうまく働かない。 awkプログラム中で$0に対してsubstrをくり返し呼ぶことで実現できるが (see section 文字列操作関数)、これはポータブルであっても、 awkward であり、大きなフィールド番号では非効率的なやり方である。

入力レコードを固定幅のフィールドに分割するときには、組み込み変数FIELDWIDTHS に設定されたスペースで区切られた数字の並びで指定する。並びのそれぞれの数字は、フィールドの幅をフィールドの間のカラムを含めて指定している。もし、フィールドの間のカラムを無視したいのであれば、後続を無視するようなフィールドの分割をする幅を指定することもできる。正でない数をフィールド幅として与えると致命的エラーとなる。次のデータはwユーティリティの出力である。これはまたFIELDWIDTHS の使い方を説明するのにちょうどよい。

 10:06pm  up 21 days, 14:04,  23 users
User     tty       login  idle   JCPU   PCPU  what
hzuo     ttyV0     8:58pm            9      5  vi p24.tex
hzang    ttyV3     6:37pm    50                -csh
eklye    ttyV5     9:53pm            7      1  em thes.tex
dportein ttyV6     8:17pm  1:47                -csh
gierd    ttyD3    10:00pm     1                elm
dave     ttyD4     9:47pm            4      4  w
brent    ttyp0    26Jun91  4:46  26:46   4:41  bash
dave     ttyq4    26Jun9115days     46     46  wnewmail

次のプログラムは先ほどのデータを入力とし、アイドルタイムを秒に変換して入力データの最初の二つのフィールドと、計算した時間を出力する:

注意: このプログラムはまだ説明されていないawkの機能をいくつか使っている。

BEGIN  { FIELDWIDTHS = "9 6 10 6 7 7 35" }
NR > 2 {
    idle = $4
    sub(/^  */, "", idle)   # 先行する空白を取り除く
    if (idle == "")
        idle = 0
    if (idle ~ /:/) {
        split(idle, t, ":")
        idle = t[1] * 60 + t[2]
    }
    if (idle ~ /days/)
        idle *= 24 * 60 * 60

    print $1, $2, idle
}

プログラムの実行結果は次の通り:

hzuo      ttyV0  0
hzang     ttyV3  50
eklye     ttyV5  0
dportein  ttyV6  107
gierd     ttyD3  1
dave      ttyD4  0
brent     ttyp0  286
dave      ttyq4  1296000

別の（より現実的であろう）固定幅の例となる入力データは、投票用紙の山からの入力だろう。合衆国の一部では、投票者は投票をコンピュータカードのパンチされた穴を選択することで行う。これらのカードは投票がどの候補者に行われたか、あるいはどの欄が選択されたかを数えるのに使われる。投票者が一部の投票を行わなかった場合、対応するカードのカラムは空である。 awkプログラムはその様なデータを処理するために、 FIELDWIDTHS 機能を使ってデータを単純に読むことができる (もちろん、カードリーダー付きのシステムでgawkを動かすようにするのは別の話だ!)。

FSへの代入は、再度FSによるフィールド分割をgawkに指示する。`FS = FS'はこれを現在のFSの値を知ることなしに行うことができる。フィールド分割がどの種のもので行われているかは PROCINFO["FS"]を使うことによって知ることができる (see section 情報を伝達する組み込み変数)。通常のフィールド分割が行われていればその値は"FS"であり、固定長のフィールド分割が行われていれば"FIELDWIDTHS"が値となる:

if (PROCINFO["FS"] == "FS")
    通常のフィールド分割 …
else
    固定長フィールド分割 …

この情報は、幾つかのレコードを読み取り、その後で元の設定に戻すような FSやFIELDWIDTHSを一時的に変更する必要がある関数を記述するときに便利である(そのような関数の例は see section Reading the User Database にある)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.7 複数行レコード

一部のデータベースでは、一つの情報のエントリを一行で保持できない。この様な場合に複数行レコードを使うことができる。これを行う最初のステップはデータフォーマットの選択である。

一つの手段としては、レコードを分割するのにあまり使われないようなキャラクタか文字列を使う。ということがある。例えばフォームフィードのコード (awkではCのように、`\f'と記述する) をファイルをページを一つのレコードとして分割するために使うことができるだろう。そうするには変数RS に"\f" (フォームフィードキャラクタを保持する文字列)をセットすればよい。他の、レコード中のデータの一部分として同じ程度にあまり使われていないキャラクタを使うこともできるだろう

他のやり方としては空行でレコードを分割するというものがある。特別な場合として、空文字列をRSにセットすると、それはレコードの区切りとして一行以上の空行をでレコードを分割するという事を示す。もし、RSに空文字列をセットすると、レコードは常に最初の空行に出会ったところで終わる。そして、次のレコードは空行でない行がきたところでスタートする。どれだけ空行が続いているのかは関係なく、単に一つのレコードセパレータとして認識される (空行は完全に空でなければならない。空白のみからなる行は含まれない)。

`RS = ""' としたときと同じ効果を"\n\n+"をRSにセットすることによって得ることができる。この正規表現はレコードの終端にある改行にマッチし、一行以上の空白行がレコードの後に続く。それに加えて、正規表現は常にマッチする最長のパターンを選択する (see section どのくらいテキストがマッチするか?)。したがって次のレコードは空行でない行がくるまでスタートしない。どれだけ空行が続いてあるかは関係なく、単に一つのレコードセパレータとして認識される

(d.c.) `RS = ""'と`RS = "\n\n+"'には重要な違いがある。最初のものは、入力データファイル中の先頭にある改行は無視され、最後のレコードの後に空行がない場合には、最後の改行がレコードから剥ぎ取られる。二番目のものでは、このような特殊な処理は行われない(d.c.)

ここまでで入力がレコードに分割された。第二のステップはレコード中のフィールドをどう分割するか、という事である。フィールドを分割する別のやり方としては、通常の方法で各行をフィールドに分割するというものである。これは特殊機能の結果、デフォルトで生じることである。 RS に空文字列が設定されていて、かつ、FSが単一キャラクタであるとき改行は常にフィールドセパレータとして動作する。これは、 FSに設定されている値によるフィールド分割に加えられる形で行われる (19)。

この特別な例外を取り入れることになった元々の動機は、デフォルトの場合に使い易い動作をするようにするためである (i.e., FS == " ")。この機能は、ユーザーが本当は改行をフィールド分割のためのキャラクタとして使いたくないときに、それを防ぐ手段がないので問題となる。しかしながら、 split関数を使って手動で分割を行なうことで望む結果を得ることができる (see section 文字列操作関数)。単一キャラクタのフィールドセパレータを使っているのなら、 FSに単一キャラクタを表す正規表現を格納するというやり方でこの特殊機能を回避することができる。たとえばフィールドセパレータにパーセント記号を使っているのなら、 `FS = "%"'とする代わりに`FS = "[%]"'とするのである。

もう一つの方法は一行を一つのフィールドとして出力する。というものがある。それを実行するには変数FS に "\n"という文字列をセットすれば良い (これは、一つの改行にマッチする単一キャラクタによるセパレータである)。このやり方を使った現実的な例は各エントリが空行で分割されているメイリングリストだろう。`addresses'という名前のファイルに格納されている以下のような形態のメイリングリストを考えてみよう。

Jane Doe
123 Main Street
Anywhere, SE 12345-6789

John Smith
456 Tree-lined Avenue
Smallville, MW 98765-4321
…

このファイルを処理する単純なプログラムは以下のようなものである:

# addrs.awk --- 簡単なメイリングリストプログラム

# レコードは空行によって分割される。
# 各行は一つのフィールド。
BEGIN { RS = "" ; FS = "\n" }

{
      print "Name is:", $1
      print "Address is:", $2
      print "City and State are:", $3
      print ""
}

プログラムを実行すると以下のような結果が得られる:

$ awk -f addrs.awk addresses
-| Name is: Jane Doe
-| Address is: 123 Main Street
-| City and State are: Anywhere, SE 12345-6789
-|
-| Name is: John Smith
-| Address is: 456 Tree-lined Avenue
-| City and State are: Smallville, MW 98765-4321
-|
…

See section メイルのラベルを出力する, for a more realistic program that deals with address lists. The following table summarizes how records are split, based on the value of RS:

RS == "\n": レコードは改行キャラクタ(`\n')で分割される。言い換えると、データファイルの各行が空行も含めて、独立したレコードとなる。
RS == 任意の一キャラクタ: レコードは指定されたキャラクタにより分割される。このキャラクタが連続している場合には、空のレコードを区切っているとみなされる。
RS == "": 空行の連続によってレコードを分割する。改行は FSに設定されているものに加えて、常にフィールドセパレータとなる、ファイルの先頭や末尾にある改行は無視される。
RS == regexp: regexpにマッチした文字列によってレコードが分割される。先頭や末尾にあるregexpは空レコードを区切るとみなされる (これはgawkの拡張機能である。POSXI標準では規定されていない)。

すべてのケースにおいて、gawkはRTに RSで指定されたものにマッチしたテキストをセットする。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8 `getline`を使った入力

これまで私達はawkの主入力ストリームから入力データを得ていた。それは標準入力(通常はターミナル、ときとして他のプログラムの出力) やコマンドラインで指定したファイルであった。 awk言語はgetlineと呼ばれる特殊な組込みコマンドを持っており、これは明確に制御された元での入力読み取りに使うことができる。

getlineコマンドは非常に複雑であり、初心者はあまり使うべきではない。この章が入力に関してのものであるのでここで記述している。以下に挙げる例はまだ説明されていないものが含まれている getlineコマンドの説明である。従って、このWeb ページの残りの部分を読んでawkがどのように動作するかの知識を十分得た後に、ここに戻ってgetlineコマンドを学ぶのが良いだろう。

getlineはレコードが見付かれば1を返し、ファイルの終端に達したときには 0を返す。もし、レコードの読み込みでなんらかのエラーが発生したり、ファイルがオープンできなかったりした場合にはgetlineは -1を返す。このときgawkはERRNOという変数にエラーが発生したことを表わす文字列をセットする。

次の例では、command はシェルコマンドを表す文字列である。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.1 引数なしで `getline` を使う

getline コマンドはカレント入力ファイルから入力するときには引数を省略することができる。この場合、入力レコードはフィールドに分割される。この getline の使い方は、カレント入力レコードに対する処理は終わったが、何か特別な処理を次のレコードに対してその時点で処理を行いたい、というときに便利である。たとえば

{
     if ((t = index($0, "/*")) != 0) {
          # value of `tmp' will be "" if t is 1
          tmp = substr($0, 1, t - 1)
          u = index(substr($0, t + 2), "*/")
          while (u == 0) {
               if (getline <= 0) {
                    m = "unexpected EOF or error"
                    m = (m ": " ERRNO)
                    print m > "/dev/stderr"
                    exit
               }
               t = -1
               u = index($0, "*/")
          }
          # */がファイルの末尾にあるとき
          # substrを含む式は""となる
          $0 = tmp substr($0, u + 2)
     }
     print $0
}

このawkプログラムは入力から`/* ... */'というCスタイルのコメントを取り除く。 `print $0'を他の文に置き換えることによって、より複雑な処理をコメントアウトされた入力に対して、ある正規表現にマッチするかどうかを探すなどして行うことができる (このプログラムには隠された問題点がある--- それは一つのコメント終了と開始とが同じ行にあるときにうまく働かないということである)。

この形式のgetlineコマンドはNF、 NR、 FNR、$0に新しい値をセットする。

NOTE: 新しい$0の値は、後に続いてあるルールのパターン部とテストするために使われる。このとき、元々の$0の値は失われる。対照的に next文で新しいレコードを読んだときは、即座に通常通りの処理を始め、プログラムの最初のルールから処理を始める。See section next 文.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.2 変数に`getline`の結果を格納する

`getline var' を使って、 awkの入力からの次のレコードを変数varに読み込むことができる。他の処理は行われない。この形式のgetlineはawkの読込み-チェック-ルールのループには見つからないで変数に行を読み込んで格納することができる。以下の例は二行ごとにその二行を入れ替える:

{
     if ((getline tmp) > 0) {
          print tmp
          print $0
     } else
          print $0
}

入力として以下のものがあったとすると:

wan
tew
free
phore

結果は次のようになる:

tew
wan
phore
free

ここではgetline関数は変数NRとFNRに (もちろん varにも)セットする目的で使われている。レコードはフィールドに分割はされず、したがってフィールドの値($0 も含めて)と、 NFの値は変更されない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.3 `getline`を使ったファイルからの入力

`getline < file'を使って、次のレコードをfileというファイルから読み込むことができる。このfileはファイル名として特定できる文字列の値を持った式である。 `< file'は異なった場所から直接入力を行うのでリダイレクと呼ばれる。例えば、次のプログラムはレコードの入力を、カレント入力からのレコードの最初のフィールドが10であったときに、 `secondary.input'というファイルから行う:

{
    if ($1 == 10) {
         getline < "secondary.input"
         print
    } else
         print
}

通常の入力ストリームを使わないので、NRとFNRの値は変更されない。しかし、読み込まれたレコードは通常のルールに従ってフィールドに分割され、 $0 および、その他のフィールドの値は変更される。もちろんNFの値もその例外ではない。

POSIXに従えば、`getline < expression' は expression中に `$'以外の演算子が括弧に囲まれないで現れたときには曖昧となる。たとえば`getline < dir "/" file' は連接演算子が括弧に囲まれずに現れており、曖昧になっている。そしてこれは、他のawk処理系でも問題なく使えるようにしたいのなら、 `getline < (dir "/" file)' と記述すべきである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.4 `getline`を使ってファイルから変数へ格納

`getline var < file'を使ってファイルfileから読み込み、変数varにそれをセットする。先に述べたように、 fileは読み込みに使用するファイルを指定する文字列式である。

この使い方のgetlineはどの組み込み変数も変更せず、レコードのフィールドへの分解も行われない。ただ単にvarだけが変わる。例えば、次のプログラムでは入力ファイルを出力するが、入力中に `@include filename'と書かれたレコードがあったときに、その様なレコードをfilenameというファイルの内容で置き換える:

{
     if (NF == 2 && $1 == "@include") {
          while ((getline line < $2) > 0)
               print line
          close($2)
     } else
          print
}

これは展開する入力ファイルの名前がプログラム中に書かれていないことに注意。この例では、`@include'がある行の二番目のフィールドで指定されるファイルからデータを持ってくる

close関数は入力中にある`@include'で指定されるファイルの中に同じものが二度以上指定されているものがあったとしてもきちんと動作することを保証するために呼ばれている See section 入出力のリダイレクトをクローズする.

このプログラムで一つ欠けているのは、本当のマクロプロセッサではできるようなネストした `@include'文(インクルードファイルの中にある `@include') を処理できないという点である。ネストした`@include'文を処理できるプログラムは See section An Easy Way to Use ライブラリ関数.

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.5 Using `getline` from a Pipe

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.6 getlineを使ったパイプからの入力

コマンドの出力をパイプを通じてgetlineを `command | getline' のように使って受けることができる。パイプは単にあるプログラムの出力を他の入力にリンクするだけである。このケースでは、 commandという文字列はシェルコマンドとして実行され、その出力がパイプを通じてawkの入力とされる。この例のgetlineではパイプからレコードを読み込んでいる。例えば次のプログラムは入力を出力にコピーするが、ある行が`@execute' で始まっていると、その行の`@execute'に続く部分をシェルのコマンドとして実行して、入力をその結果に置き換える:

{
     if ($1 == "@execute") {
          tmp = substr($0, 10)
          while ((tmp | getline) > 0)
               print
          close(tmp)
     } else
          print
}

close 関数は入力中の`@execute'のある行で指定されるコマンドに二つ以上の同一のコマンドが指定されたときに、一回毎にそのコマンドを実行する様にさせるために呼び出される。 See section 入出力のリダイレクトをクローズする. 入力として以下のものを与える:

foo
bar
baz
@execute who
bletch

プログラムの出力はこうなる:

foo
bar
baz
arnold     ttyv0   Jul 13 14:22
miriam     ttyp0   Jul 13 14:23     (murphy:0)
bill       ttyp1   Jul 13 14:23     (murphy:0)
bletch

このプログラムはwhoコマンドを実行し、結果を出力する (もしこのプログラムがやっていることを自分でやろうとしたら、その結果は異なったものとなるだろう。誰がシステムにログインしているかで変わるからだ)。

この形式のgetlineでは、レコードをフィールドに分割し、 NFをセットして$0を再計算する。このとき、NR とFNRは変更しない。

POSIXに従えば、`expression | getline'は expressionが`$'以外のカッコがついていない演算子を含んでいるときに曖昧である --- たとえば、`"echo " "date" | getline'はカッコ付けされていない演算子を含んでいるので曖昧である。他のawkの実装でも動くようにしたいのであれば、 `("echo " "date") | getline'のように記述すべきである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.7 Using `getline` into a Variable from a Pipe

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.8 `getline`を使ってパイプからの内容を変数に格納する

`command | getline var'を使ったとき、 commandの出力はパイプを通じてgetlineに渡り、さらに変数var に格納される。例えば次に挙げるプログラムでは date ユーティリティを使用して日付と時刻を読み込み、それをcurrent_timeという変数に格納し、さらに表示している:

BEGIN {
     "date" | getline current_time
     close("date")
     print "Report printed on " current_time
}

この使い方のgetlineでは、どの組み込み変数も変更されず、レコードのフィールド分割も行われない

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.9 `getline` を使ってコプロセスから入力する

getlineを使ったパイプからの入力は一方向のオペレーションであった。 `command | getline'で起動したコマンドはあなたのawkプログラムに対してだけデータを送る。

反対に、別のプログラムに処理するためのデータを送ってその結果を読み取りたいということがあるかもしれない。 gawkはコプロセス(coprocess)を起動して双方向の通信を可能にすることができる。これは`|&'演算子を使って行う。典型的には、以下の例のようにデータをコプロセスに書き込んでから結果を読み取る:

print "some query" |& "db_server"
"db_server" |& getline

これは問い合わせをdb_serverに送り、その後で結果を読み出している。

NRとFNRの内容は変化しない。なぜなら主入力ストリームは使われていないからだ。しかしながら、読み取られたレコードは通常のやり方にしたがってフィールドへの分割が行われるので、$0やその他のフィールド、そして NFの内容は変化する。

コプロセスは発展的機能(advanced feature)である。 getlineに関するセクションがここであるのでここで述べている。コプロセスの詳細はSee section Two-Way Communications with Another Process

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.10 `getline`を使ってコプロセスから変数に格納する

`command |& getline var'を使ったとき、コプロセス commandからの出力は双方向パイプを通じてgetlineに送られて、varという変数に格納される。

このバージョンのgetlineでは、組み込み変数は変化しないし、読み込まれたレコードのフィールドへの分割はされない。唯一変化する変数はvarである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.11 Points to Remember About `getline`

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.12 `getline`に関して覚えておくべきこと

以下に挙げるのは、getlineに関して心にとどめておくべきその他のことである:

getlineが$0やNFを変更したとき、 awkはプログラムの先頭に自動的にジャンプすることはないし、全てのパターンに対して新しいレコードを検査することもない。しかしながら、新しいレコードは後続するルールに対して検査される。
多くのawkの実装では一つのawkプログラムで使うことのできるパイプラインの数を一つに限定している。gawkではそのような制限はない。使用しているオペレーティングシステムの許す限り複数のパイプライン(とコプロセス)をオープンすることができる。
getlineを、BEGINルールの中でリダイレクトをせずに使った場合、興味深い副作用が発生する。リダイレクトされていないgetlineはコマンドラインで指定されたデータファイルから読み込むので、最初のgetlile はawkにFILENAMEの値をセットさせる。通常、 (BEGINルールでは)コマンドラインで指定されたデータファイルを処理しないのでFILENAMEはBEGINルールでは値を持たない(d.c.)。 (See section 特殊パターン BEGIN と ENDとsee section 情報を伝達する組み込み変数.)。
`getline < FILENAME'のようにFILENAMEを伴ったgetline は混乱の元である。awkはカレントの入力ファイルとは別の入力ストリームをオープンする。しかし、変数を使わなければ$0やNRは更新されてしまう。もしこのような使い方をしたならばそれはたぶん偶発的なもので、何をしようとしているのかを再度考えた方が良いだろう。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

3.8.13 `getline` の変種のまとめ

table-getline-variants 以下に八種類のgetlineの使い方とそれぞれの使い方でセットされる組込み変数を一覧にした。

`Variant`	`Effect`

`getline`	`$0, NF, FNR, NR をセットする`
`getline var`	`var, FNR, NR をセットする`
`getline < file`	`$0 と NF をセットする`
`getline var < file`	`var をセットする`
`command \| getline`	`$0 と NF をセットする`
`command \| getline var`	`var をセットする`
`command \|& getline`	`$0 と NFをセットする。これは gawk の拡張`
`command \|& getline var`	`varをセットする。これは gawk の拡張`

Table 3.1: getline Variants and What They Set

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4. Printing Output

もっともよく行われるアクションの一つは、入力の一部もしくは全部を出力することである。単純な出力のためにprint文を使い、整形して出力するために printf文を使う。この両者はこの章で説明する。 print文は出力する値を計算するときに限らない。しかし二つの例外があって、どのように出力するかを指定すること --- どのくらいのカラムでどのような表記で(指数表記を使うか否か) 出力するかといったことを指定することができない(二つの例外についてはsee section 出力セパレータと printの数値出力を制御する)。これらを指定して出力するには、printf文が必要となる(see section printfを使って出力を整える)。

基本と書式付け出力と共に、この章ではファイルやパイプへの入出力のリダイレクトをカバーし、さらにgawkが内部的に処理するファイル名や組み込み関数closeについても説明する。

4.1 `print` 文
4.2 `print` 文の例
4.3 出力セパレータ
4.4 `print`の数値出力を制御する		Controlling Numeric Output With `print`.
4.5 `printf`を使って出力を整える
4.6 `print` や `printf`の出力のリダイレクト		複数のファイルやパイプへの出力をどのようにリダイレクトするか。
4.7 `gawk` における特殊なファイル名		`gawk` に解釈される名前。 `gawk` は継承したファイル記述子へのアクセスを許可する。
4.8 入出力のリダイレクトをクローズする

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.1 `print` 文

print文は出力を単純に、標準的な書式で行う。カンマで区切られたリストになっているデータを文字列とするか数値として出力するかを特定できるだけである。出力は一つのスペースで区切られ、最後に改行が加えられる。 print文は以下のような形で使う:

print item1, item2, …

アイテムのリストは、全体を括弧でくくる事もできる。この括弧は、アイテムのいずれかが関係演算子`>' を使った式である場合には使う必要がある。そうしないと、リダイレクションと混同してしまう可能性があるだろう (see section print や printfの出力のリダイレクト)。

出力の対象となるアイテムは、文字列や数値定数、 ($1のような)カレントレコードのフィールド、変数、あるいは任意のawk式である。数値は文字列へと変換されてから出力される。

引数を持たない単純な`print'文は`print $0'と等価であり、カレントレコード全体を出力する。空行を出力するには、 `print ""'のように空文字列""を指定する。テキストのひとかたまりを出力するには、"Don't Panic"のように一アイテムとして文字列定数を使う。ダブルクォートを使うことを忘れてしまうと、そのテキストはawkの式として扱われてたぶんエラーになってしまうだろう。任意の二つのアイテムの間にはひとつのスペースが挟まることを心にとどめておくこと。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.2 `print` 文の例

各print文は少なくとも一行の出力を行うが、一行に限らない。改行を含む文字列がアイテムの値であった場合、その改行は文字列の残りの部分と共に出力される。一つのprint文はこのやり方で任意の行数の出力を行うことができる。

以下に挙げるのは改行が埋め込まれた文字列の出力の例である (`\n'は改行キャラクタを表すのに使ったエスケープシーケンスである。 see section エスケープシーケンス):

$ awk 'BEGIN { print "line one\nline two\nline three" }'
-| line one
-| line two
-| line three

次の例はファイル`inventory-shipped'の各入力レコードの最初の二つのフィールドを空白で区切って出力する:

$ awk '{ print $1, $2 }' inventory-shipped
-| Jan 13
-| Feb 15
-| Mar 15
…

print 文を使うときにありがちな間違いは、二つのアイテムの間に置かれるカンマを忘れてしまうという事である。それはスペースなしに、一つにまとまって出力される結果となるだろう。なぜなら、二つの並んだ文字列というのは awk では連接を行う式を意味するからだ。カンマがない例として

$ awk '{ print $1 $2 }' inventory-shipped
-| Jan13
-| Feb15
-| Mar15
…

so that the headings are only printed once: ファイル`inventory-shipped'にあまり馴染みのない人に対してもわかりやすい出力をしよう。最初のヘッダ行で何を出力しているかを明確にしようとして、月ごとの量($1)と、緑のクレーの積込量($2)のテーブルにヘッダを付け加えている。これをBEGINパターン (see section 特殊パターン BEGIN と END) を使って出力の最初に一回だけ出力させている。

awk 'BEGIN {  print "Month Crates"
              print "----- ------" }
           {  print $1, $2 }' inventory-shipped

実行するとこのプログラムの出力はこうなる:

Month Crates
----- ------
Jan 13
Feb 15
Mar 15
…

しかし問題があって、ヘッダとテーブルデータがきちんと並んでいない! これは幾つかのスペースを二つのフィールドの間に出力することで修正することができる:

awk 'BEGIN { print "Month Crates"
             print "----- ------" }
           { print $1, "     ", $2 }' inventory-shipped

このカラムの揃え方は多くのカラムがあった場合に揃えるのが少々面倒になることが想像できるだろう。二、三個のカラムのためなら単純にスペースを数えられるだろうが、これがもっと多かったりすると数え間違えやすくなる。それが printf 文が作られた理由である (see section printfを使って出力を整える)。printf文の機能の一つはデータのカラムをそろえることである。

NOTE: print文やprintf文では、任意のカンマの後に改行を置くだけで行の継続を行うことができる(see section awk Statements Versus Lines)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.3 出力セパレータ

先に述べたように、print文はカンマで区切られたアイテムのリストを含む。出力では、各アイテムは単一のスペースで区切られる。これはただのデフォルトであり、常にそうであるわけではない。組込み変数のOFSに任意の文字列をセットすることによって出力フィールドセパレータを指定することができる。この変数の初期値は" "、つまり単一のスペースである。

print文による出力全体は出力レコードと呼ばれる。各print 文は一つのレコードを出力し、その後に出力レコードセパレータ(もしくはORS)と呼ばれる文字列を出力する。組込み変数ORSがこの文字列を特定する。 ORS の初期値は"\n"という文字列である。これは改行であり、したがって、通常は各print文は分割された行を作成する。

OFSやORSといった変数に新しい値をセットすることによって、出力フィールドや出力レコードをどのように分割するかを変更することができる。通常これを行う場所は、入力がまだ処理されないBEGINルール (see section 特殊パターン BEGIN と END) の中である。同じことを、コマンドライン上で入力ファイル名の前に変数への代入を行うことでもできるし、 `-v'オプションを使うことでもできる (see section コマンドラインオプション)。次の例では、各入力レコード中のセミコロンで区切られたフィールドの一番目と二番目を、各行の後ろに空行を追加して出力する。

$ awk 'BEGIN { OFS = ";"; ORS = "\n\n" }
>            { print $1, $2 }' BBS-list
-| aardvark;555-5553
-|
-| alpo-net;555-3412
-|
-| barfly;555-7685
…

ORSが改行を含んでいなければ、すべての出力は陽に改行を出力しない限りは一行にまとまって出力されることになる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.4 `print`の数値出力を制御する

print 文を数値を出力するために使った場合、 awkは内部で数値を (その数値を表す)文字列に変換し、その文字列を出力する。 awkはこの変換動作のためにsprintf関数を使用する (see section 文字列操作関数). 現在のところ、sprintf 関数が数値(や文字列)をどのように書式化するかを記述されている書式指定(format specification)を受諾し、数値の書式指定は違った方法が何種類もあるということだけで十分である。書式の違いは書式制御文字で詳しく述べられている。

組込み変数のOFMTは、出力をおこなうときにprintがsprintf を使って数値を文字列に変換するための書式のデフォルト設定を保持している。 OFMTのデフォルトの値は"%.6g"である。 OFMTの値を違ったものにすることによって、 printが数値をどのように出力するかを変更することができる。簡単な例を挙げよう:

$ awk 'BEGIN {
>   OFMT = "%.0f"  # 数値を整数として出力 (丸め)
>   print 17.23, 17.54 }'
-| 17 18

POSIX標準に従えば、OFMTに浮動小数点の変換指定ではないなにかをセットした場合の awkの動作は定義されてない(d.c.)。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.5 `printf`を使って出力を整える

printで出力するには複雑な書式を使いたいのであれば、 printfを使うと良い。 printfを使うことによってアイテムごとにその幅を指定したり、数値を出力するのにそれをどのようなスタイルで出力するのかを指定することができるようになる (使用する基数や、符号を出力するかどうか、小数点以下何桁まで出力するか)。他の引数をどのように、どこに出力するかを制御する書式指定文字列(format string) と呼ばれる文字列によって、それを行なうことが可能である。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.5.1 Introduction to the `printf` Statement

printf文は以下のような形式である:

printf format, item1, item2, …

引数リスト全体をカッコで括ることもできる。このカッコはリストのいずれかのアイテムが関係演算子`>' を使った式であるときには必要となる。カッコがないと、その文はリダイレクトと混同される可能性がある (see section print や printfの出力のリダイレクト).

printfとprintの違いは引数formatにある。これは文字列として扱われる式で、他の引数をそれぞれどのように出力するかを指定する。これは書式指定文字列(format string)と呼ばれる。

この書式指定文字列は ISO Cライブラリのprintf関数のものと同じである。大部分の書式は(書式指定文字列の)文字通りに出力されるテキストである。書式指定子(format specifiers) はアイテム一つ毎に一つの割りあいで、このテキスト中に置かれている。個々の書式指定子は、次のアイテムをどのような書式で出力するかを指定している。

printf文は改行を自動的に付加することはせず、書式文字列で指定されたものだけを出力する。したがって改行が必要ならば、書式指定文字列にそれを含めなければならない。 OFSやORSといった変数に格納されている出力セパレータは printfに対して何の影響も与えない。例えば:

$ awk 'BEGIN {
>    ORS = "\nOUCH!\n"; OFS = "+"
>    msg = "Dont Panic!"
>    printf "%s\n", msg
> }'
-| Dont Panic!

ここでは、`+'や`OUCH'はメッセージの中に現れない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.5.2 書式制御文字

書式指定子は`%' で始まり、(printf文でどのように出力するかを指定する) 書式指定文字(format-control letter)で終わる。書式指定文字は出力する値がどんな種類であるかを指定する。書式指定子の残りは、どの位のフィールド幅で出力するかというような事を指定する (省略可能な)修飾子である。以下は書式指定文字のリストである:

%c

数値をASCIIキャラクタとみなして出力する。 `printf "%c",65'は `A'を出力する。文字列を与えた場合は文字列の先頭にあるキャラクタを出力する。

%d, %i

どちらも同じで十進整数を出力する (`%i'はISO Cとの互換性のための仕様である)。

%e, %E

これは数値を科学(または指数)形式で出力する。例えば

printf "%4.3e\n", 1950

これは小数点以下を含めて全部で四つの数字からなる `1.950e+03'を出力する (`4.3'は二つの修飾子(modifiers)であり、詳しくは後述する)。 `%E'は`e'の代わりに`E'を出力するものである。

%f

浮動小数点形式で数値を出力する。例えば、

printf "%4.3f", 1950

これは小数点以下三桁を伴った四桁のsignificant figuresである `1950.000'を出力する(`4.3' は二つ修飾子(modifiers)であり、詳しくは後述する)。

IEEE 754浮動小数点フォーマットをサポートしているシステムでは、負の無限大を表すフォーマットは`-inf'もしくは`-infinity'であり、正の無限大は`inf'と`infinity'である。特別な“数値でない”(not a number)値は`-nan'または`nan'である。

%F

%fに似ているけれども、“数値でない”値は大文字で表される。

%F書式はISO Cに対するPOSIXの拡張である。全てのシステムでサポートされているわけではない。サポートされていないシステムではgawkは%fを代わりに使う。

%g, %G

科学表記か浮動小数点表記の、いずれか出力するキャラクタ数が少なくなる方で出力する。結果が科学表記であったとき、 `%G' は `E' を `e'の代わりに使用する。

%o

This prints an unsigned octal integer. 無符号の八進整数を出力する。

%s

文字列を出力する。

%u

無符号の十進整数を出力する (この書式は marginal なものである。なぜならawkにおける数値は全て浮動小数点数であって、この書式はCとの誤カンのために提供されている)。

%x, %X

十六進の符号なし整数を出力する。 `%X'は`a'から`f'までの代わりに `A'から`F'までを使用する。

%%

これは本当は書式制御文字ではない、しかし`%'の後に続けて書かれた場合には意味がある。 `%%'と並べて書いたときには一文字の`%'を出力し、引数を取らない。また、すべての修飾子を無視する。

注意: Cでの最も広い整数型の範囲を越えた値に対する整数書式指定を使ったとき、 gawkは書式指定を`%g'に切り替える。コマンドラインで`--lint'を指定したとき(see section コマンドラインオプション) gawkはこれを警告する。他のバージョンのawkは間違った値を出力したり何かへんな動作をしたりするかもしれない。(d.c.)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.5.3 `printf` の書式の修飾子

書式指定には出力されるアイテムの値と、出力する大きさを制御するために修飾子(modifiers)を含めることができる。修飾子は`%'と書式指定文字の間に置かれる。後で挙げる例では、出力中の空白を``'•' というシンボルで表わしている。以下は使用することのできる修飾子である(出現することのできる順で):

N$

`$'に続く整数値は位置指定子(positional specifier)である。通常は、書式指定子は書式指定文字列中に現れた順に引数に対して適用が行われる。位置指定子を伴った場合、書式指定子は引数リスト中の次の引数ではなく特定の引数に対して適用される。位置指定子は1から始まる。したがって:

printf "%s %s\n", "don't", "panic"
printf "%2$s %1$s\n", "panic", "don't"

これは有名な友好的メッセージを二度出力する。

一見したところでは、この機能はそれほど使われていないようだ。事実これはgawkの拡張であり、実行時に翻訳メッセージを使うために用いられる。 See section Rearranging printf Argumentsにどのように、なぜ位置指定子を使うのかが説明されている。現在のところ、我々はこれを使わない。

-

マイナス記号は出力幅の修飾に使い、与えられた出力幅の中で左詰めを行うことを指示する。通常は与えられた出力幅の中で右詰めで表示がなされる。従って、

printf "%-4s", "foo"

これは`foo•'を出力する。

空白

数値の変換の際に、その値が正であればスペースを、負であればマイナス記号を数値の前に置く。

+

プラス記号は幅指定の修飾子(後述する)の前で使用し、変換された数値が正の数値であっても、その前に必ず符号をつけることを指示する。 `+'はスペース修飾子をオーバーライドする。

#

特定の制御文字に対して``別形式''(alternate form)を使用する。 `%o'の前に置いた場合数値の前にゼロを置く。 `%x'や`%X'の前に置いた場合、出力する数値が0でなかったときにそれに先行して`0x' や `0'を置く。 `%e', `%E', `%f' の場合、常に小数点をつけるようにする。 `%g', `%G'の場合、小数点以下の0も省略されないようにする。

0

%に続いた`0'はフラグとして動作し、出力のパディングをスペースではなく 0で行うようにする。これは数値ではない出力書式のときも適用される(d.c.)。このフラグはフィールド幅が実際に出力される値の幅よりも大きい場合にのみ効果を持つ。

'

シングルクォート(またはアポストロフィ)はISO Cに対するPOSIXの拡張である。浮動小数点数値の整数部もしくは十進整数値全体に対して 1000ごとの区切り文字を入れることを指示する。これはそれをサポートしているロカールにおいてのみ動作する。たとえば:

$ cat thousands.awk                                     Show source program
-| BEGIN { printf "%'d\n", 1234567 }
$ LC_ALL=C gawk -f thousands.awk                        "C"ロカールで実行
-| 1234567
$ LC_ALL=en_US.UTF-8 gawk -f thousands.awk              US English UTF ロカールで実行
-| 1,234,567

ロカールと国際化に関する事柄についてはWhere You Are Makes A Differenceを参照。

注意: `''はすばらしい機能であるけれども、使うのが複雑である: コマンドラインプログラムにおいて使うことが難しい。クォーティングトリックに関することはシェルのクォーティングについてを参照。

width

これはフィールドの幅を指定する数字である。 `%' と書式指定文字の間に置かれ、この幅にフィールドを広げて出力を行うことを指定する。デフォルトではフィールドを埋めるためのスペースはフィールドの左から置かれる。次のように指定した場合、

printf "%4s", "foo"

prints `•foo'. `•foo'を出力する。

width は(出力の)最小幅であって、最大幅ではない。アイテムの値が width よりも多くのキャラクタを必要としたならば、出力はその幅となる。したがって、

printf "%4s", "foobar"

これは`foobar'を出力する。

マイナス記号を伴ったフィールド幅指定は、幅あわせのためのスペースをフィールドの左ではなく右に置く。

.prec

カンマに続く整数値は出力のときを精度を指定するのに使用する数字である。制御文字で使用する精度を指定する:

%e, %E, %f: 小数点の右側に現れる桁数。
%g, %G: 数の最大桁。
%d, %i, %o, %u, %x, %X: 出力すべき数字の最小桁数。
%s: 出力すべき文字列の最大桁数。

したがって、

printf "%.4s", "foobar"

これは`foob'を出力する。

Cライブラリのprintfは実行時にwidthとprecを指定すること (例えば"%*.*s"のように)ができる。書式文字列中で幅や精度を記述する代わりに、引数リストでそれを渡す事ができる。例えば

w = 5
p = 3
s = "abcdefg"
printf "%*.*s\n", w, p, s

これは以下のものに等しい:

s = "abcdefg"
printf "%5.3s\n", s

上のプログラムは両方とも`••abc'を出力する。 awk の初期のバージョンではこの機能がサポートされていなかった。次の様に書式文字列を組み立てるのに文字列連接を使う事で、この機能をシミュレートする事が可能である。

w = 5
p = 3
s = "abcdefg"
printf "%" w "." p "s\n", s

これは読み易いとは云えないが、きちんと働く。

Cプログラマはprintfの書式指定文字列中で `l'、`L'、`h'というフラグを使っているかもしれない。これらはawkでは不正なフラグである。大部分のawk処理系ではこれらを何の警告もなしに無視する。 `--lint'がコマンドラインで指定されている場合 (see section コマンドラインオプション)、 gawkはこれらのフラグを使用したときに警告を発する。同様に`--posix'が指定されている場合には致命的エラーとなる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.5.4 `printf` を使った例

次の例は、printfを整列したテーブルの出力にどのように使用するかというものである。

awk '{ printf "%-10s %s\n", $1, $2 }' BBS-list

このプログラムは `BBS-list'というファイル中のBBSの名前($1) を10文字の文字列として、左寄せで出力する。同様に電話番号($2)をそれに続いて出力する。結果として、二つのカラムからなる、名前と電話番号のきちんと並んだテーブルが作成される。

$ awk '{ printf "%-10s %s\n", $1, $2 }' BBS-list
-| aardvark   555-5553
-| alpo-net   555-3412
-| barfly     555-7685
-| bites      555-1675
-| camelot    555-0542
-| core       555-2912
-| fooey      555-1234
-| foot       555-6699
-| macfoo     555-6480
-| sdace      555-3430
-| sabafoo    555-2127

なぜ電話番号を数値として出力するように指定していないのかわかるだろうか? ここでは数字がダッシュで区切られているので文字列として出力している。もし、これを数値として出力しようとしたならば、そこで得られるものは最初の三つの数字 `555'である。これは混乱を招くだろう。

ここでは電話番号の出力時の幅を指定していない。それは出力行の最後にあるものであり、その後ろにスペースを置く必要がないからだ。

先頭のカラムにヘッダを付け加えることによってテーブルをより見やすいものにしている。これを行う為に、BEGINパターン(see section 特殊パターン BEGIN と END) を使ってヘッダをawkプログラムの始めで一度だけ出力している。

awk 'BEGIN { print "Name      Number"
             print "----      ------" }
     { printf "%-10s %s\n", $1, $2 }' BBS-list

この例ではprint文と printf文を混ぜて使っているのに気がついただろうか?、同じ結果をprintf文だけを使って得る事ができる。

awk 'BEGIN { printf "%-10s %s\n", "Name", "Number"
             printf "%-10s %s\n", "----", "------" }
     { printf "%-10s %s\n", $1, $2 }' BBS-list

ヘッダと同じ書式指定を使って各カラムを出力しているので、ヘッダと同じように桁揃えされる。

三回同じ書式を指定するのに、変数に書式を代入してその変数で指定する方法がある。実例を挙げよう。

awk 'BEGIN { format = "%-10s %s\n"
             printf format, "Name", "Number"
             printf format, "----", "------" }
     { printf format, $1, $2 }' BBS-list

試しに以前に説明した (see section print 文). `inventory-shipped'の例の、表題と表のデータを printf文でそろえてみてほしい。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.6 `print` や `printf`の出力のリダイレクト

これまではprintやprintfからの出力は標準出力。通常は端末に対してのみ行われていた。 print と printfの両方とも別の場所に出力を送ることができる。これはリダイレクション (redirection)と呼ばれる。

リダイレクションはprint 文か printf文の後に書くことができる。 awkにおけるリダイレクションはシェルコマンドのリダイレクションとよく似ているが、 awkではプログラムの中にリダイレクションの指示を書くという点が違っている。

以下に四種類の出力リダイレクションの例、出力をファイルに送ったり、ファイルに追加したり、パイプを通して他のコマンドに出力したり、コプロセスに出力するものを挙げる。これらの例ではprint文が使われているが、 printf文を使っても同じように動作する。

print items > output-file

この書式のリダイレクションではアイテムの出力をoutput-file というファイルに対して行う。ファイル名 output-fileは式であってもかまわない。式を文字列に変換し、その後にファイル名として使用する (see section 式)。

この書式のリダイレクションは最初の出力を行う前に、 output-fileの削除を実行する。以後はoutput-file の削除はしないでファイルに追加する形で出力を行う。もしoutput-file が存在しなければファイルが新たに作成される。たとえば、次に挙げるawkプログラムはBBSの名前のリストを `name-list'という名前のファイルに、電話番号のリストを`phone-list'というファイルにそれぞれ出力する。出力されたファイルの各行は、一つの名前あるいは番号で構成される。

$ awk '{ print $2 > "phone-list"
>        print $1 > "name-list" }' BBS-list
$ cat phone-list
-| 555-5553
-| 555-3412
…
$ cat name-list
-| aardvark
-| alpo-net
…

それぞれの出力ファイルは一行に一つの名前もしくは番号が置かれる。

print items >> output-file

このリダイレクションは、出力をoutput-fileというファイルに対して行う。先ほどの`>'での指定と違うのは、 output-fileの削除が行われないということである。出力はファイルに追加される形で行われる。 output-fileが存在していなければ、作成される。

print items | command

こうすることによって出力を、ファイルに対して行う代わりにパイプを通して渡す事ができる。このやり方のリダイレクションは commandへのパイプをオープンし、そのパイプを通して、 commandを実行する為に作られたプロセスへ itemsの値を出力する。

リダイレクションの引数commandはawkの式でも良い。その式の値はコマンドを実行するための文字列に変換される。次の例では二つのファイルが作られる。一つはソートされていないBBSの名前のリスト。もう一つはアルファベットの降順にソートされたリストである。

awk '{ print $1 > "names.unsorted"
       command = "sort -r > names.sorted"
       print $1 | command }' BBS-list

この例のソートされていないリストは、ソート済みリストがパイプを通って sortユーティリティが出力する間に、通常のリダイレクトで書き込まれる。

次の例はリダイレクトを使って、メイリングリスト`bug-system'に従ってメイルを送るものである。これはトラブルにあったときに、システムメンテナンスの為に定期的にawk スクリプトを実行するような場合に便利だろう。

report = "mail bug-system"
print "Awk script failed:", $0 | report
m = ("at record number " FNR " of " FILENAME)
print m | report
close(report)

メッセージは文字列連接と変数mに保持されている内容を使って組み立てられている。作成されたメッセージはパイプラインを通してmailプログラムに送られる (カッコは連接すべきアイテムをまとめている --- 文字列連接を参照)。

ここでclose関数を呼んでいるのは、パイプを閉じてすぐに出力を送るためである。詳しいことは See section 入出力のリダイレクトをクローズする。

この例はファイルやコマンドを与えるのに変数を使っている。つまり常に文字列定数を使う、というわけではないということである。 awk が毎回同じ文字列値を要求するので、変数を使うというのは一般にはいいアイデアである。

print items |& command

このタイプのリダイレクションはアイテムをcommandの入力に対して出力する。 `|'によるリダイレクションはcommandの出力を getlineを使って読み出すことができる。したがって、commandはコプロセスであり呼び出し元と一緒に動作するけれどもawkプログラムの配下にある。

この機能はgawkの拡張であり、POSIX awkでは使うことができない。より完全な説明はSee section Two-Way Communications with Another Process。

`>', `>>', `|', `|&' を使って出力をリダイレクトするときに、 file や commandがそれまでにプログラム中で使っていなかったり出力する直前にクローズを行っていたりすると、ファイルやパイプをオープンするためにシステムに問い合わせを行う。

最初のprintのファイルへの出力で`>'を使い、その後の出力に`>>'を使うのはありがちな間違いである:

# ファイルをクリアする
print "Don't panic" > "guide.txt"
…
# 追加
print "Avoid improbability generators" >> "guide.txt"

これはシェルにおいてリダイレクションを行うときには必須であるが、 awkにおいては必要ない。このような場合、出力ファイルはただ一度だけオープンされるのですべてのprint文で`>'を使うべきである。

すでに述べたように (see section Points to Remember About getline)、多くの多くの awkの実装ではawkプログラムがオープンできるパイプラインの数がただ一つに制限されている! gawkでは、そのような制限はない。使用しているオペレーティングシステムが許すだけパイプラインをオープンすることができる。

Advanced Notes: Piping into `sh`

特に強力なリダイレクションの使い方というのは、コマンドラインを組み立ててそれをシェル(sh)に対してパイプで送るというものである。たとえば、すべてのファイル名が大文字で格納されるシステムからファイルのリストを持ってきてそれをすべて小文字の名前に付け替えたいとしよう。以下のプログラムはそれを効率よくやってくれる:

{ printf("mv %s %s\n", $0, tolower($0)) | "sh" }

END { close("sh") }

tolower関数はその引数の中の大文字を全て小文字に変換して返す(see section 文字列操作関数)。このプログラムはコマンドラインのリストを構築する。そしてそのリストをシェルに対して送って実行させる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.7 `gawk` における特殊なファイル名

gawkは内部的に解釈される特殊なファイル名を数多く提供している。これらのファイル名は標準ファイルディスクリプタ、プロセス関係の情報、 TCP/IPネットワーキングに対するアクセスを提供する。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.7.1 標準ディスクリプタのためのスペシャルファイル

実行中のプログラムは、慣習的に三つの入出力ストリームを何もしなくても読み込み、書き込みのために使えるようになっている。それらは標準入力, 標準出力, 標準エラー出力として知られている。これらのストリームはデフォルトでターミナルの入出力に割り当てられている。しかし、しばしばシェルでのリダイレクトによって（`<', `<<',`>', `>>', `>&', `|' といったオペレータを使って）、変更される。標準エラー出力はエラーメッセージの出力にだけ使われる。それは、標準出力、標準エラー出力の二つのストリームがあり、別々にリダイレクトを行う事が可能であるからである。

他のawk処理系では、次のような方法でしか awkプログラムから標準エラー出力にエラーメッセージを出力する事ができない。

print "Serious error detected!" | "cat 1>&2"

これは標準エラー出力にアクセスするためにパイプを開いて awkプロセスの出力を渡している。これはエレガントとは言い難いし、他のプロセスを必要とする非効率的なやり方である。多くの人はこの点にあまり気を使っていないようなawk プログラムを書いている。こういったやり方に代えて、エラーメッセージを次のようにしてターミナルに送る。

print "Serious error detected!" > "/dev/tty"

これは多くの場合同じ結果となるだろうが、常にではない。標準エラー出力は通常端末であるが、リダイレクトすることができ、その場合には出力は端末に対しては行われない。事実、awkをバックグラウンドジョブで実行すると、そのプロセスは端末を持っておらず、`/dev/tty'のオープンは失敗する。

gawkは三つの標準ストリームにアクセスするために特殊なファイル名を持っている。 gawkで入出力をリダイレクトするときにリダイレクト先のファイル名が次の特殊な名前の中にあれば、ファイル名の代わりに gawkは直接(定義されている)ストリームを使用する。これらの特殊なファイル名はgawkが移植されている全てのオペレーティングシステムで動作するが、POSXI準拠のものではない:

`/dev/stdin': 標準入力 (ファイル記述子 0)。
`/dev/stdout': 標準出力 (ファイル記述子 1)。
`/dev/stderr': 標準エラー出力 (ファイル記述子 2)。
`/dev/fd/N': ファイル記述子 N に結び付けられたファイル。そのファイルは awkを実行したプログラム(典型的にはシェル)によってオープンされていなければならない。 gawkが起動されたシェルによって特別なことが行われていない限り、記述子 0, 1, 2 だけが使用可能である。

`/dev/stdin', `/dev/stdout', `/dev/stderr'といったファイル名は`/dev/fd/0', `/dev/fd/1', `/dev/fd/2'の別名である。しかし、より説明的な名前である。 gawkプログラムでエラーメッセージを出力する適切な方法は `/dev/stderr'を以下のようにして使うことである:

print "Serious error detected!" > "/dev/stderr"

ファイル名の周りをクォートでくくっていることに注意。他のリダイレクションと同様、その値は文字列でなければならない。クォートを省略してしまうのはありがちな間違いであり、その場合混乱する結果となるだろう。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.7.2 プロセスに関連した情報のためのスペシャルファイル

gawkはgawkプロセスが実行されている情報にアクセスすることのできる特殊なファイル名も提供している。これらの“ファイル”は情報のレコードを一つ持っている。二度以上読み出すには、最初にclose関数でクローズせねばならない (see section 入出力のリダイレクトをクローズする)。ファイル名は以下のとおり:

`/dev/pid'

このファイルを読むとカレントプロセスのプロセス ID が十進形式で改行で終端されて返ってくる。

`/dev/ppid'

このファイルを読むと、カレントプロセスの親プロセスIDが十進数で、改行で終端されて返ってくる。

`/dev/pgrpid'

このファイルを読むと、カレントプロセスのプロセスグループIDが十進数で、改行で終端されて返ってくる。

`/dev/user'

このファイルを読むと、改行で終端されスペースで区切られたフィールドを持つ一つのレコードが返ってくる。そのフィールドは以下のような情報を表しているものである:

$1: getuidシステムコールの返す値(実ユーザーID番号)。
$2: geteuidシステムコールの返す値(実効ユーザーID番号)。
$3: getgidシステムコールの返す値(実グループID番号)。
$4: etgidシステムコールの返す値(実効グループID番号)。

さらに追加のフィールドがあるなら、 getgroupsシステムコールが返したグループIDである (Multiple グループはすべてのシステムでサポートされているわけではない)。

これらの特殊ファイル名はコマンドライン上でデータファイルのように使ってもよいし、 awkプログラムの中で入出力のリダイレクションで使ってもよい。ただし、`-f'オプションを伴ったソースファイルとしては使うことはできない。

注意: これらのプロセス関係の情報を提供する特殊ファイルは今では時代遅れ(obsolete)なもので、次のgawkのリリースでは完全になくなってしまうだろう。 gawkはこれらのファイルを使うたびに警告のメッセージを出力する。プロセス関係の情報を得るためには、配列 PROCINFOを使用する。 See section 情報を伝達する組み込み変数,

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.7.3 スペシャルファイル for Network Communications

gawkのバージョン 3.1から、awkプログラムで双方向のTCP/IPコネクションをオープンすることが可能となりクライアントやサーバーとして振舞うことができるようになった。これは以下の形式の特殊なファイル名を使って行う:

`/inet/プロトコル/ローカルポート/リモートホスト/リモートポート'

Full discussion is delayed until プロトコルは`tcp', `udp', `raw'のいずれかである。そしてその他のフィールドは作成するネットワークコネクションのための情報となる。これらのファイル名は`|&'演算子を使ってコプロセスとの通信を行う(see section Two-Way Communications with Another Process)。これは発展的な機能であり、ここでは完全性のためにのみ取り上げている。完全な説明はUsing gawk for Network Programmingにある。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.7.4 Special ファイル名 Caveats

以下はgawkが提供する特殊なファイル名を使う際の注意事項のリストである:

これらの特殊なファイル名はgawkが互換モード(see section コマンドラインオプション)のときは使うことができない。
プロセスに関連する情報を提供する特殊ファイルはobsoleteなものであると考えられ、次のリリースのgawkでは完全に取り除かれる。 gawkはこれらのファイルを使用したときには警告メッセージを出力する。プロセス関連の情報を得るにはPROCINFO配列を使用するSee section 組み込み変数。
バージョン 3.1から、gawkは常にこれらの特殊なファイル名を解釈するようになった。(20) たとえば、出力のための`/dev/fd/4'は実際にファイルディスクリプタ4 であり、ファイルディスクリプタ4をdupしたものではない。これはほとんどの場合意味がないことであるけれども、ファイルディスクリプタ0,1,2 に関連したファイルをクローズしないということが重要である。これをしてしまうと予期せぬ動作をすることになる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

4.8 入出力のリダイレクトをクローズする

もし同じファイル名や同じシェルコマンドが、 awkプログラムの実行中に二度以上getline (see section getlineを使った入力) と一緒に使われた場合、ファイルのオープンやコマンドの実行は最初の一回だけ行われる。つまり最初にファイルやコマンドからレコードを読み込むときである。次にgetlineを使って読むときは同一のファイル、コマンドから別のレコードを読み込む。

同様にファイルやパイプが出力のためにオープンされたとき、 awkは(オープンした情報を)そのファイル名やコマンド名と結び付け、後になって出力したときにその出力をそれまでのものに追加する形で行う。ファイルやパイプはawkが終了するまでオープンされている。

このことによって、同じファイルを再び最初から読み始めたいときや、シェルコマンドを再実行（コマンドの出力からもっと読みだしたいとき）したいようなときには特別な手順を踏まねばならない。つまり、次の例のようにclose関数を使わなければならない。

close(filename)

or:

close(command)

引数filenameやcommandは任意の式であってよい。その値は、ファイルをオープンしたりコマンドを起動した文字列と (スペースや他の"irrelevant" (無関係)なキャラクタも含めて) 正確に一致しなければならない。例えば、次のようにパイプをオープンしたら、

"sort -r names" | getline foo

次のようにクローズしなければならない。

close("sort -r names")

一度この関数呼びだしが実行されると、次のファイルやコマンドからのgetlineや、ファイルやコマンドに対するprint、printfは、ファイルの再オープンやコマンドの再実行を行う。ファイルやパイプラインをクローズするのに使う式はそれらのファイルオープンするときやコマンドを実行するときに使った式と正確に一致しなければならないので、ファイル名やコマンドを変数に格納する練習に良い。先の例は以下のように記述することができる:

sortcom = "sort -r names"
sortcom | getline foo
…
close(sortcom)

これは、awkプログラムに見つけづらい打ち間違いのエラー (typographical errors)が入り込むのを防ぐのに役立つ。以下に出力ファイルをクローズする必要があるかもしれない理由を幾つか挙げる:

同一のawkプログラム中で、書き込みを行ったファイルを後で読み返すため。最後の出力が終わったときにファイルをクローズした後で、 getlineを使ってそのファイルから入力を始める事ができる
同一のawkプログラム中で、連続的に複数のファイルに書き込みを行うため。もしファイルのクローズを行わないでいると、一つのプロセスでオープンできるシステムの限界数を越えてしまうかもしれない。それを避けるために書き込みが終了したときにそれをクローズする。
コマンドを終了させるため。パイプを通して出力をリダイレクトしているとき、パイプから読み込みを行っているコマンドはパイプがオープンされていると通常通り入力を読み込もうとし続ける。多くの場合、コマンドはパイプがクローズされるまでその実行を停止できない。例えばリダイレクトでmailプログラムに出力を送ると、そのメッセージはパイプがクローズされるまで実際には送られない。
同じプログラムを、同じ引数で再度実行させるため。これは最初に実行したときに続いて入力を与えるということではない!
例えば、パイプの出力をmailプログラムに送ることを考えてみよう。クローズしないでこのパイプに数行の出力をリダイレクトすると、一つのメッセージに数行があるという結果となるだろう。対照的に、各行を出力した後にパイプをクローズすると、それぞれの行は別々のメッセージに分割される。

システムがオープンすることを許している以上の数のファイルを使おうした場合、 gawkは使っているデータファイルの中で多重オープンを試みる。 gawkのこれを行う能力はあなたが使っているオペレーティングシステムの能力に依存する。したがって、ファイルを使いおわったら常にclose するということがよいやり方であるし、移植性のためによいのである。事実、多くのパイプを使っているときにはコマンドが終了したらそれをクローズすることは効率がよい。たとえば以下の例を考えてみよう:

{
    …
    command = ("grep " $1 " /some/file | my_prog -q " $3)
    while ((command | getline) > 0) {
        process output of command
    }
    # ここに close(command) が必要
}

この例はそれぞれのレコード中のデータに基づいて新しいパイプラインを作る。コメントで示しているようにcloseがなければ、 awkはコマンドを実行するために子プロセスを生成してパイプラインをそれ以上作れなくなってしまうまでファイルディスクリプタを使ってしまう。

各コマンドが実行終了した(getlineのステータスでファイルの終端が示された)としても、子プロセスは終了しない(21)。より重要なことは、パイプのためのファイルディスクリプタは closeが呼び出されるかawkが実行終了するまで解放されないということである。

closeはファイルを表す引数やリダイレクションによってオープンされたパイプ、子プロセスを表す引数が与えられなかった場合にはなにもしない。

`close(FILENAME)'がコマンドラインで与えられたファイルの名前を通じて読み込んでいる暗黙のループに対して、“魔術的な” 効果をもっていないことに注意すること。この場合も、オープンされていないファイルをクローズすることになるので awkはなにもしない。

コプロセスに対して`|&'を使って通信をしているとき、双方向パイプの片方だけをもう片方をクローズせずにクローズすることはとても便利である。これはcloseに二番目の引数を与えることで行うことができる。その他のcloseと同じように、第一引数はコプロセスを起動するのに使用したコマンドの名前か特殊ファイルの名前である。第二引数は文字列で、その値は"to"か"from"のいずれかである。大小文字の違いは意味を持たない。これは発展的機能であるので、詳細はTwo-Way Communications with Another Processで行う。

Advanced Notes: Using `close`'s Return Value

Unix 上のawkの多くは、close 関数は実際には文である。 closeからの戻り値を使おうとすると構文エラーとなる: (d.c.)

command = "…"
command | getline info
retval = close(command)  # 大部分の Unix の awk では構文エラーになる

gawkはcloseを関数として取り扱う。その戻り値はクローズに成功した時0であり、失敗したときには0以外である。失敗した場合にはgawkは組み込み変数ERRNOにエラーの発生を示す文字列がセットする。

gawkでは、パイプやコプロセス(の入力か出力)をクローズしたとき、その戻り値はコマンドの終了ステータスである。(22) それ以外の場合、入出力のファイルをクローズしたときのシステムのcloseもしくはC 関数fcloseの戻り値である。この値はクローズに成功したときにはゼロ、失敗したときは-1である。

POSIX標準はもっと曖昧である。そこではcloseは成功のときにゼロ、そうでないときに非ゼロを返すとしか書いていない。一般的には、異なる実装ではパイプをクローズしたときに異なる値になる。したがって戻り値を移植性のあるものとして使うことはできない。(d.c.)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5. 式

式とはawkのパターンとアクションの基本構成ブロックである。式は出力したり、検査したり、関数に渡す値として評価することができる。それに加えて、式は代入演算子を使って変数やフィールドの新しい値として代入代入することができる。

式はパターンやアクションとして使うことができる。その他のほとんどの文は操作すべき二つ以上の式を有している。他の言語と同様、awkにおける式は変数、配列の参照、定数、関数呼び出しとこれらの演算子を使った組み合わせを含んでいる。

5.1 定数式
5.2 正規表現定数を使う
5.3 変数
5.4 文字列と数値の変換
5.5 数学的演算子		数学的操作 (`+', `-', など)。
5.6 文字列連接
5.7 代入式
5.8 インクリメント/デクリメント演算子
5.9 `awk` における真と偽		``true''とは何か、また、``false''とは何か。
5.10 変数の型付けと比較式		How variables acquire types and how this affects comparison of numbers and strings with `<', etc.
5.11 ブール式		ブール演算子 `\|\|' (``または'')、 `&&' (``かつ'')、`!' (``でない'') を使って比較式を組み合わせる。
5.12 条件式		Conditional expressions select between two subexpressions under control of a third subexpression.
5.13 関数呼び出し
5.14 演算子の優先順位 (How Operators Nest)		様々な演算子をどのようにネストするか。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.1 定数式

もっとも単純な式は定数である。これは常に同じ値を持つ。定数には三種類あり、数値定数、文字列定数、正規表現定数である

これらはそれぞれ、データの値が必要となったときに適切な文脈で使われる。数値定数は異なる形式をもつことができるが、内部的には同一のものとして格納される。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.1.1 数値定数と文字列定数

数値定数は数を意味する。この数は整数でも良いし、小数でも良いし科学(指数)表記の数であっても良い(23)。以下に数値定数の例をいくつか挙げる。これらはすべて同じ値を持つ。

105
1.05e+2
1050e-1

文字列定数は二重引用符で囲まれたキャラクタの並びから構成される。たとえば、

"parrot"

これは`parrot'という構成の文字列である。 gawkにおける文字列は、任意の長さのASCIIのNUL(キャラクタコード 0)も含めた任意の8bit ASCIIキャラクターを使うことが可能である。他のawk処理系では一部のキャラクタコードを扱うことが難しいかもしれない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.1.2 八進数字および十六進数字

awkでは、全ての数値は十進数である。他のプログラミング言語の多くでは別の基数、八進数であるとか十六進数を使って数値を指定することができる。八進数では、数字は0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12 と進む。 `11'は十進数では1掛ける10足す1で`11'であるが、八進数では1掛ける8足す1でこれは十進数の9に等しい。十六進数では数字が16個ある。十進では数字は10個しかない(`0'--`9') ので、残りの数字を表すのに`a'から`f'までの文字が用いられる (大小文字の区別はされないので、十六進数字の`a'と`A'は値としては同じである)。したがって、十六進では1掛ける16足す1で十進数の17となる。

ただ単に`11'と書かれているとき、その基数がなんであるかを判別することはできない。したがってCやC++、Cから派生した言語では基数を識別するための特別な記法がある。八進数値は先頭に`0'を置き、十六進数値には先頭に `0x'か`0X'を置く:

11: 十進数値11．
011: 八進の11、十進の9。
0x11: 十六進の11、十進の17。

以下の例はこれらの違いを明確にする:

$ gawk 'BEGIN { printf "%d, %d, %d\n", 011, 11, 0x11 }'
-| 9, 11, 17

八進定数や十六進定数が可能なことは、バイナリデータのような通常のキャラクタや数値として表現することのできないようなデータを扱うときに便利である。

gawk allows the use of octal and hexadecimal gawkはプログラムテキストの中で八進や十六進の定数を扱うことを許している。しかしながら、そのような数値は入力データの中にある場合には異なる扱いを受ける。これはデフォルトで八進や十六進の定数を扱うようにしてしまうと古いプログラムの動作を変えてしまうからである (もし本当にデフォルト動作を変えたいのなら、`--non-decimal-data' オプションを使用する。see section 十進でない入力データを許す)。八進や十六進のデータがあるのならstrtonum関数(see section 文字列操作関数) を使ってデータを数値へ変換することができる。ほとんどの場合、組み込みのビット操作関数(see section gawk のビット操作関数)を使うときに八進や十六進の定数を使いたくなるだろう。

一部の初期のCの実装と異なり、`8'と`9'は正当な八進数値ではない。 gawkは`018'を十進の18として扱う:

$ gawk 'BEGIN { print "021 is", 021 ; print 018 }'
-| 021 is 17
-| 18

ソースコード中の八進や十六進の定数はgawkの拡張である。 gawkが互換モード(see section コマンドラインオプション)のときには使うことはできない。

Advanced Notes: A Constant's Base Does Not Affect Its Value

数値定数を内部表現に一度変換してしまうと、gawkはもともとの定数がどの基数で記述されたものであるかは記憶していない。内部的な値が常に使われる。これは数値から文字列への変換のときに重要である:

$ gawk 'BEGIN { printf "0x11 is <%s>\n", 0x11 }'
-| 0x11 is <17>

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.1.3 正規表現定数

正規表現定数は/^beginning and end$/のようにスラッシュで囲まれて記述されている正規表現である。awkで使われている大部分の正規表現は定数であるが、 `~' や `!~'といったマッチング演算子は ``動的な'' 正規表現(正規表現を含む普通の文字列や、変数)に使うこともできる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.2 正規表現定数を使う

`~' や `!~'といった演算子の右側で使われたとき、正規表現定数は単にマッチングを試みる正規表現を意味するだけである。しかしながら、(/foo/のような)正規表現定数は単純式のように使われる場合がある。正規表現定数がそのままで現れたとき、それは`($0 ~ /foo/)'であったのと同じ意味になる (d.c.) See section パターンとしての式。このことは、

if ($0 ~ /barfly/ || $0 ~ /camelot/)
    print "found"

と

if (/barfly/ || /camelot/)
    print "found"

がまったく同じであるということである。このルールによる一つの奇妙な結果は、以下のブール式が、正当であるがユーザーが望んだものではないというものである。

# /foo/ が ~ の左側にあることに注意
if (/foo/ ~ $1) print "found foo"

このコードは``明らかに''$1と/foo/という正規表現とのマッチングを行なうように見える。しかし実際にはこの`(/foo/ ~ $1)'という式は、 `(($0 ~ /foo/) ~ $1)' と同じである。言い換えるならば、最初に入力レコードに対して /foo/という正規表現を適用する。その結果は0か1のどちらかであり、マッチの成否によって決定する。その結果に対してレコードの第一フィールドを適用してマッチングを行なう。こういった動作は本当にユーザーが望んでいたテストとは違ったものであろうから、こういった文をプログラム中で見つけると、gawkは警告を発する。もうひとつ、この規則による結果は代入文でも起きる。

matches = /foo/

assigns either zero or one to the variable matches, depending upon the contents of the current input record. This feature of the language has never been well documented until the POSIX specification. この例では変数matchesに、カレント入力レコードの内容によって0か1のどちらかが代入される。言語のこの機能は、POSIX標準までドキュメント化されなかった。

正規表現定数は gensub, sub, gsub といった関数の第一引数として使用され、また、match関数の第二引数として使われる (see section 文字列操作関数)。 gawkも含めて最近のawk処理系では、 split関数の第三引数として正規表現定数を許している。一部の古い処理系ではそうではない (d.c.) これは、ユーザー定義関数 (see section ユーザー定義関数) の引数として正規表現定数を使おうとしたときに混乱を引き起こす。例を挙げると、

function mysub(pat, repl, str, global)
{
    if (global)
        gsub(pat, repl, str)
    else
        sub(pat, repl, str)
    return str
}

{
    …
    text = "hi! hi yourself!"
    mysub(/hi/, "howdy", text, 1)
    …
}

この例では、プログラマーはユーザー定義関数mysubにそれを通して sub や gsubに渡される正規表現定数を渡そうとしている。しかしながら、実際の動作ではpatパラメータは1か0になり、それは/hi/が$0とマッチするかどうかに依存する。これはおそらくユーザーが本当に渡そうとした値とは異なったものであるから、 gawkはユーザー定義関数に対するパラメータに正規表現定数を使おうしたときに警告を発する。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.3 変数

変数とはプログラムのある箇所で、後から別の箇所で参照するために値を格納する方法である。ユーザーは変数をプログラムのテキストの中で自由に扱うことができ、また、変数に対する値の代入をawkのコマンドラインで行うことができる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.3.1 プログラム中での変数の使用

変数にはあとでその値を参照するために名前が付けられている。これまでにも多くの例で変数が出てきた。変数の名前は文字、数字、あるいはアンダースコアの並びでなければならず、かつ、先頭が数字であってはいけない。変数名の大小文字は区別され、したがってa と Aは別の変数である。

変数名はそれ自身が、変数の現在の値を表わす一つの正しい式である。変数は代入演算子 (assignment operators)や増加演算子 (increment operators)、減少演算子 (decrement operators) によって新たな値を与えられる。See section 代入式.

awk. すべての組み込み変数の名前は全体が大文字である。一部の変数はあらかじめ特別な意味を持っているものがある。フィールドセパレータとしてのFSやカレント入力レコード中のフィールド数を表わすNFなどがそれである。 See section 組み込み変数. にそういった変数のリストがある。これら組み込み変数は他の変数のように代入したり値を参照したりできるが、その値は自動的にawkが変更したり、使ったりする。組み込み変数の名前はそれぞれ大文字だけからなる。

awkでの変数は数値でも文字列でも代入することができる。デフォルトでは文字列は空文字列で初期化され、それが数値に変換されるときには 0として扱われる。このことは、awkではCやその他の多くの言語のように変数の初期化を陽に行う必要がないということである。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.3.2 コマンドライン上で変数に代入する

awkを起動したときにコマンドライン上の引数に変数代入(variable assignment) を含めることによって、任意のawkの変数に値をセットすることができる (see section その他のコマンドライン引数)。代入は次のような形式である。

variable=text

こうすることによって、変数に対する値のセットをawkの起動時か入力ファイルと入力ファイルの間で行なうことができる。ここで、代入の前に`-v'というオプションを次のように付けた場合、

-v variable=text

変数に対する値のセットは一番最初、BEGINルールが実行される前に行なわれる。 `-v'オプションとその後の代入はすべてのファイル名の引数の前になければならず、またプログラムテキストがコマンドラインで与えられている場合にも、それの前になければならない (`-v'オプションについての詳細はSee section コマンドラインオプション)。そうでない場合には、変数に対する代入は前に位置しているファイル名を示す引数が処理された後で行なわれる。たとえば、

awk '{ print $n }' n=4 inventory-shipped n=2 BBS-list

この例は全ての入力レコードのフィールド番号がnのフィールドを出力する。最初のファイルが読まれる前に、コマンドラインで変数nに4がセットされる。これによって、`inventory-shipped'から入力されるレコードの 4番目のフィールドが出力される。最初のファイルの処理が終ったあと、そして二番目のファイルの処理が始まる前に、 nは2にセットされる。したがって、`BBS-list'のレコードの二番目のフィールドが出力される

$ awk '{ print $n }' n=4 inventory-shipped n=2 BBS-list
-| 15
-| 24
…
-| 555-5553
-| 555-3412
…

コマンドライン引数はawkプログラム中でARGV という名前の配列によって参照することができる (see section ARGC と ARGV を使う)。 awkはエスケープシーケンスのためにコマンドラインでの代入の値を処理する(see section エスケープシーケンス)。 (d.c.)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.4 文字列と数値の変換

awkプログラムの文脈により、必要に応じて文字列を数値に変換したり数値を文字列に変換したりする。例えば、`foo + bar'という式があったときに、 foo か barの値（もしくは両方）が文字列であった場合、その値は加算が行われる前に数値に変換される。逆に文字列連結中で数値があった場合にはそれは文字列に変換される。例を挙げると、

two = 2; three = 3
print (two three) + 4

この例は数値の27を出力する。変数 two と three の数としての値は文字列に変換され、それが連結される。その結果得られた文字列は再度 23という数に変換され、それに4が加えられる。

何かの理由で数を強制的に文字列に変換したいときは空文字列""をくっつける。逆に文字列を強制的に数に変換するには、文字列に0を加える。文字列の頭の方に数字列がついているような文字列は文字列から数値に変換される。 "2.5"は2.5に、"1e3"は1000に変換され、 "25fix"は数の値として25を持つ。正しい数として認識できない文字列は0に変換される。

数値の文字列への変換のルールは、awkの組み込み変数CONVFMT (see section 組み込み変数)によって制御される。数値は関数sprintfに書式文字列として CONVFMTが渡されたのと同じ様に変換される(see section 文字列操作関数)。

CONVFMTのデフォルトの値は"%.6g"であり、これは値を最低6文字あるとして変換する。一部のアプリケーションのためにこの精度を変更したいと考えるかも知れない。最近のマシンの大部分では倍精度実数は十進数で17桁あれば (ほとんどの場合は)十分に収めることができる。(24)

CONVFMT にsprintfで通常の浮動小数点数を指定しているような文字列ではないものをセットした場合、おかしな結果となるだろう。例えば書式文字列の`%'を忘れた場合には、全ての数値は同じ文字列定数に変換される。特別な場合として数値が整数であった場合、変換した結果の文字列は常に整数のものとなり、 CONVFMTの値に左右されない。次のようなプログラムの断片があったとすると、

CONVFMT = "%2.2f"
a = 12
b = a ""

bは"12.00"ではなく"12"という値を持つ。 (d.c.)

POSIX の標準以前には、awkは数値から文字列への変換の為に OFMTの値を使用していた。 OFMTはprint文で数値を出力するときの書式を指定する。 CONVFMTは、出力するときと変換するときを区別するために導入された。 CONVFMT とOFMTの両方とも、デフォルトの値は"%.6g" である。多くの場合、古いawkはその挙動を変えないだろう。しかし、この様なOFMTの使用は、プログラムを他の実装による awk処理系に持っていくような場合には、常にそのことに注意せねばならない。こういった場合、プログラムを直すよりもgawkそれ自体を移植することを勧める。 print文に関する詳しい説明はSee section print 文。

最後に、繰り返すが数値と文字列の間の変換について述べておこう。 Where You Are Makes A Differenceにおいて、地域ごとのキャラクターセットと言語(ロカール(locale))が gawkのマッチするキャラクタに影響することに言及した。特にawkプログラムに対しては小数点を表すキャラクタに影響する。 "C"ロカールとほとんどの英語圏のロカールでは小数点としてピリオド(`.') を使っている。しかし、多くのヨーロッパのロカールや非英語圏のロカールでは小数点としてカンマ(`,')を使っている。

POSIX標準はawkはawkプログラムのソースコードを読むときやコマンドライン引数(see section その他のコマンドライン引数)で代入を行うときには常にピリオドを小数点として使用するとしている。しかし、入力データを解釈するときやprint、printfで出力するとき、数値から文字列への変換の際にはその地域での小数点キャラクタが使われる。 gawkはバージョン 3.1.3においてこの標準にフルに準拠した。以下の例はGNU/Linuxシステムにおける動作の違いを表したものである。

$ gawk 'BEGIN { printf "%g\n", 3.1415927 }'
-| 3.14159
$  LC_ALL=en_DK gawk 'BEGIN { printf "%g\n", 3.1415927 }'
-| 3,14159
$ echo 4,321 | gawk '{ print $1 + 1 }'
-| 5
$ echo 4,321 | LC_ALL=en_DK gawk '{ print $1 + 1 }'
-| 5,321

`en_DK'ロカールはデンマークにおける英語のロカールであり、小数点としてカンマを使っている。通常の"C"ロカールでは gawkは`4,321'を`4'として扱うが、 Danishロカールではそれは全て数値として扱われ`4.321'となる。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.5 数学的演算子

awk言語は、式を評価するときに一般的な算術演算子を使用する。これらの算術演算子は通常の優先順位の規則にしたがっており、あなたの期待通りに働くだろう。

これは、学生の名前と、各学生の三つのテストの点数が記録されたリストからなる `grades'というファイルの内容である (小さなクラスだ)。

Pat   100 97 58
Sandy  84 72 93
Chris  72 92 89

次のプログラムに`grades'を入力ファイルとして与えると平均点を出力する。

$ awk '{ sum = $2 + $3 + $4 ; avg = sum / 3
>        print $1, avg }' grades
-| Pat 85
-| Sandy 83
-| Chris 84.3333

以下のリストはawkの算術演算子一覧である。優先順位の高い順から低い順にならんでいる。

- x: 反転。
+ x: 単項のプラス。式は数値に変換される。
x ^ y
x ** y: べき乗。xをy乗する。 `2 ^ 3'の値は8になる。 `**'というキャラクタの並びは`^'と等価である。
x * y: 乗算。
x / y: 割り算。awkのすべての数値は浮動小数点数であるので、 `3 / 4' の結果は整数に丸められることはなく、0.75となる (これは特にCのプログラマーにおいてよくある間違いで、 awkにおけるすべての数は浮動小数点数であるということと整数であるように見える定数の割り算も整数ではなく実数が結果となるということを忘れてしっているのである)。
x % y: 剰余。詳しいことはこのリストの後で述べる。
x + y: 加算。
x - y: 減算。

単項のプラスとマイナスは同じ優先順位を持ち、乗算演算子はすべて同じ優先順位を持つ。また、加算と減算は同じ優先順位を持つ。

x % yの剰余を求めるとき、その商は整数にゼロ方向へ丸められ、さらにyが掛けられる。この結果はxから減算される。この操作は``trunc-mod''として知られている。以下の関係が常に保たれる。

b * int(a / b) + (a % b) == a

一つの望ましくないであろうこの剰余の定義の効果は、 xが負であるときにx % yが負になるということである。したがって:

-17 % 8 = -1

他の実装のawkでは、剰余の符号はマシン依存である。

注意: POSIX標準ではべき乗に対して`^'しか定義していない。移植性を最大限に保つには、`**'を使わないこと。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.6 文字列連接

It seemed like a good idea at the time. Brian Kernighan

文字列の演算子はただ一つ、連接のみである。これはそれを表わす特定の演算子を持たない。その代わり、ある式を別の式に何の演算子も挟まずに連続して置いたときに連接が行われる。例を挙げよう。

$ awk '{ print "Field number one: " $1 }' BBS-list
-| Field number one: aardvark
-| Field number one: alpo-net
…

ここで、次のように`:'のあとにスペースがない文字列にしても同様である。

$ awk '{ print "Field number one:" $1 }' BBS-list
-| Field number one:aardvark
-| Field number one:alpo-net
…

文字列の連接が明確な演算子を持っていないので、連接を行なうアイテムをカッコで囲んで連接が確実に行なわれることを保証することがしばしば必要となる。たとえば次のようなコードではfile と name を連接するということが明確になっていない。

file = "file"
name = "name"
print "something meaningful" > file name

これは次のように書く必要がある。

print "something meaningful" > (file name)

連接を使うときには、いつでもカッコで連接の全体を囲むことを勧める (とくに`='の右辺のオペランドであったりしたときには)。文字列連接を使った式には十分注意すること。とくに、連接に使われる式の評価の順番がawk言語において明確になっていない場合には。以下の例を考えてみよう。

BEGIN {
    a = "don't"
    print (a " " (a = "panic"))
}

ここで、aに対する代入が連接により得られる値の取得の前に行われるのか後に行われるのか定義されていない。この結果は `don't panic'か`panic panic'のいずれかになる。他の演算子と混ぜて使うとき、連接の優先順位はしばしば直感に反したものとなる。以下の例を考えてみよう。

$ awk 'BEGIN { print -12 " " -24 }'
-| -12-24

これは``明らかに""、-12、スペース、-24を連結している。しかしスペースはどこに行ってしまったのだろうか? その答えは演算子の優先順位の組み合わせとawkの自動変換規則に隠されている。望みの結果を得るためには、プログラムを以下のように書く。

$ awk 'BEGIN { print -12 " " (-24) }'
-| -12 -24

これはawkに`-24'の`-'を単項のものとして扱うように強制する。そうしなければ以下のように解釈される。

    -12 (" " - 24)
⇒ -12 (0 - 24)
⇒ -12 (-24)
⇒ -12-24

先に述べたように、連接を行うときにはカッコをつけよう。さもなければ結果は保証されない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.7 代入式

代入(assignment)はある変数に新しい値をセットする式である。次の例では、zという変数に1を代入している。

z = 1

この式が実行された後では変数zの値は1になり、代入前のzの値は失われる。

文字列も同じ様に代入を行うことができる。例えば、次の例では messageという変数に"this food is good" という値が格納される。

thing = "food"
predicate = "good"
message = "this " thing " is " predicate

この例はまた、文字列の連接も説明している。 `='は代入演算子(assignment operator)と呼ばれる、演算子の中でもっとも単純なもので、右辺の値をそのまま変更せずに代入する。大部分の演算子(加算、連接、など)は、値を計算する以外になんの作用も持たない。もし、(計算された)その値を無視するならば、それは演算子を使わなかったのと同じ結果となるだろう。しかし代入演算子は異なっていて、値を生成しその値を無視したとしても代入操作は変更された値を自分に格納する。これは副作用(side effect)と呼ばれる。

代入の左辺は変数(see section 変数)を必ずしも必要とせず、それはフィールド (see section フィールドの内容を変更する) や配列の要素 (see section awk における配列)であってもよい。これらは総称してlvalues (左辺値)と呼ばれ、代入演算子の左辺に置くことができる。右辺にはどのような式、特定の値を代入する式やフィールド、配列要素でも (rvalues(右辺値)と呼ばれるような値を)、置くことができる。

重要なことは、変数は常に同じ型であるというわけではないという事である。変数の型は単純に、その時点で格納している値によって決定される。次に挙げるプログラムの断片では、変数fooは最初は数の値を持ち、その後は文字列値を持っている。

foo = 1
print foo
foo = "bar"
print foo

二番目の代入文でfooに文字列値を与えたときに、それ以前の数の値は失われる

数字で始まっていない文字列の値は数値(numeric value)としてはゼロである。次のコードを実行すると、fooの値は5となる。

foo = "a string"
foo = foo + 5

注意: 変数を数値として扱い、その後で文字列として扱うことは混乱を招きやすく、よくないプログラミングスタイルであることに注意すること。先の例は awkの動作がどんなものかを説明するものであって、このようにプログラムを書けば良いという方法ではない!)

代入はそれ自身の値（代入された値）を持つ式である。従って、`z = 1'は1という値を持つ式である。この結果、多重代入を記述することもできる。

x = y = z = 5

この例では三つの変数(x, y, z)全てに、5を格納する。なぜなら、`z = 5'の値は5であり、それがyに格納され、さらに`y = z = 5'の値、つまり5がxに格納される。

代入は式のどこででも使うことができる。例えば`x != (y = 1)'という記述は正しく、これはy に1をセットし、それからxが1と等しいかどうかをテストする。しかし、このスタイルはプログラムを読みにくくするものである。 one-shot programを除いてはこのようなネストした代入を取り除くように書きなおすべきである。

`='は別として、その他の代入演算子は変数の（代入前の）古い値と演算を行う。例えば、`+='という演算子は右辺値を変数の古い値と加算して新しい値を計算する。従って、次の例はfooの値に5加えるということになる。

foo += 5

これは次のように記述したものと同じである。

foo = foo + 5

`+='という演算子を使ったことによりプログラムの意味が明確になる。

`+='(または任意の代入演算子)を使ったときと、演算子の左側のオペランドを演算子の右側で繰り返し使ったときとで異なる場合がある。例を挙げよう。

# Pat Rankin に感謝
BEGIN  {
    foo[rand()] += 5
    for (x in foo)
       print x, foo[x]

    bar[rand()] = bar[rand()] + 5
    for (x in bar)
       print x, bar[x]
}

randは呼ばれるたびに異なる値を返すので、 barの添え字は異なることが保証される (配列とrand関数はまだ説明していない。詳しくは See section awk における配列と数値関数を参照)。この例は代入演算子に関する重大な事実を如実にしている。それは代入演算子の左辺がただ一度しか評価されないということである。左辺と右辺のどちらの式が先に評価されるのかは処理系による。以下の例を考えてみよう。

i = 1
a[i += 2] = i + 1

この例のa[3]の値は2にも4にもなりうる。

table-assign-opsは算術代入演算子のリストである。それぞれ、右側のオペランドに現れた式は数値に変換される。

`Operator`	`Effect`

`lvalue += increment`	`increment を lvalue に足す。`
`lvalue -= decrement`	`decrement を lvalue から引く。`
`lvalue *= coefficient`	`lvalue に coefficient を掛ける。`
`lvalue /= divisor`	`lvalue を divisor で割る。`
`lvalue %= modulus`	`lvalue に modulus での剰余をセットする。`
`lvalue ^= power`
`lvalue **= power`	`lvalue を power 乗する。`

Table 5.1: 算術代入演算子

注意: POSIXでは`^='演算子だけが定義されている。移植性を最大限に保つために、`**=*'演算子は使わないようにすること。

Advanced Notes: `/=' と正規表現との間の構文的な曖昧性

`/='代入演算子と最初のキャラクタが`='である正規表現定数との間には構文的な曖昧さがある。 (d.c.) これは商用のawkで最も明確に現れている。たとえば

$ awk /==/ /dev/null
error--> awk: syntax error at source line 1
error-->  context is
error-->         >>> /= <<<
error--> awk: bailing out at source line 1

回避策は以下のとおり:

awk '/[=]=/' /dev/null

gawkはこの問題や他の自由に入手することのできる awk 処理系にある他の自由に入手することのできる処理系にあるような問題を抱えていない。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.8 インクリメント/デクリメント演算子

インクリメント演算子(increment operators)やデクリメント演算子(decrement operators) は変数の値を1増やすか、1減らすかする。この演算子は代入と同時に使うことができ、インクリメント演算子はそういった場合にawk言語に対して何の影響も及ぼさないが、非常によく行なわれることを省略して記述することができる。

1を加える演算子は`++'と記述する。この演算子は変数のインクリメントを、その値を得る前、得た後のどちらでも行える。変数vに対して先にインクリメントを行うには`++v'と記述する。これはvの値に1を加えて、新しい値がこの式の値となる。 `v += 1'という代入式はこれと全く同じである。変数の後に`++'を記述したものはポストインクリメントと呼ばれる。これは変数の値をインクリメントするが、先ほどと違って、インクリメント式自体の値は変数の古い値である。従って、fooの値が4のとき、`foo++'という式の値は4 であるが foo の値は5に変更されている。言い換えると、この演算子は変数の古い値を返すが副作用としてインクリメントを行うということである。

ポストインクリメントの`foo++'は`(foo+= 1) - 1' という記述とほぼ同じであるが、完全に同じというわけではない。それは、awkでの数値は全て浮動小数点数だからである。浮動小数点数では、 `foo + 1 - 1'は fooと同一ではない。しかし、かなり小さな数(10の12乗、つまり一兆未満) しか扱わない限りはこういった違いはごく僅かである。

フィールド、及び配列要素は変数と同じ様にインクリメントが行われる (フィールドの参照と、変数のインクリメントを同時に行いたいときには `$(i++)'を使う。このカッコはフィールド参照演算子`$' の優先順位のために必ず付けなければならない)。

デクリメント演算子`--'は`++'と同じ様に動作するが、加算ではなく、1 を減算する。`++'と同じく、 lvalueの前に置いてプリデクリメントで使用したり、 lvalueの後ろに置いてポストデクリメントで使用することができる

++lvalue: この式はlvalueをインクリメントし、インクリメント後の値をこの式の値とする
lvalue++: この式もlvalueの内容をインクリメントするが、式の値はインクリメントする前の古いlvalueの値となる。
--lvalue: `++lvalue'と似ているが、加算ではなく減算を行う。 lvalueを減じ、その結果が式の値となる。
lvalue--: `lvalue++'と似ているが加算ではなく減算を行う。 lvalueを減じ、式の値はデクリメントする前の古い値となる。

Advanced Notes: Operator Evaluation Order

Advanced Notes: 演算子の評価順序

Doctor, doctor! It hurts when I do this! So don't do that! Groucho Marx

以下のようにしたとき何が起こるだろうか?

b = 6
print b += b++

あるいは次のものでは?

b = 6
b += ++b + b++
print b

言い換えれば、後置演算子(`b++')による副作用が効果をもつのはいつか? 副作用が起きるのは実装定義である。言い換えれば、それはawkの特定のバージョンに依存するものである。最初の例の結果は12か13であり、二番目の例の結果は22か23になるだろう。

まとめると、こういうことをするのは勧められないし移植性のためにはその動作に頼るべきではない。あなたのプログラムからはこういったことは取り除いた方が良い。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.9 `awk` における真と偽

多くのプログラミング言語では、``真''、``偽''を表わすような特別なものがある。そういったものを持ったプログラミング言語では、 trueとかfalse あるいはこれらの大文字のものを一般に使っている、しかしawkは違っている。 awkでは、非常に単純な、真偽に関するコンセプトをCから受け継いでおり、 0ではない数値、あるいは空ではない文字列は真となる。そうではない値(ゼロか空文字列、"")は偽となる。次のサンプルプログラムは、`A strange truth value'を三回出力する。

BEGIN {
   if (3.1415927)
       print "A strange truth value"
   if ("Four Score And Seven Years Ago")
       print "A strange truth value"
   if (j = 57)
       print "A strange truth value"
}

びっくりするような``non-zero or non-null'' の結果が生じることがある。 "0"という文字列定数は、真である。なぜなら、これは空文字列ではないからである。 (d.c.)

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.10 変数の型付けと比較式

The Guide is definitive. Reality is frequently inaccurate. The Hitchhiker's Guide to the Galaxy

他のプログラミング言語とは異なり、awkの変数は固定した型を持っておらず、なにから代入されたかによって数値にも文字列にもなる

1992年のPOSIX標準では、数値文字列(numeric string)の概念が導入された。これは" +2"のような、数値のように見える文字列である。この概念は変数の型を決定するのに使われる。変数の型は二つの変数をどのように比較するのかを決定するのに影響するので、非常に重要である。 gawkでは、変数の型は以下のルールに従う。

数値リテラルや数値演算の結果は数値属性を持つ。
文字列リテラルや文字列演算の結果は文字列属性を持つ。
フィールド、getline入力、FILENAME、ARGVの要素、 ENVIRONの要素、splitで作成された配列の要素、といったもので数値文字列のものは数値文字列属性を持っている。それ以外(数値文字列でないもの)は文字列属性を持つ。初期化されていない変数は同様に数値文字列属性を持つ。
属性は代入を通じて伝播するが使用することによって変ることはない。

この最後のルールは特に重要である。次のプログラムでは、 aは文字列演算の後でも数値タイプを持つ。

BEGIN {
         a = 12.345
         b = a " is a cute number"
         print b
}

二つのオペランドを比較するときは、オペランドの属性によって文字列演算子か数値演算子のいずれかが以下の一覧に従って決定され、使用される。

        +----------------------------------------------
        |       STRING          NUMERIC         STRNUM
--------+----------------------------------------------
        |
STRING  |       文字列          文字列          文字列
        |
NUMERIC |       文字列          数値            数値
        |
STRNUM  |       文字列          数値            数値
--------+----------------------------------------------

基本的な考え方は、ユーザーの入力が数値のように見え、ユーザーが入力だけ行ったときのみ数値であり、そのデータがキャラクタから構成されていた場合にはそれは文字列であるというものである。したがって、たとえば" +3.14"という文字列定数は数値のように見えるが文字列であり、比較のために数値として扱われることはない。

まとめると、一つのオペランドが文字列定数のような``純粋な''文字列であるとき、文字列比較が行われる。そうでなければ数値比較が行われる。 (25)

比較式(comparison expression)は文字列あるいは数値の、等しいかなどの比較を行う。この式はCのスーパーセットになっている関係演算子 (relational operators) を使用する。table-relational-opsで説明する。

`Expression`	`Result`

`x < y`	`x が y より小さいときに真。`
`x <= y`	`x が y 以下のときに真。`
`x > y`	`x が y より大きいときに真。`
`x >= y`	`x が y以上のときに真。`
`x == y`	`x が yと等しいときに真。`
`x != y`	`x が yと等しくないときに真。`
`x ~ y`	`文字列x が正規表現 yとマッチするときに真。`
`x !~ y`	`文字列x が正規表現 yとマッチしないときに真。`
`subscript in array`	`配列array が subscriptで添え字付けされる要素を持っているときに真。`

Table 5.2: 関係演算子

比較式は、真のときその値として 1 を持ち、偽のとき 0 を持つ。比較式のオペランドが異なる型であった場合、数値オペランドは CONVFMTの値を使って文字列に変換される (see section 文字列と数値の変換)。

文字列の比較は文字列の先頭からキャラクタごとの比較で行なわれる。したがって、 "10" は "9"よりも小さい、ということになる。二つの文字列が他方の前の部分に等しいような場合、つまり "abc" と "abcd"の比較では、短い方の文字列 "abc" がより小さい、と認識される。

次の例は、非常にありがちな、`=='演算子の`='を一つ忘れてしまうというものである。これは正しいawkプログラムであるが、期待した動作はしないだろう。

if (a = b)   # おおっと! a == b であるべき
   …
else
   …

bが0か、空文字列でない限り、i fの条件式は常に真になる。演算子がこのように似ているために、この種のエラーはソースコードを眺めたときに見つけることは非常に難しい。

以下にgawkがどのように比較を行ない、どのような結果となるのかの例を挙げる。

1.5 <= 2.0: 数値比較 (真)
"abc" >= "xyz": 文字列比較 (偽)
1.5 != " +2": 文字列比較 (真)
"1e2" < "3": 文字列比較 (真)
a = 2; b = "2"
a == b: 文字列比較 (真)
a = 2; b = " +2"
a == b: 文字列比較 (偽)

$ echo 1e2 3 | awk '{ print ($1 < $2) ? "true" : "false" }'
-| false

この例では`false'が出力される。なぜなら$1 と $2の両方が数値文字列(strnum)属性を持ち、文字列でもあり数値でもあるので数値として比較が行なわれたからである。比較ルールと数値文字列を使用する目的は、正しい動作を、驚くようなことができるだけ少なくなるように行なわせるということである。文字列の比較と正規表現の比較は非常に異なっている。例を挙げると、

x == "foo"

この式は変数xが`foo'であるときに 1あるいは真の値を持つ。対照的に、

x ~ /foo/

この式はxに`foo'が含まれているもの、例えば "Oh, what a fool am I!"であれば式の値は1となる。

`~' 演算子や `!~'演算子の右側にくるオペランドは正規表現定数(/…/)でもあり、通常の式でもある。これは、ちょうど文字列としての式の値が動的正規表現 (see section 正規表現の使い方とsee section 動的正規表現を使う) であるということと同じである

最近のawkの処理系ではスラッシュで囲まれた正規表現定数はそれ自体が式であり、 /regexp/という正規表現は以下の比較式の省略形である。

$0 ~ /regexp/

/foo/ が`$0 ~ /foo/' の省略形にならない特別な場所は、 `~'演算子や`!~'の右辺のオペランドである。詳しくはsee section 正規表現定数を使うで述べられている。

[ < ]

[ > ]

[ << ]

[ Up ]

[ >> ]

[Top]

[Contents]

[Index]

[ ? ]

5.11 ブール式

ブール式(Boolean expression)は比較式やマッチング式を論理演算子 ``または''(`||') や ``かつ''(`&&')、否定(`!') を用いて繋げたものである。論理式全体の真偽は各部分式の真偽値の組み合わせによって決定される。ブール式は論理式でもあり、これら二つの単語の意味は同じである。

ブール式は、比較式やマッチング式を記述できるところであればどこでも記述することができるし、if、while、do や for といった文のなかで使うこともできる (see section アクション中の制御文)。ブール式は真のとき1、偽のとき0の値を持ち、その結果を変数に格納したり算術式に使うこともできる。

それに加えて、それぞれのブール式は正しい論理パターンでもあるので、ルールの実行を制御するパターンとして使うこともできるブール演算子には以下のものがある。

boolean1 && boolean2

boolean1 と boolean2の両方ともが真のときに真となる。たとえば、次の例ではカレント入力レコードに`2400' と `foo' の両方が含まれているときにそのレコードが出力される。

if ($0 ~ /2400/ && $0 ~ /foo/) print

部分式boolean2は、boolean1が真であったときにのみ評価が行なわれる。このことによって、boolean2が副作用を持つ式であったときに違った結果になるようにすることもできる。たとえば `$0 ~ /foo/ & ($2 == bar++)'といった式では、 `foo'がレコード中に存在しなかった場合には変数barはインクリメントされない。

boolean1 || boolean2

boolean1 か boolean2の少なくともどちらか一方でも真であれば論理式全体が真となる。たとえば、次の例では `2400' か`foo'のどちらか一方、あるいはその両方が入力ファイル`BBS-list'からの入力レコード中にあったときにそのレコードを出力する。

if ($0 ~ /2400/ || $0 ~ /foo/) print

部分式boolean2は、boolean1が偽であったときにだけ評価が行なわれる。このことにより、boolean2が副作用を持っていたときには異なった結果をもたらすこともある。

! boolean

booleanが偽であるときに真となる。たとえば、次の例では HOME環境変数が未定義であるときに`no home!'を出力する。

BEGIN { if (! ("HOME" in ENVIRON))
               print "no home!" }

in演算子は配列要素への参照で説明されている。

`&&'演算子や`||'演算子は、その動作から短絡評価 (short-circuit)演算子と呼ばれる。一部分を評価することで全体の値を決定できる場合には、式全体の評価は"短絡"(short-circuited)される。

`&&' や `||'の後に改行を置くことによって、行の継続をすることができる。しかし、改行をこれらの演算子の前にバックスラッシュによる行継続なしで置くことはできない (see section awk Statements Versus Lines)。

`!'演算子を使った式の値は1か0のいずれかになる。これは演算子を適用した式の真偽の値による。 `!'演算子はフラグ変数の意味を真から偽に変えたり、逆方向に変えるのによく使われる。例えば、次のプログラムは特殊なパターン行の間の行を出力するものである。

$1 == "START"   { interested = ! interested; next }
interested == 1 { print }
$1 == "END"     { interested = ! interested; next }

interestedという変数は、awkのすべての変数と同様に初期値0(偽)でスタートする。最初のフィールドが`START'であるような行を見つけたとき、 interestedの値は `!'を使って真へと変わる。最初のフィールドが`END'であるような行を見つけたとき、 interestedは偽へと戻る。

注意: next文はnext 文で説明されている。 nextはawkに対して残りのルールをスキップして次のレコードを取り込み、そしてルール群の先頭から処理を始めるように指示する。これを使�

General Introduction

序文

前書き

awk と gawk の歴史

0.1 A Rose by Any Other Name

0.2 この本を使う

0.3 Typographical Conventions

Dark Corners

GNU プロジェクトとこの本

貢献の仕方

謝辞

1. Getting Started with awk

1.1 awk プログラムの実行の仕方

1.1.1 使い捨ての一発awkプログラム

1.1.2 awk を入力ファイルなしで実行する

1.1.3 長いプログラムを実行する

1.1.4 実行可能な awk プログラム

Advanced Notes: Portability Issues with `#!'

1.1.5 awk プログラム中のコメント

1.1.6 シェルのクォーティングについて

1.2 例のための データファイル

1.3 幾つかの単純な例

1.4 二つのルールの例

1.5 より複雑な例

1.6 awk Statements Versus Lines

1.7 awk のその他の機能

1.8 awk を使うとき

2. 正規表現

2.1 正規表現の使い方

2.2 エスケープシーケンス

Advanced Notes: Backslash Before Regular Characters

Advanced Notes: メタキャラクタのエスケープシーケンス

2.3 正規表現演算子

2.4 キャラクタリストの使用

2.5 gawk固有の正規表現演算子

2.6 Case Sensitivity in Matching

2.7 どのくらいテキストがマッチするか?

2.8 動的正規表現を使う

Advanced Notes: 動的正規表現のキャラクタリストで \n を使う

2.9 Where You Are Makes A Difference

3. 入力ファイルを読む

3.1 入力がどのようにレコードに分割されるか

Advanced Notes: RS = "\0" Is Not Portable

3.2 フィールドを検査する

3.3 定数でないフィールド番号

3.4 フィールドの内容を変更する

3.5 フィールドがどのように分割されるかを特定する

3.5.1 フィールド分割のために正規表現を使う

3.5.2 ここのキャラクタを別個のフィールドにする

3.5.3 コマンドラインから FS を設定する

3.5.4 フィールド分割のまとめ

Advanced Notes: FS の変更はフィールドに影響しない

Advanced Notes: FS と IGNORECASE

3.6 固定長データを読む

3.7 複数行レコード

3.8 getlineを使った入力

3.8.1 引数なしで getline を使う

3.8.2 変数にgetlineの結果を格納する

3.8.3 getlineを使ったファイルからの入力

3.8.4 getlineを使ってファイルから変数へ格納

3.8.5 Using getline from a Pipe

3.8.6 getlineを使ったパイプからの入力

3.8.7 Using getline into a Variable from a Pipe

3.8.8 getlineを使ってパイプからの内容を変数に格納する

3.8.9 getline を使ってコプロセスから入力する

3.8.10 getlineを使ってコプロセスから変数に格納する

3.8.11 Points to Remember About getline

3.8.12 getlineに関して覚えておくべきこと

3.8.13 getline の変種のまとめ

4. Printing Output

4.1 print 文

4.2 print 文の例

4.3 出力セパレータ

4.4 printの数値出力を制御する

4.5 printfを使って出力を整える

4.5.1 Introduction to the printf Statement

4.5.2 書式制御文字

4.5.3 printf の書式の修飾子

4.5.4 printf を使った例

4.6 print や printfの出力のリダイレクト

`awk` と `gawk` の歴史

1. Getting Started with `awk`

1.1 `awk` プログラムの実行の仕方

1.1.1 使い捨ての一発`awk`プログラム

1.1.2 `awk` を入力ファイルなしで実行する

1.1.4 実行可能な `awk` プログラム

1.1.5 `awk` プログラム中のコメント

1.2 例のためのデータファイル

1.6 `awk` Statements Versus Lines

1.7 `awk` のその他の機能

1.8 `awk` を使うとき

2.5 `gawk`固有の正規表現演算子

Advanced Notes: 動的正規表現のキャラクタリストで `\n` を使う

Advanced Notes: `RS = "\0"` Is Not Portable

3.5.3 コマンドラインから `FS` を設定する

Advanced Notes: `FS` の変更はフィールドに影響しない

Advanced Notes: `FS` と `IGNORECASE`

3.8 `getline`を使った入力

3.8.1 引数なしで `getline` を使う

3.8.2 変数に`getline`の結果を格納する

3.8.3 `getline`を使ったファイルからの入力

3.8.4 `getline`を使ってファイルから変数へ格納

3.8.5 Using `getline` from a Pipe

3.8.7 Using `getline` into a Variable from a Pipe

3.8.8 `getline`を使ってパイプからの内容を変数に格納する

3.8.9 `getline` を使ってコプロセスから入力する

3.8.10 `getline`を使ってコプロセスから変数に格納する

3.8.11 Points to Remember About `getline`

3.8.12 `getline`に関して覚えておくべきこと

3.8.13 `getline` の変種のまとめ

4.1 `print` 文

4.2 `print` 文の例

4.4 `print`の数値出力を制御する

4.5 `printf`を使って出力を整える

4.5.1 Introduction to the `printf` Statement

4.5.3 `printf` の書式の修飾子

4.5.4 `printf` を使った例

4.6 `print` や `printf`の出力のリダイレクト

Advanced Notes: Piping into `sh`

4.7 `gawk` における特殊なファイル名

Advanced Notes: Using `close`'s Return Value

5.9 `awk` における真と偽