*pattern.txt*	For Vim バージョン 9.2.  Last change: 2026 Feb 14


		  VIM リファレンスマニュアル	by Bram Moolenaar


パターンと検索コマンド					*pattern-searches*

最も基本的な説明はユーザーマニュアルの |03.9| にあります。
27章 |usr_27.txt| にも説明があります。

1. 検索コマンド			|search-commands|
2. パターンの定義		|search-pattern|
3. Magic			|/magic|
4. パターンの概要		|pattern-overview|
5. 量指定子			|pattern-multi-items|
6. 普通のアトム			|pattern-atoms|
7. 大文字と小文字を無視する	|/ignorecase|
8. 合成文字			|patterns-composing|
9. Perl のパターンとの比較	|perl-patterns|
10. マッチしたテキストを強調する|match-highlight|
11. ファジーマッチ		|fuzzy-matching|

==============================================================================
1. 検索コマンド					*search-commands*

							*/*
/{pattern}[/]<CR>	[count] 番目にマッチする {pattern} を前方検索します。
			|exclusive|(排他的)

/{pattern}/{offset}<CR> [count] 番目にマッチする {pattern} を前方検索し、
			|{offset}| 行だけ上/下に移動します。|linewise|(行指向)

							*/<CR>*
/<CR>			[count] 番目にマッチする最終検索パターン|last-pattern|
			を、最後に使われた|{offset}|を使って、前方検索します。

//{offset}<CR>		[count] 番目にマッチする最終検索パターン|last-pattern|
			を、新しい |{offset}| を使って前方検索します。
			{offset} を指定しなかった場合、|{offset}| は使われませ
			ん。

							*?*
?{pattern}[?]<CR>	[count] 番目にマッチする {pattern} を後方検索します。
			|exclusive|(排他的)

?{pattern}?{offset}<CR> [count] 番目にマッチする {pattern} を後方検索して
			|{offset}| 行だけ上/下に移動します。|linewise|(行指向)

							*?<CR>*
?<CR>			[count]番目にマッチする最終検索パターン|last-pattern|
			を、最後に使われた|{offset}|を使って、後方検索します。

??{offset}<CR>		[count]番目にマッチする最終検索パターン|last-pattern|
			を、新しい |{offset}| を使って後方検索します。
			{offset} を指定しなかった場合、|{offset}| は使われませ
			ん。


							*n*
n			最後の "/" か "?" を [count] 回繰り返します。
			カーソルが移動しないときは、検索は [count] + 1で繰り返
			されます。
			|last-pattern|

							*N*
N			最後の "/" か "?" を逆方向に [count] 回繰り返します。
			|last-pattern|

							*star* *E348* *E349*
*			[count] 番目にマッチする単語を前方検索します。検索され
			る単語は、カーソルに最も近い単語です。次の順番で選択さ
			れます:
				1. カーソル位置のキーワード 'iskeyword'
				2. 現在行の、カーソルの後ろの最初のキーワード
				3. カーソル位置の単語 (|WORD|)
				4. 現在行の、カーソルの後ろの最初の単語
			"/\<keyword\>" と検索するのと同じように、完全なキー
			ワードのみ検索されます。|exclusive|(排他的)
			'smartcase' ではなく 'ignorecase' の設定が使われます。

							*#*
#			"*" と同じですが、後方検索します。ポンド記号 (文字コー
			ド 163) でも動作します。"#" キーがバックスペースとして
			動作する場合は、Vim を起動する前に "stty erase <BS>"
			としてみてください (<BS> は CTRL-Hもしくは本当のバック
			スペースです)。

							*gstar*
g*			"*" と似ていますが "\<" と "\>" を単語の周りに加えませ
			ん。つまり単語の一部にマッチするものを検索することもで
			きます。

							*g#*
g#			"#" と似ていますが "\<" と "\>" を単語の周りに加えませ
			ん。つまり単語の一部にマッチするものを検索することもで
			きます。

							*gd*
gd			ローカル宣言を検索します。カーソルがローカル変数の上に
			ある場合、その変数の宣言にジャンプします。これはCのコー
			ドで動作するように作られており、他の言語では正しく動作
			しないことがあります。
			はじめに、Vim は現在の関数の開始行を検索します ("[["
			コマンドと同じ)。見つからなかった場合は、ファイルの 1
			行目に移動します。見つかった場合は、その場所から空行を
			後方検索します。そして、"*" コマンドで検索するのと同じ
			ように、キーワードを検索します。このとき、コメントと判
			断した行は無視します('comments' オプション参照)。
			Note: Vim は文法を実際にチェックしているわけではなく、
			キーワードにマッチするものを検索しているだけですので、
			これがうまく動作するとは限りません。インクルードされて
			いるファイル内も検索したい場合は、|include-search| で
			列挙されているコマンドを使ってください。
			このコマンドを実行した後、コマンド|n|で次のマッチを前
			方検索できます。

							*gD*
gD			グローバル宣言を検索します。ファイル内で定義されている
			グローバル変数の上にカーソルがある場合、その宣言にジャ
			ンプします。"gd" と同じですが、このコマンドは常に 1 行
			目からキーワードを検索します。

							*1gd*
1gd			"gd" と同じですが、現在のカーソル位置より前の {} ブ
			ロック内を無視します。

							*1gD*
1gD			"gD" と同じですが、現在のカーソル位置より前の {} ブ
			ロック内を無視します。

							*CTRL-C*
CTRL-C			現在の(検索)コマンドを中止します。MS-Windowsでは
			CTRL-Breakを使ってください |dos-CTRL-Break|。
			ノーマルモードでは、入力済みの、まだ実行されていないコ
			マンドをすべて中止します。
			出力をリダイレクトして Vim を起動し、変更されたバッファ
			がない場合、CTRL-C で Vim を終了します。これは、"vim
			file | grep word" を使用していて、抜け出す方法がわから
			ないユーザーを支援するためです(盲目的に :qa<CR> と入力
			してもうまくいきます)。
			|popup-filter| ありのポップアップが開いている場合、ポッ
			プアップは閉じられる。

							*:noh* *:nohlsearch*
:noh[lsearch]		'hlsearch' オプションによる強調表示をやめます。検索コ
			マンドを使うか、'hlsearch' をオンに設定すると、再び強
			調表示されます。このコマンドは自動コマンド中は機能しま
			せん。自動コマンドを実行する時に強調表示の状態を保存
			し、実行後に元に戻すからです。|autocmd-searchpat|ユー
			ザー関数を呼び出したときも同様。


'incsearch' オプションがオンの場合、検索パターンを入力している途中に、その時点
でマッチしているものが強調表示されます。実際に、その場所にカーソルを移動させる
には <CR> を打って検索を終了する必要があります。検索を中止するには <Esc> キー
を使ってください。

							*nohlsearch-auto*
'hlsearch' オプションがオンの場合、最後に使った検索パターンは強調表示されます。
これは |:nohlsearch| コマンドで一時停止することも、nohlsearch プラグインで自動
的に一時停止することもできます。|nohlsearch-install| を参照。


'shortmess' が "S" フラグを含まない場合、Vim はカーソルが位置するインデックス
を自動的に表示します。これはこのように見えます: >

  [1/5]		カーソルは 5 つのマッチの先頭に位置しています。
  [1/>99]	カーソルは 99 より多いマッチの先頭に位置しています。
  [>99/>99]	カーソルは 99 より多いマッチの 99 番目以降に位置しています。
  [?/??]	いくつのマッチが存在しているのか不明です。検索の時間切れによっ
		て統計が中断された場合に生成されます。

Note: 総数はオフセットを考慮していません。

マッチが見つからなかった場合はエラーが表示されます: *E486* Pattern not found
Note: `:global` コマンドを旧来のスクリプトで使うと、Vi の互換性のためノーマル
メッセージ "Pattern not found" になります。
|Vim9| script ではエラーで E486 の "pattern not found" か `:vglobal` で各行に
マッチするパターンの時に *E538* になります。
|:s| コマンドでは "e" フラグを指定することでエラーメッセージを抑制できます
|:s_flags|。

					*search-options*
以下のオプションは、Vim で検索を実行する方法に影響します:
    'hlsearch'		マッチをハイライトする
    'ignorecase'	検索時に大文字と小文字を区別しない
    'imsearch'		検索パターンを入力するときに |IME| を使用する
    'incsearch'		パターンを入力すると、マッチするものが段階的に表示される
    'maxsearchcount'	検索カウントの最大数 |shm-S|
    'shortmess'		メッセージを抑制 |shm-s|。検索件数を表示 |shm-S|
    'smartcase'		パターンに大文字が含まれている場合は 'ignorecase' を上
			書きする
    'wrapscan'		ファイルの先頭から検索を続行する

					*search-offset* *{offset}*
上記の検索コマンドは指定されたパターンを検索します。"/" と "?" ではさらにオフ
セットを指定できます。オフセットには、行オフセットと文字オフセットの 2 種類あ
ります。

オフセットを指定して、マッチした場所から相対的にカーソルを移動できます:
    [num]	[num]行下、1 桁目に移動
    +[num]	[num]行下、1 桁目に移動
    -[num]	[num]行上、1 桁目に移動
    e[+num]	[num]文字右に、マッチ部分の終わりの場所から移動
    e[-num]	[num]文字左に、マッチ部分の終わりの場所から移動
    s[+num]	[num]文字右に、マッチ部分の初めの場所(start)から移動
    s[-num]	[num]文字左に、マッチ部分の初めの場所(start)から移動
    b[+num]	[num] 上記 s[+num] と同じ (begin の b)
    b[-num]	[num] 上記 s[-num] と同じ (begin の b)
    ;{pattern}  さらに検索する。|//;|を参照。

'-' か '+' を指定して [num] を省略した場合は 1 が使われます。'e' を使ってオフ
セットを指定した場合、検索は包括的になります (カーソルが移動するであろう位置の
文字まで含めて操作の対象になります)。

例:

パターン		カーソルの位置 ~
/test/+1		"test" の 1 行下の 1 桁目
/test/e			"test" の最後
/test/s+2		"test" の 's'
/test/b-3		"test" の 3 文字前

これらのコマンドがオペレータに対して使われた場合、現在のカーソル位置から、検索
後のカーソル位置までが、操作の対象となります。ただし、行オフセットが指定された
場合は、2 つのカーソル位置の間の行全体が操作の対象となります。

パターンを検索して置換する例: >
	/foo<CR>	"foo" を検索
	c//e<CR>	マッチした文字列を変更
	bar<Esc>	置換する文字を入力
	//<CR>		次のマッチへ移動
	c//e<CR>	マッチした文字列を変更
	beep<Esc>	今度は別の文字で置換
			...
<
							*//;* *E386*
非常に特殊なオフセットですが、';' に続けて検索コマンドを指定できます。例: >

   /test 1/;/test
   /test.*/+1;?ing?

一つ目の例は、はじめに次の "test 1" を検索し、それから "test" を検索します。

これは、2 つの検索コマンドを分けて実行するのと似ていますが、次の点が違います:
- 合わせて 1 つの検索コマンドなので、オペレータに対して使うことができます。
- "n"、"N" コマンドを使った場合、検索方向は最初の検索コマンドと同じです。
- エラーが起きた場合、カーソルはまったく動きません。

							*last-pattern*
最後に使われた検索パターン (最終検索パターン) とオフセットは記憶され、同じ検索
を繰り返すのに使うことができます。検索方向を変えたり、カウントを指定したりする
こともできます。Note: 記憶されるパターンは 2 つあります。1 つは「通常の」検索
コマンドのパターンです。もう 1 つは置換コマンド ":s" のパターンです。空のパ
ターンを指定すると直前に使用されたパターンが使われます。ただし、検索パターンが
まだ使用されてなかった場合は、可能であれば、直前の置換コマンドのパターンが使わ
れます。

'magic' オプションは最終検索パターンに影響しません。'magic' を変更しても、最終
検索パターンの解釈は変わりません。
'ignorecase' オプションは違います。'ignorecase' が変更された場合、最終検索パ
ターンは、違うテキストにマッチする可能性があります。

'hlsearch' オプションがオンの場合、最終検索パターンにマッチするテキストが強調
表示されます。

最終検索パターンを消去するには次のようにします: >
	:let @/ = ""
パターンに空文字列をセットしているのではありません。それだと全ての場所にマッチ
してしまいます。パターンは本当に消去され、Vim起動直後のように、何もない状態に
なります。

検索では通常、カーソル下のマッチはスキップされます。そのとき、すぐ隣の文字から
検索を開始するのか、スキップしたマッチの後ろから検索を開始するのかは、
'cpoptions' の 'c' フラグに依存します。|cpo-c|を参照。
	'c' フラグがある場合:   "/..." は 1 から 3 文字ずつ進みます。
	'c' フラグがない場合:   "/..." は 1 文字ずつ進みます。
検索は行頭から開始され、カーソル位置を過ぎたマッチを見付けるまでスキップされま
す。そのため、'c' フラグを含んでいる場合の動作は予想外かもしれません。
{訳注: aaaaaa
       カーソルが 2 桁目にある場合、/aaa は 4 桁目からの aaa にマッチする。
       これは、行頭から aaa aaa というマッチの区切りになり、
       カーソルを含んだ最初の aaa がスキップされるため。}

後方検索するときも、検索は行頭から始まり、上述のように 'cpoptions' の 'c' フラ
グが使われます。そして、カーソル位置より前でマッチする最後のマッチが使われます。

Vi では、":tag" コマンドでタグを検索すると、最終検索パターンは上書きされます。
Vim では、'cpoptions' に 't' フラグがある場合のみ、最終検索パターンが上書きさ
れます。どちらにしても、検索パターンは常に検索履歴に保存されます。

'wrapscan' オプションがオン (初期設定) の場合、検索がバッファの端に到達したと
きに、もう一方の端に移動して検索が継続されます。オフの場合は、後方検索ならバッ
ファの先頭、前方検索ならバッファの末尾でストップします。
パターンが見つからなかった場合、'wrapscan' がオンのときは、"pattern not found"
というメッセージが表示され、カーソルは動きません。オフのときは、後方検索なら
"search hit TOP without match"、前方検索なら "search hit BOTTOM without
match"、というメッセージが表示されます。
'wrapscan' がオンのときに検索がバッファの端から端へ継続した場合、後方検索なら
"search hit TOP, continuing at BOTTOM"、前方検索なら "search hit BOTTOM,
continuing at TOP" というメッセージが表示されます。このメッセージを表示しない
ようにするには、'shortmess' オプションに 's' フラグを設定します。メッセージは
'highlight' オプションの 'w' で強調表示されます (初期設定: standout)。

							*search-range*
"/" コマンドで検索するとき、\%>l を含めることで検索の範囲を指定できます。
例えば、199行目と300行目の間にある "limit" という単語を検索するには次のように
します: >
	/\%>199l\%<300llimit
|/\%>l|も参照。

他にも、":substitute" コマンドに 'c' フラグをつける方法で、擬似的な範囲内検索
ができます。例: >
   :.,300s/Pattern//gc
この例では、カーソル位置から 300 行目までの間で "Pattern" が検索されます。マッ
チした場所で、動作を指示するためのキーを入力必要があります。検索を停止するには
'q' を、次のマッチを検索するには 'n' を入力します。

"*", "#", "g*", "g#" コマンドはカーソルに近い単語を次の順番で検索します。最初
に見つかったものが使われます:
- カーソル位置のキーワード
- 同じ行の、カーソルの右側のキーワード
- カーソル位置の単語
- 同じ行の、カーソルの右側の単語
キーワードは、'iskeyword' で定義されている文字だけを含む文字列です。
単語 (|WORD|) は、空白文字 (<Tab> や <Space>) を含まない文字列です。
Note: 10本の指を使ってタイプしているなら、このコマンドを覚えるのは簡単です:
"#" は左手の中指で押します (左上に向かって検索します)。
"*" は右手の中指で押します (右下に向かって検索します)。
{訳注: これは英語キーボードでの話}

								*E956*
ごくまれに、正規表現が再帰的に使用されます。これは、パターンの実行に時間がかか
り、チャネル上のメッセージをチェックするときに、パターンを使用するコールバック
が呼び出されるか、または自動コマンドがトリガされたときに発生します。ほとんどの
場合、これはうまくいくはずですが、パターンが使用中でそれが再度使用されたときに
それは失敗します。通常これはパターンに何か問題があることを意味します。

==============================================================================
2. パターンの定義			*search-pattern* *pattern* *[pattern]*
					*regular-expression* *regexp* *Pattern*
					*E383* *E476*

初心者の方はユーザーマニュアルの27章 |usr_27.txt| を読んでください。

						*/bar* */\bar* */pattern*
1. パターンは、"\|" で分けられた 1 つ以上のブランチからなります。ブランチがど
   れか 1 つでもマッチすればマッチします。例えば、"foo\|beep" は "foo" と
   "beep" にマッチします。複数のブランチがマッチした場合は、最初にマッチしたも
   のが使われます。

   pattern ::=	    branch
		or  branch \| branch
		or  branch \| branch \| branch
		etc.

						*/branch* */\&*
2. ブランチは、"\&" で分けられた1つ以上の連接からなります。全ての連接が同じ
   場所でマッチした場合に限り、最後の連接がマッチします。例:
	"foobeep\&..." は "foobeep" の "foo" にマッチします。
	".*Peter\&.*Bob" は "Peter" と "Bob" が両方ある行でマッチします。

   branch ::=	    concat
		or  concat \& concat
		or  concat \& concat \& concat
		etc.

						*/concat*
3. 連接は、連続した 1 つ以上のピースからなります。ピースがすべて、順番どおり
   マッチした場合にマッチします。例えば、"f[0-9]b" は最初に "f" にマッチし、次
   に 1 桁の数字、そして "b" にマッチします。

   concat  ::=	    piece
		or  piece piece
		or  piece piece piece
		etc.

						*/piece*
4. ピースはアトムです。アトムが何回マッチするかを指示する、量指定子を後ろに置
   くことができます。例えば "a*" はいくつの "a" でもマッチします。
   ""、"a"、"aa" など。|/multi|を参照。

   piece   ::=	    atom
		or  atom  multi

						*/atom*
5. アトムはパターンアイテムを構成する要素です。ほとんどのアトムは 1 文字にマッ
   チします。多くの場合、アトムは普通の文字か文字クラスです。カッコを使ってパ
   ターンからアトムを作れます。"\z(\)" は構文強調専用です。

   atom    ::=	    ordinary-atom		|/ordinary-atom|
		or  \( pattern \)		|/\(|
		or  \%( pattern \)		|/\%(|
		or  \z( pattern \)		|/\z(|


				*/\%#=* *two-engines* *NFA*
Vim は二つの正規表現エンジンを持っています:
1. 古い、バックトラッキングエンジン。すべての機能をサポート。
2. 新しい、NFA エンジン。いくつかのパターンで動作が速いがいくつかのパターンで
   は遅くなる。
								 *E1281*
Vim は自動的に適切なエンジンを選択します。何か問題が発生したか、あるいは明示的
にエンジンを選択したいか、あるいはその他の理由で、エンジンを指定したい場合はパ
ターンの先頭で次のように指定します:

	\%#=0	強制的に自動選択にする。'regexpengine' が 0 以外のときだけ意味
	        がある。
	\%#=1	強制的に古いエンジンを使う。
	\%#=2	強制的に NFA エンジンを使う。

'regexpengine' オプションでもデフォルトのエンジンを選択できます。

			 *E864* *E868* *E874* *E875* *E876* *E877* *E878*
NFA エンジンが選択され、未実装の機能が使用され、パターンがマッチしなかった場合
に発生します。Vim のデバッグ用です。

==============================================================================
3. Magic							*/magic*

パターンの中でリテラル、つまり文字列として扱われる文字は、テキストの同じ文字と
マッチします。しかし、バックスラッシュが前置されると、特別な意味を持つことがあ
ります。

バックスラッシュを前置しなくても特別な意味を持つ文字があります。そのような文字
をリテラル文字としてマッチさせるには、バックスラッシュを前置する必要がありま
す。例えば "." は任意の文字にマッチし "\." はドットにマッチします。

ある文字がリテラルとして処理されるかどうかは、オプション 'magic' と、以下で説
明するパターンに含まれるアイテムに依存します。オプション 'magic' は常に設定す
るべきですが、Vi 互換のためにオフにすることができます。ここでは網羅性のために
'nomagic' の効果を説明しますが、使用については推奨しません。
							*/\m* */\M*
"\m" を使うと、それ以降のパターンは 'magic' がオンの状態で処理されます。
オプション 'magic' の設定よりも優先されます。
"\M" を使うと、それ以降のパターンは 'nomagic' の状態で処理されます。
							*/\v* */\V*
"\v" を使うと、それ以降の、'0'-'9'、'a'-'z'、'A'-'Z'、'_'、以外のすべての
ASCII文字は特別な意味を持ちます: "very magic"

"\V" を使うと、それ以降はバックスラッシュと終端文字 (通常は / や ?) だけが特別
な意味を持ちます: "very nomagic"

例:
after:	  \v	   \m	    \M	     \V		マッチするもの ~
		'magic' 'nomagic'
	  a	   a	    a	     a		リテラルの 'a'
	  \a	   \a	    \a	     \a		何かの英字 1 文字
	  .	   .	    \.	     \.		何か 1 文字
	  \.	   \.	    .	     .		リテラルのドット
	  $	   $	    $	     \$		行末
	  *	   *	    \*	     \*		直前のアトムの繰り返し
	  ~	   ~	    \~	     \~		直近の置換文字列
	  ()	   \(\)     \(\)     \(\)	アトムとしてグループ化
	  |	   \|	    \|	     \|		マッチ無し: 選択の区切り
	  \\	   \\	    \\	     \\		リテラルのバックスラッシュ
	  \{	   {	    {	     {		リテラルの波カッコ

{\m、\M、\v、\V、はVimだけの機能です}

パターンが 'magic' の設定に影響されないよう望むなら、パターンの先頭に "\m" か
"\M" を置きます。


==============================================================================
4. パターンの概要					*pattern-overview*
						*E865* *E866* *E867* *E869*

量指定子の概要。					*/multi* *E61* *E62*
詳しい説明や使用例は、リンク先を参照してください。		*E64* *E871*

	  量指定子 ~
     'magic' 'nomagic'	アトムがいくつマッチするか ~
|/star|	*	\*	0 以上		最長一致
|/\+|	\+	\+	1 以上		最長一致
|/\=|	\=	\=	0 か 1		最長一致
|/\?|	\?	\?	0 か 1		最長一致

|/\{|	\{n,m}	\{n,m}	n 以上 m 以下	最長一致
	\{n}	\{n}	n		正確に指定した数だけ
	\{n,}	\{n,}	n 以上		最長一致
	\{,m}	\{,m}	0 以上 m 以下	最長一致
	\{}	\{}	0 以上		最長一致 (*と同じ)

|/\{-|	\{-n,m}	\{-n,m}	n 以上 m 以下	最短一致
	\{-n}	\{-n}	n		正確に指定した数だけ
	\{-n,}	\{-n,}	n 以上		最短一致
	\{-,m}	\{-,m}	0 以上 m 以下	最短一致
	\{-}	\{-}	0 以上		最短一致

							*E59*
|/\@>|	\@>	\@>	1	強欲な量指定子
|/\@=|	\@=	\@=	なし	幅ゼロの肯定先読み |/zero-width|
|/\@!|	\@!	\@!	なし	幅ゼロの否定先読み |/zero-width|
|/\@<=|	\@<=	\@<=	なし	幅ゼロの肯定後読み |/zero-width|
|/\@<!|	\@<!	\@<!	なし	幅ゼロの否定後読み |/zero-width|


普通のアトムの概要					*/ordinary-atom*
詳しい説明や使用例は、リンク先を参照してください。

      アトム ~
      magic   nomagic	マッチするもの ~
|/^|	^	^	行頭 (パターンの先頭にある場合だけ) |/zero-width|
|/\^|	\^	\^	リテラル文字 '^'
|/\_^|	\_^	\_^	行頭 (どこでも使える) |/zero-width|
|/$|	$	$	行末 (パターンの末尾にある場合だけ) |/zero-width|
|/\$|	\$	\$	リテラル文字 '$'
|/\_$|	\_$	\_$	行末 (どこでも使える) |/zero-width|
|/.|	.	\.	何か 1 文字 (改行以外)
|/\_.|	\_.	\_.	何か 1 文字 (改行含む)
|/\<|	\<	\<	単語の先頭 |/zero-width|
|/\>|	\>	\>	単語の末尾 |/zero-width|
|/\zs|	\zs	\zs	なし。マッチの開始地点を設定します
|/\ze|	\ze	\ze	なし。マッチの終了地点を設定します
|/\%^|	\%^	\%^	ファイルの先頭 |/zero-width|		*E71*
|/\%$|	\%$	\%$	ファイルの末尾 |/zero-width|
|/\%V|	\%V	\%V	選択範囲内 |/zero-width|
|/\%#|	\%#	\%#	カーソル位置 |/zero-width|
|/\%'m|	\%'m	\%'m	マーク m の位置 |/zero-width|
|/\%l|	\%23l	\%23l	23行目 |/zero-width|
|/\%c|	\%23c	\%23c	23列目 |/zero-width|
|/\%v|	\%23v	\%23v	23列目 (表示単位) |/zero-width|

文字クラス:						*/character-classes*
      magic   nomagic	マッチするもの ~
|/\i|	\i	\i	識別子文字 (オプション 'isident' を参照)
|/\I|	\I	\I	"\i" と同じですが、数字は除外します
|/\k|	\k	\k	キーワード文字 (オプション 'iskeyword' を参照)
|/\K|	\K	\K	"\k" と同じですが、数字は除外します
|/\f|	\f	\f	ファイル名の文字 (オプション 'isfname' を参照)
|/\F|	\F	\F	"\f" と同じですが、数字は除外します
|/\p|	\p	\p	印字可能文字 (オプション 'isprint' を参照)
|/\P|	\P	\P	"\p" と同じですが、数字は除外します
|/\s|	\s	\s	空白文字: <Space> と <Tab>
|/\S|	\S	\S	空白文字以外。\s の反対です
|/\d|	\d	\d	数字				[0-9]
|/\D|	\D	\D	数字以外			[^0-9]
|/\x|	\x	\x	16 進数字			[0-9A-Fa-f]
|/\X|	\X	\X	16 進数字以外			[^0-9A-Fa-f]
|/\o|	\o	\o	8 進数字			[0-7]
|/\O|	\O	\O	8 進数字以外			[^0-7]
|/\w|	\w	\w	単語を構成する文字		[0-9A-Za-z_]
|/\W|	\W	\W	単語を構成する文字以外		[^0-9A-Za-z_]
|/\h|	\h	\h	単語の先頭の文字		[A-Za-z_]
|/\H|	\H	\H	単語の先頭の文字以外		[^A-Za-z_]
|/\a|	\a	\a	英字				[A-Za-z]
|/\A|	\A	\A	英字以外			[^A-Za-z]
|/\l|	\l	\l	小文字英字			[a-z]
|/\L|	\L	\L	小文字英字以外			[^a-z]
|/\u|	\u	\u	大文字英字			[A-Z]
|/\U|	\U	\U	大文字英字以外			[^A-Z]
|/\_|	\_x	\_x	x は上記の文字クラスのどれかです。文字クラスと改行が
			マッチします。
(文字クラスここまで)

      magic   nomagic	マッチするもの ~
|/\e|	\e	\e	<Esc>
|/\t|	\t	\t	<Tab>
|/\r|	\r	\r	<CR>
|/\b|	\b	\b	<BS>
|/\n|	\n	\n	改行
|/~|	~	\~	最後に置換された文字列
|/\1|	\1	\1	最初の \(\) と同じ文字列
|/\2|	\2	\2	"\1" と同じですが、2 番目の \(\) を使います
	   ...
|/\9|	\9	\9	"\1" と同じですが、9 番目の \(\) を使います
								*E68*
|/\z1|	\z1	\z1	構文強調専用。|:syn-ext-match|を参照
	   ...
|/\z1|	\z9	\z9	構文強調専用。|:syn-ext-match|を参照

	x	x	特別な意味のない文字は、その文字自身とマッチします

|/[]|	[]	\[]	[] で囲んだ文字のうちどれか
|/\%[]|	\%[]	\%[]	任意にマッチするアトム列

|/\c|	\c	\c	大文字小文字を無視します。'ignorecase' は使用されない
|/\C|	\C	\C	大文字小文字を区別します。'ignorecase' は使用されない
|/\Z|	\Z	\Z	Unicodeの合成文字かどうかを無視します。
			ヘブライ語やアラビア語で母音を検索するときに便利です。

      magic   nomagic	マッチするもの ~
|/\m|	\m	\m	以降のパターン文字を 'magic' がオンの状態で処理します
|/\M|	\M	\M	以降のパターン文字を 'magic' がオフの状態で処理します
|/\v|	\v	\v	以降のパターン文字を "very magic" で処理します
|/\V|	\V	\V	以降のパターン文字を "very nomagic" で処理します
|/\%#=|   \%#=1   \%#=1   正規表現エンジンを選択する |/zero-width|

|/\%d|	\%d	\%d	10進数指定の特定の文字 (例 \%d123)
|/\%x|	\%x	\%x	16進数指定の特定の文字 (例 \%x2a)
|/\%o|	\%o	\%o	8進数指定の特定の文字  (例 \%o040)
|/\%u|	\%u	\%u	特定のマルチバイト文字 (例 \%u20ac)
|/\%U|	\%U	\%U	特定の広範囲のマルチバイト文字 (例 \%U12345678)
|/\%C|	\%C	\%C	すべての合成文字

例			マッチするもの ~
\<\I\i*		or
\<\h\w*
\<[a-zA-Z_][a-zA-Z0-9_]*
			識別子 (例えば C 言語の識別子)

\(\.$\|\. \)		<EOL> かスペースの直前のピリオド

[.!?][])"']*\($\|[ ]\)	文末。")" コマンドが認識する文末と同じ定義です。

cat\Z			"cat" と "càt" ("a" + 0x0300) にマッチする。
			見た目は似ていますが、"càt" (0x00e0)にはマッチしませ
			ん。


==============================================================================
5. 量指定子 (Multi items)				*pattern-multi-items*

アトムがどのように、何回マッチするかを指示するものを、量指定子 (multi) と呼び
ます。概要は |/multi| を参照してください。

							*/star* */\star*
*	('magic' がオフのときは \* )
	アトムの 0 回以上の繰り返し。最長一致。
	Example  'nomagic'	マッチするもの ~
	a*	   a\*		""、"a"、"aa"、"aaa"、など。
	.*	   \.\*		改行以外の全て (空文字列も)
	\_.*	   \_.\*	バッファの末尾までの全て
	\_.*END	   \_.\*END	一番最後の "END" までの全て

	例外: パターンの最初と "^" の直後の "*" は、リテラルの "*" にマッチし
	ます。

	"\_." の繰り返しには注意してください。たくさんのテキストがマッチして、
	そして、時間が掛かります。例えば、"\_.*END" は、カーソルの位置から 1
	番最後の "END" までのすべてのテキストがマッチします。"*" は最長一致な
	ので、まずファイルの末尾までスキップして、それから 1 文字ずつ後退しな
	がら "END" を探します。

							*/\+*
\+	アトムの 1 回以上の繰り返し。最長一致。
	Example		マッチするもの ~
	^.\+$		空行以外の行
	\s\+		1 文字以上の空白

							*/\=*
\=	0 回または 1 回のアトム。最長一致。
	Example		マッチするもの ~
	foo\=		"fo" と "foo"

							*/\?*
\?	\= と同じ。"?" コマンドによる後方検索では使えません。

					*/\{* *E60* *E554* *E870*
\{n,m}	アトムの n 以上 m 以下の繰り返し。最長一致
\{n}	アトムの n 回         の繰り返し
\{n,}	アトムの n 回以上     の繰り返し。最長一致
\{,m}	アトムの 0 以上 m 以下の繰り返し。最長一致
\{}	アトムの 0 回以上     の繰り返し。最長一致 (*と同じ)
							*/\{-*
\{-n,m}	アトムの n 以上 m 以下の繰り返し。最短一致
\{-n}	アトムの n 回         の繰り返し
\{-n,}	アトムの n 回以上     の繰り返し。最短一致
\{-,m}	アトムの 0 以上 m 以下の繰り返し。最短一致
\{-}	アトムの 0 回以上     の繰り返し。最短一致

	n と m には 10 進数正数、またはゼロを指定できます。

								*non-greedy*
	"{" の直後に "-" がある場合は、最短一致のアルゴリズムが使われます (下
	記の例を参照)。特に、"\{-}" は "*" と同じですが、最短一致のアルゴリズ
	ムが使われます。しかし、早い位置でマッチするものが、短いマッチよりも優
	先されます。例えば、"a\{-}b" は "xaaab" の "aaab" にマッチします。

	Example			マッチするもの ~
	ab\{2,3}c		"abbc" または "abbbc"
	a\{5}			"aaaaa"
	ab\{2,}c		"abbc", "abbbc", "abbbbc", etc.
	ab\{,3}c		"ac", "abc", "abbc" or "abbbc"
	a[bc]\{3}d		"abbbd"、"abbcd"、"acbcd"、"acccd"、など
	a\(bc\)\{1,2}d		"abcd" または "abcbcd"
	a[bc]\{-}[cd]		"abcd" の "abc"
	a[bc]*[cd]		"abcd" の "abcd"

	} にバックスラッシュを前置するかどうかは任意です: \{n,m\}

							*/\@=*
\@=	幅ゼロの肯定先読み。先行するアトムに幅ゼロでマッチします。
	Perl の "(?=pattern)" と似ています。
	Example			マッチするもの ~
	foo\(bar\)\@=		"foobar" の "foo"
	foo\(bar\)\@=foo	何もマッチしない
							*/zero-width*
	"\@=" (や、"^"、"$"、"\<"、"\>"、など) を使った場合、その文字はマッチ
	に含まれません。これらのアイテムは、マッチすることができるかどうかの
	チェックだけに使われます。続くアイテムが同じ場所でマッチすることに注意
	してください。上記の最後の例は "foobarfoo" にはマッチしません。"bar"
	がマッチしたのと同じ場所で "foo" とマッチしようとするからです。

	Note: "\&" は "\@=" と同じような働きをします。"foo\&.." と
	"\(foo\)\@=.." は同じです。カッコを書かなくていいので "\&" の方が簡単
	です。


							*/\@!*
\@!	幅ゼロの否定先読み。先行するアトムが現在の位置でマッチしない場合に、幅
	ゼロでマッチします。|/zero-width|
	Perl の "(?!pattern)" と似ています。
	Example			マッチするもの ~
	foo\(bar\)\@!		後ろに "bar" のない "foo"
	a.\{-}p\@!		後ろに "p" のない "a"、"ap"、"app"、"appp" など
	if \(\(then\)\@!.\)*$	後ろに "then" のない "if "

	"\@!" を使うには注意が必要です。パターンにマッチしない場所、というのは
	そこらじゅうにあるからです。"a.*p\@!" は "a" から行末までマッチしま
	す。なぜなら、".*" が全ての文字にマッチし、"p" は行末にマッチしないか
	らです。"a.\{-}p\@!" は後ろに "p" のない文字列、"a"、"ap"、"app"、など
	にマッチします。なぜなら、"." が "p" にもマッチし、"p\@!" がその後ろに
	マッチする(つまり "p" がマッチしない) からです。

	直前がマッチしないことを調べるために "\@!" を使うことはできません。
	"\(foo\)\@!bar" は "foobar" の "bar" にマッチします。なぜなら、"foo"
	がマッチしなかった場所で、"bar" がマッチするからです。"foobar" がマッ
	チしないように、"\(foo\)\@!...bar" とすることもできますが、これは行頭
	の "bar" にはマッチしません。"\(foo\)\@<!bar" を使ってください。

	実用的な例: "bar" を含んでいない行から "foo" を探す: >
		/^\%(.*bar\)\@!.*\zsfoo
<	このパターンはまず、行の中で "bar" がマッチしないことを確認します。も
	しどこかで ".*bar" がマッチすると \@! によってこのパターンは否決されま
	す。それがマッチせず、そしてどこかで "foo" が見つかると、"\zs" によっ
	て "foo" の直前でマッチが開始したことにされます。

							*/\@<=*
\@<=	幅ゼロの肯定後読み。先行するアトムが、この後に続くパターンの直前にマッ
	チする場合に、幅ゼロでマッチします。|/zero-width|
	Perl の "(?<=pattern)" と似ていますが、Vimでは可変長パターンも使えます。
	Example			マッチするもの ~
	\(an\_s\+\)\@<=file	"an" と空白文字 (改行含む) の後の "file"

	処理速度を気にするなら、この量指定子は避けたほうが無難です。代わりに
	"\zs" を使ってください |/\zs|。次のものは上記の例と同じものにマッチし
	ます:
		an\_s\+\zsfile
	あるいは少なくとも探索範囲を制限した方がいいでしょう。下記参照。

	"\@<=" と "\@<!" は直前の文字がマッチしているかどうかをチェックしま
	す。理論上は、マッチの現在位置よりも前ならどこでもマッチできます。しか
	し、処理時間を制限するために、マッチの現在行と、(もしあれば) 1 つ前の
	行だけが検索されます。ほとんどの場合はこれで十分ですし、遅くなり過ぎる
	こともありません。

	古い正規表現エンジンでは "\@<=" や "\@<!" の後にくるパターンは最初に
	チェックされます。そのため、先行するアトムの内側にある \(\) に対する
	"\1" のような参照は機能しません。順番を逆にした場合は機能します:
	悪い例				マッチするもの ~
	\%#=1\1\@<=,\([a-z]\+\)		"abc,abc" の中の ",abc"

	新しい正規表現エンジンでは動作が異なるので、この動作の違いに依存しない
	ようにするのが無難です。可能なら \@<= の使用を避けてください:
	例				マッチするもの ~
	\([a-z]\+\)\zs,\1		"abc,abc" の中の ",abc"

\@123<=
	"\@<=" と同じですが 123 バイトまでしか探索しません。失敗すると分かって
	いて、その探索のせいで遅くなる状況を回避できます。例えば、"span" の前
	に "<" があるかどうかをチェックする場合:
		/<\@1<=span
	このパターンは "span" の前の 1 バイトだけを見て "<" を探します。この例
	ではなんにしても 1 バイト前だけが唯一マッチする場所です。
	行をまたいだ場合、探索範囲はその行末からの相対位置になります。つまり、
	探索開始位置の行の文字はカウントされません (ものごとをシンプルに保つた
	め)。
	数値のゼロは制限なしと同じです。

							*/\@<!*
\@<!	幅ゼロの否定後読み。先行するアトムが、この後に続くパターンの直前にマッ
	チしない場合に、幅ゼロでマッチします。現在行と 1 つ前の行だけがチェッ
	クされます。|/zero-width|
	Perl の "(?<!pattern)" と似ていますが、Vimでは可変長パターンも使えます。
	対象のアトムは、続くアトムの直前までがマッチの範囲になるため、最後が
	".*" で終わっているアトムも機能します。
	警告: これは遅くなることがあります (マッチするかどうかを多くの場所で
	チェックする必要があるため)。可能であれば探索範囲に制限をかけてくださ
	い。下記参照。
	Example			マッチするもの ~
	\(foo\)\@<!bar		"foobar" 以外の "bar"
	\(\/\/.*\)\@<!in	"//" の後ろ以外の "in"

\@123<!
	"\@<!" と同じですが 123 バイトまでしか探索しません。失敗すると分かって
	いて、その探索のせいで遅くなる状況を回避できます。

							*/\@>*
\@>	強欲な量指定子。
	Perlの "(?>pattern)" と似ています。
	Example		マッチするもの ~
	\(a*\)\@>a	何もマッチしない ("a*" が全ての "a" を取るので、その後
			に "a" があることはありません)

	パターンがそのアトムだけであるかのようにマッチします。そして、パターン
	全体がマッチしなくても、そのアトムのマッチを短くして再トライしたりはし
	ません (バックトラックしません)。次の違いに注意してください。"a*b" と
	"a*ab" は両方とも "aaab" にマッチします。このとき、後者の "a*" は先頭
	の "aa" にマッチしています。"\(a*\)\@>ab" は "aaab" にマッチしません。
	なぜなら、"a*" が "aaa" にマッチする (最長一致する) ため、"ab" がマッ
	チできないからです。


==============================================================================
6.  普通のアトム					*pattern-atoms*

普通のアトムは次のものです:

							*/^*
^	パターンの先頭にある場合、行頭にマッチします。"\|"、"\("、"\%(" の直後
	でも構いません。他の場所にある場合は、リテラル文字の '^' にマッチしま
	す。|/zero-width|
	Example		マッチするもの ~
	^beep(		(おそらく) C 言語の関数 "beep" の開始。

							*/\^*
\^	リテラル文字の '^' にマッチします。[] の中以外のパターンのどの場所でも
	使えます。

							*/\_^*
\_^	行頭にマッチします。|/zero-width| [] の中以外のパターンのどの場所でも
	使えます。
	Example		マッチするもの ~
	\_s*\_^foo	空白文字や空行の直後の、行頭の "foo"

							*/$*
$	パターンの末尾、または "\|"、"\)"、"\n" ('magic' on時) の前にある場
	合、行末 (<EOL>) にマッチします。他の場所にある場合は、リテラル文字の
	'$' にマッチします。|/zero-width|

							*/\$*
\$	リテラル文字の '$' にマッチします。[] の中以外のパターンのどの場所でも
	使えます。

							*/\_$*
\_$	行末にマッチします。|/zero-width| [] の中以外のパターンのどの場所でも
	使えます。Note: "a\_$b" はどこにもマッチしません。"b" は行末とはマッチ
	しないからです。代わりに、"a\nb" を使ってください |/\n|。
	Example		マッチするもの ~
	foo\_$\_s*	行末の "foo" と、それに続く空白や空行

.	('nomagic' なら \.)				*/.* */\.*
	改行以外のすべての文字がマッチします。

							*/\_.*
\_.	改行も含め、すべての文字がマッチします。
	注意: "\_.*" はバッファの末尾までのすべてのテキストがマッチします。

							*/\<*
\<	単語の先頭にマッチします。このアトムの次の文字は単語の 1 文字目です。
	どの文字が単語を構成するかは、オプション 'iskeyword' で設定します。
	|/zero-width|

							*/\>*
\>	単語の末尾にマッチします。このアトムの前の文字は単語の最後の文字です。
	どの文字が単語を構成するかは、オプション 'iskeyword' で設定します。
	|/zero-width|

							*/\zs*
\zs	[] の中以外のパターンのどの場所でもマッチして、マッチの開始地点を設定
	します。このアトムの次の文字は、マッチした文字列の 1 文字目です。
	|/zero-width|
	例: >
		/^\s*\zsif
<	これは、行頭からスペースを無視して、"if" にマッチします。
	複数回の繰り返しで使った場合は、最後にマッチしたものが使われます。
	例: >
		/\(.\{-}\zsFab\)\{3}
<	これは、3 番目に現れた "Fab" にマッチします。
	後ろに量指定子を置くことはできない。 *E888*
	{|+syntax|が有効な場合のみ利用できます}
							*/\ze*
\ze	[] の中以外のパターンのどの場所でもマッチして、マッチの終了地点を設定
	します。このアトムの前の文字は、マッチした文字列の最後の文字で
	す。|/zero-width|
	複数回の繰り返しで使った場合は、最後にマッチしたものが使われます。
	例: >
		/end\ze\(if\|for\)
<	これは、"endif" または "endfor" の "end" にマッチします。
	後ろに量指定子を置くことはできない。 |E888|
	{|+syntax|が有効な場合のみ利用できます}

						*/\%^* *start-of-file*
\%^	ファイルの先頭にマッチします。文字列 (|expr-string|) とマッチングする
	場合は、文字列の先頭にマッチします。
	例: >
		/\%^\_.\{-}\zsVIM
<	これは、ファイルの最初にある "VIM" にマッチします。

						*/\%$* *end-of-file*
\%$	ファイルの末尾にマッチします。文字列 (|expr-string|) とマッチングする
	場合は、文字列の末尾にマッチします。
	Note: 次のパターンでは、ファイルの最後の "VIM" を検索できません: >
		/VIM\_.\{-}\%$
<	これは、カーソル位置から次の "VIM" を検索します。"VIM" の後の
	"\_.\{-}\%$" が常にマッチするからです。ファイルの最後の "VIM" を検索す
	るには、次のようにします: >
		/VIM\ze\(\(VIM\)\@!\_.\)*\%$
<	"VIM" の後に "VIM" がないことを確実にするために|/\@!|を使っています。
	ファイルの末尾から後方検索する方が簡単です。

						*/\%V*
\%V	選択範囲内にマッチします。ビジュアルモードでないときは、|gv| で再選択
	できる範囲にマッチします。
	これはゼロ幅マッチ |/zero-width| です。パターンを選択範囲内でマッチさ
	せたい場合は、パターンの最初と最後の直前にこれを指定してください。例: >
		/\%Vfoo.*ba\%Vr
<	これは "foo bar" のみがビジュアル選択されている場合でも機能します。以
	下は、 >
		/\%Vfoo.*bar\%V
<	ビジュアル選択が "r" より後も含む場合に "foo bar" にマッチします。
	カレントバッファでのみ機能します。

						*/\%#* *cursor-position*
\%#	カーソルの位置にマッチします。ウィンドウに表示されているバッファ内で
	マッチングする場合のみ機能します。
	警告: パターンが使われた後で、カーソルを移動した場合、マッチの結果は正
	確ではなくなってしまいます。マッチの結果は自動的に更新されません。これ
	は特に、構文強調と 'hlsearch' に関係します。
	カーソルが移動しても、表示は自動的に更新されません。表示が更新されるの
	は、行を変更したため行全体が更新されたときや、|CTRL-L| コマンドを使っ
	てスクリーン全体を更新したときです。カーソル位置の単語を強調表示するに
	は次のようにします: >
		/\k*\%#\k*
<	'hlsearch' をオンにして、カーソルを移動し、テキストを変更してみて、表
	示が更新されるかどうか確認してください。

						*/\%'m* */\%<'m* */\%>'m*
\%'m	マーク m の位置にマッチします。
\%<'m	マーク m より前の位置にマッチします。
\%>'m	マーク m より後ろの位置にマッチします。
	例えば、マーク 's から 'e までを強調するには次のようにします: >
		/.\%>'s.*\%<'e..
<	Note: マーク 'e の位置をマッチに含めるには 'e の後ろに 2 つのドットが
	必要です。なぜなら、"\%<'e" はマーク 'e の前の文字にマッチし、そしてそ
	れはゼロ幅マッチ|/zero-width| なので、その文字は結果に含まれないからで
	す。
	警告: マークを検索した後にマークを移動した場合、その結果は正しくなくな
	ります。Vim は自動的にマッチの強調表示を更新したりしません。
	|/\%#| で検索した後にカーソルを動かした場合と似ています。

				*/\%l* */\%>l* */\%<l* *E951* *E1204* *E1273*
\%23l	指定した行にマッチします。
\%<23l	指定した行より上にマッチします。
\%>23l	指定した行より下にマッチします。
\%.l	カーソル行にマッチします。
\%<.l	カーソル行より上にマッチします。
\%>.l	カーソル行より下にマッチします。
	この 6 つを使って、バッファの特定の行にマッチできます。"23" の所には任
	意の行番号が指定可能です。先頭の番号は 1 です。
	警告: 行を挿入したり削除したりしても、マッチの結果は自動的に更新されま
	せん。そのため、このアトムを使った構文強調は、すぐに誤った表示になって
	しまいます。また、カーソル位置 (".") を参照しているとき、カーソルが移
	動しても変化に合わせて表示が更新されることはありません。更新されるのは
	コマンド |CTRL-L| を使ったときです (画面全体が更新されます)。
	現在行を強調表示するには次のようにします: >
		:exe '/\%' .. line(".") .. 'l'
<	あるいは次を使います: >
		/\%.l
<	'hlsearch' をオンにして、カーソルを移動し、テキストを変更してみて、表
	示が更新されるかどうか確認してください。

						*/\%c* */\%>c* */\%<c*
\%23c	指定した列にマッチします。
\%<23c	指定した列より前にマッチします。
\%>23c	指定した列より後ろにマッチします。
\%.c	カーソル列にマッチします。
\%<.c	カーソル列より前にマッチします。
\%>.c	カーソル列より後ろにマッチします。
	この 6 つを使って、バッファの特定の列にマッチできます。"23" の所には任
	意の列番号が指定可能です。先頭の番号は 1 です。実際には、何バイト目か
	を指定するので、マルチバイト文字を扱うときには、"列番号" という表現は
	正確ではありません。
	警告: 行を挿入したり削除したりしても、マッチの結果は自動的に更新されま
	せん。そのため、このアトムを使った構文強調は、すぐに誤った表示になって
	しまいます。また、カーソル位置 (".") を参照しているとき、カーソルが移
	動しても変化に合わせて表示が更新されることはありません。更新されるのは
	コマンド |CTRL-L| を使ったときです (画面全体が更新されます)。
	カーソル位置の列を強調表示するには次のようにします: >
		:exe '/\%' .. col(".") .. 'c'
<	あるいは次を使います: >
		/\%.c
<	'hlsearch' をオンにして、カーソルを移動し、テキストを変更してみて、表
	示が更新されるかどうか確認してください。
	44 バイト目を強調表示するには次のようにします: >
		/\%>43c.\%<46c
<	Note: "." が 44 バイト目にマッチした場合、"%<46c" は 45 列目にマッチし
	ます。
						*/\%v* */\%>v* */\%<v*
\%23v	指定した表示列にマッチします。
\%<23v	指定した表示列より前にマッチします。
\%>23v	指定した表示列より後ろにマッチします。
\%.v	現在の表示列にマッチします。
\%<.v	現在の表示列より前にマッチします。
\%>.v	現在の表示列より後ろにマッチします。
	この 6 つを使って、バッファの特定の表示列にマッチできます。文字列
	(|expr-string|) とマッチングするときは、カレントウィンドウの、
	'tabstop' などの設定が使われます。
	"23" の所には任意の表示列番号が指定可能です。先頭の番号は 1 です。
	Note: Tab 文字や全角文字などの、複数列で表示される文字の途中の列を指定
	した場合は、マッチしません。
	警告: 行を挿入したり削除したりしても、マッチの強調表示は自動的に更新さ
	れません。そのため、このアトムを使った構文強調は、すぐに誤った表示に
	なってしまいます。また、カーソル位置 (".") を参照しているとき、カーソ
	ルが移動しても変化に合わせて表示が更新されることはありません。更新され
	るのはコマンド |CTRL-L| を使ったときです (画面全体が更新されます)。
	表示列の72桁目以降のすべての文字を強調表示するには次のようにします: >
		/\%>72v.*
<	'hlsearch' をオンにして、カーソルを移動し、テキストを変更してみて、表
	示が更新されるかどうか確認してください。
	17 列までのテキストにマッチさせるには次のようにします: >
		/^.*\%17v
<	現在の表示列 (カーソルがある場所) より後ろの全ての文字にマッチさせるに
	は: >
		/\%>.v.*
<	17 列目は含まれません。なぜならこれはゼロ幅マッチ (|/zero-width|) であ
	る為です。列を含むには次を使用します: >
		/^.*\%17v.
<	次のコマンドも同様の動作ですが、17 列目に文字が存在しなくてもマッチし
	ます: >
		/^.*\%<18v.
<	Note: これは "^" 無しでも最初のカラムに居たままマッチします。17 列目も
	ハイライトされます: >
		/.*\%17v
<	".*" がゼロ幅文字として別の文字にマッチする為 17 列目は 'hlsearch' に
	よりハイライトされます。


文字クラス:
\i	識別子文字 ('isident' 参照)			*/\i*
\I	"\i" と同じですが、数字は除外します		*/\I*
\k	キーワード文字 ('iskeyword' 参照)		*/\k*
\K	"\k" と同じですが、数字は除外します		*/\K*
\f	ファイル名の文字 ('isfname' 参照)		*/\f*
\F	"\f" と同じですが、数字は除外します		*/\F*
\p	印字可能文字 ('isprint' 参照)			*/\p*
\P	"\p" と同じですが、数字は除外します		*/\P*

NOTE: 上記のものはマルチバイト文字に対しても機能します。次のものは、示された範
囲の ASCII 文字だけがマッチします。

						*whitespace* *white-space*
\s	空白文字: <Space> と <Tab>			*/\s*
\S	空白文字以外。\s の反対です			*/\S*
\d	数字:				[0-9]		*/\d*
\D	数字以外:			[^0-9]		*/\D*
\x	16 進数字:			[0-9A-Fa-f]	*/\x*
\X	16 進数字以外:			[^0-9A-Fa-f]	*/\X*
\o	8 進数字:			[0-7]		*/\o*
\O	8 進数字以外:			[^0-7]		*/\O*
\w	単語を構成する文字:		[0-9A-Za-z_]	*/\w*
\W	単語を構成する文字以外:		[^0-9A-Za-z_]	*/\W*
\h	単語の先頭の文字:		[A-Za-z_]	*/\h*
\H	単語の先頭の文字以外:		[^A-Za-z_]	*/\H*
\a	英字:				[A-Za-z]	*/\a*
\A	英字以外:			[^A-Za-z]	*/\A*
\l	小文字英字:			[a-z]		*/\l*
\L	小文字英字以外:			[^a-z]		*/\L*
\u	大文字英字:			[A-Z]		*/\u*
\U	大文字英字以外:			[^A-Z]		*/\U*

	NOTE: これらのアトムは |/[]| を使うよりも高速です。

	NOTE: 'ignorecase'、"\c"、"\C" は、文字クラスには影響しません。

			*/\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F*
			*/\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X*
			*/\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A*
			*/\_l* */\_L* */\_u* */\_U*
\_x	x は上記の文字クラスのどれかです。文字クラスと改行がマッチします。
(文字クラスここまで)

\e	<Esc> にマッチします				*/\e*
\t	<Tab> にマッチします				*/\t*
\r	<CR> にマッチします				*/\r*
\b	<BS> にマッチします				*/\b*
\n	改行にマッチします				*/\n*
	バッファのテキストではなく、文字列 (|expr-string|) とマッチングすると
	きは、リテラルの改行文字がマッチします。

~	最後に置換された文字列とマッチします		*/~* */\~*

\(\)	パターンをカッコでまとめます			*/\(* */\(\)* */\)*
	例えば、"\(^a\)" は行頭の 'a' にマッチします。
	これらは 9 つしか存在できません。"\%(" を使用してさらに追加できますが、
	部分正規表現としてカウントすることはできません。
	*E51* *E54* *E55* *E872* *E873*

\1      \( と \) に囲まれた最初の部分正規表現が		*/\1* *E65*
	マッチした文字列と同じ文字列にマッチします。
	例えば、"\([a-z]\).\1" は "ata"、"ehe"、"tot"、などにマッチします。
\2      "\1" と同じですが、2 番目の部分正規表現を使います	*/\2*
   ...								*/\3*
\9      "\1" と同じですが、9 番目の部分正規表現を使います	*/\9*
	Note: 部分正規表現の番号は、最初の "\(" から数えて、左から右へ、順番に
	番号が付けられます。マッチする順番ではありません。

\%(\)	パターンをカッコでまとめます			*/\%(\)* */\%(* *E53*
	\(\) と同じですが、部分正規表現としてカウントされません。たくさんのグ
	ループを作ることができますし、処理が少し高速です。

x	特別な意味のない文字は、その文字自身とマッチします

							*/\* */\\*
\x	バックスラッシュと文字の組合せで、現在、特別な意味を持っていない文字
	は、将来の拡張のために予約されています。

[]	('nomagic' のときは \[])	*/[]* */\[]* */\_[]* */collection* *E76*
\_[]
	コレクションです。複数の文字を角カッコで囲みます。コレクションに含まれ
	る任意の 1 文字とマッチします。
	Example		マッチするもの ~
	[xyz]		'x'、'y'、'z' のどれか
	[a-zA-Z]$	行末の英字
	\c[a-z]$	同上
	[А-яЁё]		ロシア語アルファベット (utf-8 と cp1251)

								*/[\n]*
	"\_" を付けた場合、コレクションは改行も含みます。コレクションに "\n"
	を含めた場合と同じですが、"\_" を付けた場合は、コレクションの先頭が
	"^" の場合でも改行にマッチします。つまり、"\_[^ab]" は "a" や "b" 以外
	の文字と改行にマッチします。
	これは Vi 互換です。"\_" や "\n" を使わなければ、改行にはマッチしませ
	ん。

								*E769*
	']' がない場合、Vim はエラーを表示せず、コレクションが使われているので
	はないと判断します。'[' を検索するときに便利です。しかし、Vim 内部での
	検索では E769 のエラーがでます。そして、`:substitute` コマンドでコマン
	ド全体がパターンとなることに注意してください。例えば、":s/[/x/" は
	"[/x" を検索します。置換はおこなわれません。"[" を検索して "x" に置換
	するのではありません！

								*E944* *E945*
	コレクション文字列の先頭が "^" の場合、コレクションに含まれている文字
	以外の文字がマッチします。"[^xyz]" は 'x'、'y'、'z' 以外の文字にマッチ
	します。
	- 2 つの文字で '-' を挟んで、ASCII 文字の範囲を指定できます。例えば、
	  "[0-9]" はすべての数字にマッチします。例えば [c-a] のように最初の文
	  字が後ろの文字よりも大きい場合は E944 が発生します。非ASCII 文字も指
	  定できますが、古い正規表現エンジンでは 2 つの文字の値の差が 256 を超
	  えてはなりません。例えば re=1 をセットした後に [\u3000-\u4000] で検
	  索すると E945 が発生します。先頭に \%#=2 を追加することでこれを回避
	  できます。
	- 文字クラス表現を使って、その文字クラスが含んでいる文字を取り込むこと
	  ができます。次の文字クラスがサポートされています。
		  名前	      関数	含んでいるもの ~
*[:alnum:]*	  [:alnum:]   isalnum	ASCII の英数字
*[:alpha:]*	  [:alpha:]   isalpha	ASCII の英字
*[:blank:]*	  [:blank:]		スペースとタブ
*[:cntrl:]*	  [:cntrl:]   iscntrl	ASCII コントロール文字
*[:digit:]*	  [:digit:]		10 進数字、'0' から '9'
*[:graph:]*	  [:graph:]   isgraph	スペース以外の ASCII 印字可能文字
*[:lower:]*	  [:lower:]   (1)	小文字英字 ('ignorecase' が使用され、
					古いエンジンが使用されている場合はすべ
					ての英字 |two-engines|)
*[:print:]*	  [:print:]   (2)	スペースを含む印字可能文字
*[:punct:]*	  [:punct:]   ispunct	ASCII の句読点
*[:space:]*	  [:space:]		空白文字: スペース、タブ、復帰コード、
					改行コード、垂直タブ、改ページ
*[:upper:]*	  [:upper:]   (3)	大文字英字 ('ignorecase' が使用され、
					古いエンジンが使用されている場合はすべ
					ての英字 |two-engines|)
*[:xdigit:]*	  [:xdigit:]		16 進数字: 0-9, a-f, A-F
*[:return:]*	  [:return:]		<CR> 文字
*[:tab:]*	  [:tab:]		<Tab> 文字
*[:escape:]*	  [:escape:]		<Esc> 文字
*[:backspace:]*	  [:backspace:]		<BS> 文字
*[:ident:]*	  [:ident:]		識別子文字 ("\i" と同じ)
*[:keyword:]*	  [:keyword:]		キーワード文字 ("\k" と同じ)
*[:fname:]*	  [:fname:]		ファイル名の文字 ("\f" と同じ)
	  角カッコで囲んだ文字クラス表現を、コレクションの角カッコ内に書きま
	  す。例えば、"[-./[:alnum:]_~]\+" は、UNIX のファイル名として妥当なパ
	  ターンです。このパターンは、'-'、'.'、'/'、英数字、'_'、'~'、のどの
	  文字の組合せでも、1 文字以上の文字列にマッチします。
	  これらのものは、8 ビット文字のみマッチします。ただし、新しい正規表現
	  エンジンを使用している場合は [:lower:] と [:upper:] のみマルチバイト
	  文字にも作用します。|two-engines| を参照。将来的にはこれらの項目は、
	  マルチバイト文字に作用するようになるでしょう。現状 "alpha" の全てを
	  得るには [[:lower:][:upper:]] を使う事ができます。

	  "関数" 列はどのライブラリ関数が使われるかを示しています。実装はシス
	  テムに依存します。特殊なものは以下の通りです:
	  (1) ASCII には islower()、それ以外には、Vim の組み込みルールが使用さ
	  れます。
	  (2) Vim の組み込みルールが使用されます。
	  (3) (1)と同じですが、代わりに isupper() が使用されます。
							*/[[=* *[==]*
	- 等価クラス。これはその文字とほぼ同じ文字にマッチします。例えば、アク
	  セントを無視するなど。これは Unicode、latin1、latin9 でのみ機能しま
	  す。次のように書きます:
		[=a=]
							*/[[.* *[..]*
	- 照合要素。現在は中に一文字だけ指定できます:
		[.a.]
							  */\]*
	- リテラル文字の ']'、'^'、'-'、'\' をコレクションに含めるには、バック
	  スラッシュを前置して、"[xyz\]]"、"[\^xyz]"、"[xy\-z]"、"[xyz\\]" と
	  書きます。
	  (Note: POSIX ではこのようなバックスラッシュの使い方はサポートされて
	  いません。)
	  ']' は、コレクションの先頭、または '^' の直後にそのまま書いて、
	  "[]xyz]" や "[^]xyz]" とすることができます。
	  '-' も、先頭や末尾にそのまま書いて、"[-xyz]"、"[^-xyz]"、"[xyz-]"、
	  とすることができます。'\' も指定文字 "^]-\bdertnoUux" 以外の文字の前
	  ならそのまま書けます。"[\xyz]" は、'\'、'x'、'y'、'z'、の文字にマッ
	  チします。しかし、常に "\\" と書くようにした方がいいでしょう。'\' と
	  何かの文字の組合せは将来的に拡張に使われる可能性があります。
	- 末尾の ] を省略してもエラーにはなりません。"[]" は "[]]" と同じ意味
	  になり ']' 文字にマッチします。
	- 'cpoptions' が 'l' フラグを含んでいない場合、次のものが特別に解釈さ
	  れます:
		\e	<Esc>
		\t	<Tab>
		\r	<CR>	(改行文字ではありません)
		\b	<BS>
		\n	改行。上記 |/[\n]| 参照。
		\d123	10 進数の文字番号
		\o40	0o377 までの 8 進数の文字番号
		\x20	0xff までの 16 進数の文字番号
		\u20AC	16 進数。0xffff までのマルチバイト文字番号
		\U1234	16 進数。最大 8 文字 0xffffffff のマルチバイト文字番号
			|E1541|
	  NOTE: 他のバックスラッシュによる特殊文字の表記は、[] の中では機能し
	  ません。
	- コレクションを使ったマッチングは遅くなることがあります。コレクション
	  の文字と、テキストの文字を、それぞれ 1 文字ずつ比較する必要があるか
	  らです。同じ意味のアトムが他にある場合は、それを使ってください。例え
	  ば、"\d" は "[0-9]" よりも速く、同じ文字にマッチします。ただし新しい
	  |NFA| 正規表現エンジンにおけるこれらの取り扱いは、古いものよりも高速
	  です。

						*/\%[]* *E69* *E70* *E369*
\%[]	任意にマッチするアトム列です。これは常にマッチします。アトム単位で最長
	一致し、最初にアトムがマッチしなかったところでストップします。例: >
		/r\%[ead]
<	これは、"r"、"re"、"rea"、"read" にマッチします。1 番長いマッチが使わ
	れます。Ex コマンドの "function" は、"fu" が必須で、"nction" は省略可
	能ですが、次の例は、そのようなものにマッチします: >
		/\<fu\%[nction]\>
<	"full" の "fu" にマッチするようなことがないように、単語末尾のアトム
	"\>" が使われています。使う機会はあまりないかもしれませんが、普通の文
	字以外のアトムを使って、さらに複雑なものも表現できます。例: >
		/\<r\%[[eo]ad]\>
<	これは、"r"、"re"、"ro"、"rea"、"roa"、"read"、"road" にマッチします。
	[] の中では \(\)、\%(\)、\z(\) は使えません。\%[] はネストできません。
	"[" を含めるには "[[]" を、"]" を含めるには "[]]" を使ってください。
	例: >
		/index\%[[[]0[]]]
<	これは "index"、"index["、"index[0"、"index[0]" にマッチします。
	{|+syntax| が有効な場合のみ利用可能}

				*/\%d* */\%x* */\%o* */\%u* */\%U* *E678*

\%d123	10進数で指定した文字にマッチします。このアトムの後ろには数字以外の文字
	を置いてください。
\%o40	8進数で指定した文字にマッチします (最大値 0o377)。0o40 より小さい値を
	指定するとき、このアトムの後ろには8進数字以外の文字か、数字以外の文字
	を置いてください。
\%x2a	16進数で指定した文字にマッチします。2桁まで。
\%u20AC	16進数で指定した文字にマッチします。4桁まで。
\%U1234abcd	16進数で指定した文字にマッチします。8桁まで。0x7fffffff まで。
	(許容される最大値は INT_MAX |E1541| ですが、有効な Unicode コードポイ
	ントの最大値は U+10FFFF です)。

==============================================================================
7. 大文字と小文字を無視する					*/ignorecase*

オプション 'ignorecase' がオンの場合、普通の英字の大文字と小文字の違いは無視さ
れます。'smartcase' がオンの場合、パターンが大文字を含んでいないときだけ、大文
字と小文字が無視されます。
							*/\c* */\C*
"\c" はパターン中のどこにでも置くことができ、パターン全体が、'ignorecase' をオ
ンにした状態で処理されます。実際の 'ignorecase' と 'smartcase' の設定は無視さ
れます。"\C" は "\c" の反対の意味で、大文字と小文字は必ず区別されます。
{Vim だけが \c と \C をサポートしています}
Note: 'ignorecase'、"\c"、"\C" は、文字クラスには作用しません。

例:
      パターン	'ignorecase'  'smartcase'	マッチするもの ~
	foo	  off		-		foo
	foo	  on		-		foo Foo FOO
	Foo	  on		off		foo Foo FOO
	Foo	  on		on		    Foo
	\cfoo	  -		-		foo Foo FOO
	foo\C	  -		-		foo

技術的な説明:					*NL-used-for-Nul*
ファイル中の <Nul> 文字は、<NL> 文字としてメモリに保存され、ディスプレイには
"^@" と表示されます。これは、ファイルを読み書きする時に変換されます。検索パ
ターンに <Nul> をマッチさせるには、CTRL-@ か "CTRL-V 000" を入力します。この動
作はそれほど違和感がないはずです。検索パターンの <Nul> 文字は内部で <NL> に変
換されています。CTRL-V CTRL-J をタイプした場合も <NL> が入力されるので、ファイ
ル中の <Nul> を検索するのに使えますが、この動作は不自然に感じるかもしれませ
ん。

						*CR-used-for-NL*
'fileformat' が "mac" の場合、ファイル中の <NL> は内部では <CR> で保存され、テ
キストの中では "^J" として表示されます。他では、<NL> と <Nul> の場合と同じよう
に扱われます。

スクリプトでは、パターン中の <NL> は、文字列中の <NL> とマッチします。"\n"
(バックスラッシュと n) は <NL> とはマッチしません。バッファ中のテキストとの
マッチの場合のみ、"\n" は改行とマッチします。

				*pattern-multi-byte* *pattern-multibyte*
マルチバイト文字を使ったパターンは、たいていは、ユーザーが期待したとおりに機能
します。しかし、不正なバイトでトラブルが起こることもあります。不正なバイトを含
むパターンはおそらく、決してマッチしません。

==============================================================================
8. 合成文字						*patterns-composing*

							*/\Z*
パターンに "\Z" が含まれている場合、すべての合成文字は無視されます。そのため、
どの合成文字が、いくつ結合されていても、基底文字とマッチするだけでマッチしま
す。'encoding' が "utf-8" の場合だけ使用します。例外: パターンが一つか複数の合
成文字で開始している場合は、それらはマッチします。
							*/\%C*
すべての合成文字をスキップするには "\%C" を使います。例えば、パターン "a" は
"càt" (a に 0x0300 が合成されている) にはマッチしませんが、"a\%C" にはマッチし
ます。Note: これは "cát" (á は 0xe1 という文字で、合成文字を持っていない) に
はマッチしません。"cat" (a のみ) にはマッチします。

合成文字がパターンの先頭にあるか、合成文字を含まないアイテムの後に合成文字があ
る場合、その合成文字を含んでいるすべての文字がマッチします。
{訳注: x が合成文字として /x/  /\(x\)/  /\zsx/ など}

ドットと合成文字を使うと、どの文字に合成されていても、その合成文字にマッチしま
す。
{訳注: x が合成文字として /.x/ と書く}

合成文字の順番は関係ありません。また、指定した以上の合成文字がテキストにあって
も、それはマッチします。ただし、パターンで指定したすべての合成文字がテキストに
含まれている必要があります。

例えば B が基底文字で x と y が合成文字として:
	パターン	テキスト	マッチ ~
	Bxy		Bxy		yes (完全マッチ)
	Bxy		Byx		yes (順番違い)
	Bxy		By		no (x がない)
	Bxy		Bx		no (y がない)
	Bx		Bx		yes (完全マッチ)
	Bx		By		no (x がない)
	Bx		Bxy		yes (余計な y は無視される)
	Bx		Byx		yes (余計な y は無視される)

==============================================================================
9. Perl のパターンとの比較				*perl-patterns*

Vim と Perl の正規表現は、とても似ていて、同じ事ができます。違いは表記だけで
す。違いの要約を示します:

効果				Vim の表記	Perl の表記 ~
----------------------------------------------------------------
大文字と小文字を区別しない	\c		(?i)
大文字と小文字を区別する	\C		(?-i)
後方参照しないグループ		\%(atom\)	(?:atom)
最短一致の量指定子		\{-n,m}		*?, +?, ??, {}?
幅ゼロの肯定先読み		atom\@=		(?=atom)
幅ゼロの否定先読み		atom\@!		(?!atom)
幅ゼロの肯定後読み		atom\@<=	(?<=atom)
幅ゼロの否定後読み		atom\@<!	(?<!atom)
強欲な量指定子			atom\@>		(?>atom)

Vim と Perl では文字列中の改行の扱いが少し違います:

Perl では、'^' と '$' はテキストの最先頭と最末尾にマッチしますが、'm' フラグを
使うと、テキストの中間の改行にもマッチするようになります。's' フラグを使うと、
'.' が改行にもマッチするようなります。'm' と 's' のフラグは、上記の(?i) フラグ
のように、パターン中で設定することもできます。

Vim では、'^' と '$' は常に中間の改行にもマッチします。最先頭と最末尾にはそれ
ぞれ、'\%^' と '\%$' がマッチします。Perl の 's' フラグに対応するのは '\_' 修
飾子です。'.' や文字クラスの前に '\_' を付けると、改行にもマッチするようになり
ます。

次のものは Perl だけの機能です:
- 正規表現中で任意のコードを実行する: (?{perl code})
- 条件式: (?(condition)true-expr|false-expr)

次のものは Vim だけの機能です:
- パターンのマジックを変更する:  \v \V \m \M
   (バックスラッシュだらけになるのを防げます)
- 任意にマッチするアトム列:  \%[atoms]
- \&   ("\&" と "\|" は、"and" と "or" の関係です。複数のブランチを同じ場所で
  マッチさせることができます)
- 行や列を指定してマッチングする:  \%5l \%5c \%5v
- 正規表現にマッチしたものとして返される範囲を設定する:  \zs \ze

==============================================================================
10. マッチしたテキストを強調する		      	*match-highlight*

							*syntax-vs-match*
		Note マッチハイライトのメカニズムは |syntax-highlighting| とは
		独立していることに注意してください。これは (通常は) バッファ
		ローカルのハイライトですが、マッチングはウィンドウローカルであ
		り、両方の方法を自由に混合できます。マッチハイライト関数を使用
		すると、いつ、どのように適用するかについてもう少し柔軟性が得ら
		れますが、通常は厳密なルールがなく、一時的なハイライトにのみ使
		用されます。どちらの方法もテキストを隠すために使用できます。

		したがって、|matchadd()| のようなマッチング関数は、構文ルール
		や |synconcealed()| のような関数を考慮しません。また、その逆も
		考慮されません。

							*:mat* *:match*
:mat[ch] {group} /{pattern}/
		カレントウィンドウ内で強調表示するパターンを定義します。強調に
		は {group} が使われます。例: >
			:highlight MyGroup ctermbg=green guibg=green
			:match MyGroup /TODO/
<		{pattern} の区切りには // 以外の文字を使うことができます。'"'
		や '|' などの特別な文字を使うときは注意してください。

		{group} はコマンドを実行する前に定義しておく必要があります。

		{group} の強調表示は、'hlsearch' で文字を強調表示する場合にも
		適用されますが、これはマッチでの強調表示が 'hlsearch' の強調表
		示よりも優先されるためです。構文の強調表示 ('syntax' を参照)
		もマッチによって上書きします。

		Note: 'hlsearch' の強調はすべてのウィンドウに適用されますが、
		":match" はカレントウィンドウだけです。ウィンドウのバッファを
		切り替えても、強調表示は維持されます。

		'ignorecase' の設定は使われず、大文字と小文字の違いを無視する
		には |/\c| を使います。それ以外では大文字と小文字は区別されま
		せん。

		'redrawtime' で検索に費やす最大の時間を定義できます。

		改行にマッチしているときに、Vim がディスプレイの一部だけを再描
		画すると、予期しない結果になることがあります。それは、Vim が再
		描画した行からマッチの検索を開始するからです。

		|matcharg()| と |getmatches()| も参照してください。
		前者はハイライトグループと |:match| コマンドで使用されたパター
		ンを返します。後者はハイライトグループのリストと |matchadd()|
		および |:match| で定義されたパターンを返します。

		|:match| を用いたハイライトのマッチは3つのマッチに制限されてい
		ます (余談ながら |:match|, |:2match|, |:3match| があります)。
		|matchadd()| にはこの制限はなく、加えてマッチの優先度付けがで
		きます。

		別の例として、72 表示列目以降の文字をすべて強調表示します: >
			:highlight rightMargin term=bold ctermfg=blue guifg=blue
			:match rightMargin /.\%>72v/
<		7 表示列目の文字をすべて強調表示するには次のようにします: >
			:highlight col8 ctermbg=grey guibg=grey
			:match col8 /\%<8v.\%>7v/
<		Note: TAB のような複数表示列を占める文字にもマッチさせるため2
		つの項目を使用しています。

:mat[ch]
:mat[ch] none
		以前に定義したマッチパターンを消去します。


:2mat[ch] {group} /{pattern}/					*:2match*
:2mat[ch]
:2mat[ch] none
:3mat[ch] {group} /{pattern}/					*:3match*
:3mat[ch]
:3mat[ch] none
		上述の |:match| と同じですが、別々のマッチを設定します。そのた
		め、同時に 3 つのマッチを表示できます。同じ場所でマッチした場
		合は、数値の低いものが優先されます。これは、マッチ ID 3 を使い
		ます。
		":3match" コマンドは |matchparen| プラグインで使用されています
		(Vim < 9.0.2054)。手動マッチングには ":match"、他のプラグイン
		には ":2match" を使うか、より柔軟な |matchadd()| (および同様の)
		関数を使うことをお勧めします。

==============================================================================
11. ファジーマッチ					*fuzzy-matching*

ファジーマッチは、パターン文字が必ずしも連続して出現するとは限らない場合に、文
字列がパターンにどの程度マッチするかをスコア付けする。

例: >
    パターン:	"vim"
    候補:	"vim"	     -> 完璧
		"vimeo"	     -> 良い (v i m)
		"voice mail" -> 弱い (v _ i _ _ _ m)
		"vintage"    -> マッチしない (no "m")
<
検索文字列に複数の単語が含まれている場合、各単語は個別にマッチし、候補リスト内
で任意の順序で出現する可能性がある。例えば、"get pat" は "GetPattern"、
"PatternGet"、"getPattern"、"patGetter"、"getSomePattern"、"MatchpatternGet"
などとマッチする。

'ignorecase' および 'smartcase' オプションは適用されず、パターンがすべて小文字
の場合、大文字/小文字は無視される。

Vim の実装は、fzy プロジェクトのアルゴリズムに基づいている:
https://github.com/jhawthorn/fzy

与えられたパターンと候補に対して、動的計画法を用いて最適なスコアを計算する。

アルゴリズムは 2 段階で動作する:

1. 前方パス
   候補を左から右にスキャンし、各パターンの位置における最高スコアを追跡する。
   マッチは、候補の先頭、単語の先頭 (スペース、アンダースコア、ダッシュ、キャ
   メルケース)、または直前のマッチの直後に出現すると、より高いスコアになる。

2. 後方パス
   最高得点の終了位置から開始し、一歩下がってマッチする位置を見つけ、配置が最
   適であることを確認する。

Vim はオリジナルのアルゴリズムを拡張し、マルチバイトコードポイントをサポートす
ることで、UTF-8 やその他のエンコーディングでの正確なマッチングを可能にした。

計算時間は O (パターン * 候補) である。メモリ使用量もこれに比例する。

|matchfuzzy()| 関数と |matchfuzzypos()| 関数は、文字列のリスト内でファジー検索
を実行する。|matchfuzzy()| はマッチする文字列を返し、|matchfuzzypos()| はマッ
チする文字列をその位置とスコアとともに返す。

`:vimgrep` の フラグ "f" はファジーマッチを有効にする。

|ins-completion| でファジーマッチを有効にするには、'completeopt' オプションに
"fuzzy" を追加する。|cmdline-completion| の場合は、'wildoptions' オプションに
"fuzzy" を追加する。

 vim:tw=78:ts=8:noet:ft=help:norl:
