1*pattern.txt* For Vim version 8.2. Last change: 2019 Dec 07 2 3 4 VIM REFERENCE MANUAL by Bram Moolenaar 5 6 7Patterns and search commands *pattern-searches* 8 9The very basics can be found in section |03.9| of the user manual. A few more 10explanations are in chapter 27 |usr_27.txt|. 11 121. Search commands |search-commands| 132. The definition of a pattern |search-pattern| 143. Magic |/magic| 154. Overview of pattern items |pattern-overview| 165. Multi items |pattern-multi-items| 176. Ordinary atoms |pattern-atoms| 187. Ignoring case in a pattern |/ignorecase| 198. Composing characters |patterns-composing| 209. Compare with Perl patterns |perl-patterns| 2110. Highlighting matches |match-highlight| 22 23============================================================================== 241. Search commands *search-commands* 25 26 */* 27/{pattern}[/]<CR> Search forward for the [count]'th occurrence of 28 {pattern} |exclusive|. 29 30/{pattern}/{offset}<CR> Search forward for the [count]'th occurrence of 31 {pattern} and go |{offset}| lines up or down. 32 |linewise|. 33 34 */<CR>* 35/<CR> Search forward for the [count]'th occurrence of the 36 latest used pattern |last-pattern| with latest used 37 |{offset}|. 38 39//{offset}<CR> Search forward for the [count]'th occurrence of the 40 latest used pattern |last-pattern| with new 41 |{offset}|. If {offset} is empty no offset is used. 42 43 *?* 44?{pattern}[?]<CR> Search backward for the [count]'th previous 45 occurrence of {pattern} |exclusive|. 46 47?{pattern}?{offset}<CR> Search backward for the [count]'th previous 48 occurrence of {pattern} and go |{offset}| lines up or 49 down |linewise|. 50 51 *?<CR>* 52?<CR> Search backward for the [count]'th occurrence of the 53 latest used pattern |last-pattern| with latest used 54 |{offset}|. 55 56??{offset}<CR> Search backward for the [count]'th occurrence of the 57 latest used pattern |last-pattern| with new 58 |{offset}|. If {offset} is empty no offset is used. 59 60 *n* 61n Repeat the latest "/" or "?" [count] times. 62 If the cursor doesn't move the search is repeated with 63 count + 1. 64 |last-pattern| 65 66 *N* 67N Repeat the latest "/" or "?" [count] times in 68 opposite direction. |last-pattern| 69 70 *star* *E348* *E349* 71* Search forward for the [count]'th occurrence of the 72 word nearest to the cursor. The word used for the 73 search is the first of: 74 1. the keyword under the cursor |'iskeyword'| 75 2. the first keyword after the cursor, in the 76 current line 77 3. the non-blank word under the cursor 78 4. the first non-blank word after the cursor, 79 in the current line 80 Only whole keywords are searched for, like with the 81 command "/\<keyword\>". |exclusive| 82 'ignorecase' is used, 'smartcase' is not. 83 84 *#* 85# Same as "*", but search backward. The pound sign 86 (character 163) also works. If the "#" key works as 87 backspace, try using "stty erase <BS>" before starting 88 Vim (<BS> is CTRL-H or a real backspace). 89 90 *gstar* 91g* Like "*", but don't put "\<" and "\>" around the word. 92 This makes the search also find matches that are not a 93 whole word. 94 95 *g#* 96g# Like "#", but don't put "\<" and "\>" around the word. 97 This makes the search also find matches that are not a 98 whole word. 99 100 *gd* 101gd Goto local Declaration. When the cursor is on a local 102 variable, this command will jump to its declaration. 103 First Vim searches for the start of the current 104 function, just like "[[". If it is not found the 105 search stops in line 1. If it is found, Vim goes back 106 until a blank line is found. From this position Vim 107 searches for the keyword under the cursor, like with 108 "*", but lines that look like a comment are ignored 109 (see 'comments' option). 110 Note that this is not guaranteed to work, Vim does not 111 really check the syntax, it only searches for a match 112 with the keyword. If included files also need to be 113 searched use the commands listed in |include-search|. 114 After this command |n| searches forward for the next 115 match (not backward). 116 117 *gD* 118gD Goto global Declaration. When the cursor is on a 119 global variable that is defined in the file, this 120 command will jump to its declaration. This works just 121 like "gd", except that the search for the keyword 122 always starts in line 1. 123 124 *1gd* 1251gd Like "gd", but ignore matches inside a {} block that 126 ends before the cursor position. 127 128 *1gD* 1291gD Like "gD", but ignore matches inside a {} block that 130 ends before the cursor position. 131 132 *CTRL-C* 133CTRL-C Interrupt current (search) command. Use CTRL-Break on 134 MS-Windows |dos-CTRL-Break|. 135 In Normal mode, any pending command is aborted. 136 137 *:noh* *:nohlsearch* 138:noh[lsearch] Stop the highlighting for the 'hlsearch' option. It 139 is automatically turned back on when using a search 140 command, or setting the 'hlsearch' option. 141 This command doesn't work in an autocommand, because 142 the highlighting state is saved and restored when 143 executing autocommands |autocmd-searchpat|. 144 Same thing for when invoking a user function. 145 146While typing the search pattern the current match will be shown if the 147'incsearch' option is on. Remember that you still have to finish the search 148command with <CR> to actually position the cursor at the displayed match. Or 149use <Esc> to abandon the search. 150 151All matches for the last used search pattern will be highlighted if you set 152the 'hlsearch' option. This can be suspended with the |:nohlsearch| command. 153 154When 'shortmess' does not include the "S" flag, Vim will automatically show an 155index, on which the cursor is. This can look like this: > 156 157 [1/5] Cursor is on first of 5 matches. 158 [1/>99] Cursor is on first of more than 99 matches. 159 [>99/>99] Cursor is after 99 match of more than 99 matches. 160 [?/??] Unknown how many matches exists, generating the 161 statistics was aborted because of search timeout. 162 163Note: the count does not take offset into account. 164 165When no match is found you get the error: *E486* Pattern not found 166Note that for the |:global| command this behaves like a normal message, for Vi 167compatibility. For the |:s| command the "e" flag can be used to avoid the 168error message |:s_flags|. 169 170 *search-offset* *{offset}* 171These commands search for the specified pattern. With "/" and "?" an 172additional offset may be given. There are two types of offsets: line offsets 173and character offsets. 174 175The offset gives the cursor position relative to the found match: 176 [num] [num] lines downwards, in column 1 177 +[num] [num] lines downwards, in column 1 178 -[num] [num] lines upwards, in column 1 179 e[+num] [num] characters to the right of the end of the match 180 e[-num] [num] characters to the left of the end of the match 181 s[+num] [num] characters to the right of the start of the match 182 s[-num] [num] characters to the left of the start of the match 183 b[+num] [num] identical to s[+num] above (mnemonic: begin) 184 b[-num] [num] identical to s[-num] above (mnemonic: begin) 185 ;{pattern} perform another search, see |//;| 186 187If a '-' or '+' is given but [num] is omitted, a count of one will be used. 188When including an offset with 'e', the search becomes inclusive (the 189character the cursor lands on is included in operations). 190 191Examples: 192 193pattern cursor position ~ 194/test/+1 one line below "test", in column 1 195/test/e on the last t of "test" 196/test/s+2 on the 's' of "test" 197/test/b-3 three characters before "test" 198 199If one of these commands is used after an operator, the characters between 200the cursor position before and after the search is affected. However, if a 201line offset is given, the whole lines between the two cursor positions are 202affected. 203 204An example of how to search for matches with a pattern and change the match 205with another word: > 206 /foo<CR> find "foo" 207 c//e<CR> change until end of match 208 bar<Esc> type replacement 209 //<CR> go to start of next match 210 c//e<CR> change until end of match 211 beep<Esc> type another replacement 212 etc. 213< 214 *//;* *E386* 215A very special offset is ';' followed by another search command. For example: > 216 217 /test 1/;/test 218 /test.*/+1;?ing? 219 220The first one first finds the next occurrence of "test 1", and then the first 221occurrence of "test" after that. 222 223This is like executing two search commands after each other, except that: 224- It can be used as a single motion command after an operator. 225- The direction for a following "n" or "N" command comes from the first 226 search command. 227- When an error occurs the cursor is not moved at all. 228 229 *last-pattern* 230The last used pattern and offset are remembered. They can be used to repeat 231the search, possibly in another direction or with another count. Note that 232two patterns are remembered: One for 'normal' search commands and one for the 233substitute command ":s". Each time an empty pattern is given, the previously 234used pattern is used. However, if there is no previous search command, a 235previous substitute pattern is used, if possible. 236 237The 'magic' option sticks with the last used pattern. If you change 'magic', 238this will not change how the last used pattern will be interpreted. 239The 'ignorecase' option does not do this. When 'ignorecase' is changed, it 240will result in the pattern to match other text. 241 242All matches for the last used search pattern will be highlighted if you set 243the 'hlsearch' option. 244 245To clear the last used search pattern: > 246 :let @/ = "" 247This will not set the pattern to an empty string, because that would match 248everywhere. The pattern is really cleared, like when starting Vim. 249 250The search usually skips matches that don't move the cursor. Whether the next 251match is found at the next character or after the skipped match depends on the 252'c' flag in 'cpoptions'. See |cpo-c|. 253 with 'c' flag: "/..." advances 1 to 3 characters 254 without 'c' flag: "/..." advances 1 character 255The unpredictability with the 'c' flag is caused by starting the search in the 256first column, skipping matches until one is found past the cursor position. 257 258When searching backwards, searching starts at the start of the line, using the 259'c' flag in 'cpoptions' as described above. Then the last match before the 260cursor position is used. 261 262In Vi the ":tag" command sets the last search pattern when the tag is searched 263for. In Vim this is not done, the previous search pattern is still remembered, 264unless the 't' flag is present in 'cpoptions'. The search pattern is always 265put in the search history. 266 267If the 'wrapscan' option is on (which is the default), searches wrap around 268the end of the buffer. If 'wrapscan' is not set, the backward search stops 269at the beginning and the forward search stops at the end of the buffer. If 270'wrapscan' is set and the pattern was not found the error message "pattern 271not found" is given, and the cursor will not be moved. If 'wrapscan' is not 272set the message becomes "search hit BOTTOM without match" when searching 273forward, or "search hit TOP without match" when searching backward. If 274wrapscan is set and the search wraps around the end of the file the message 275"search hit TOP, continuing at BOTTOM" or "search hit BOTTOM, continuing at 276TOP" is given when searching backwards or forwards respectively. This can be 277switched off by setting the 's' flag in the 'shortmess' option. The highlight 278method 'w' is used for this message (default: standout). 279 280 *search-range* 281You can limit the search command "/" to a certain range of lines by including 282\%>l items. For example, to match the word "limit" below line 199 and above 283line 300: > 284 /\%>199l\%<300llimit 285Also see |/\%>l|. 286 287Another way is to use the ":substitute" command with the 'c' flag. Example: > 288 :.,300s/Pattern//gc 289This command will search from the cursor position until line 300 for 290"Pattern". At the match, you will be asked to type a character. Type 'q' to 291stop at this match, type 'n' to find the next match. 292 293The "*", "#", "g*" and "g#" commands look for a word near the cursor in this 294order, the first one that is found is used: 295- The keyword currently under the cursor. 296- The first keyword to the right of the cursor, in the same line. 297- The WORD currently under the cursor. 298- The first WORD to the right of the cursor, in the same line. 299The keyword may only contain letters and characters in 'iskeyword'. 300The WORD may contain any non-blanks (<Tab>s and/or <Space>s). 301Note that if you type with ten fingers, the characters are easy to remember: 302the "#" is under your left hand middle finger (search to the left and up) and 303the "*" is under your right hand middle finger (search to the right and down). 304(this depends on your keyboard layout though). 305 306 *E956* 307In very rare cases a regular expression is used recursively. This can happen 308when executing a pattern takes a long time and when checking for messages on 309channels a callback is invoked that also uses a pattern or an autocommand is 310triggered. In most cases this should be fine, but if a pattern is in use when 311it's used again it fails. Usually this means there is something wrong with 312the pattern. 313 314============================================================================== 3152. The definition of a pattern *search-pattern* *pattern* *[pattern]* 316 *regular-expression* *regexp* *Pattern* 317 *E76* *E383* *E476* 318 319For starters, read chapter 27 of the user manual |usr_27.txt|. 320 321 */bar* */\bar* */pattern* 3221. A pattern is one or more branches, separated by "\|". It matches anything 323 that matches one of the branches. Example: "foo\|beep" matches "foo" and 324 matches "beep". If more than one branch matches, the first one is used. 325 326 pattern ::= branch 327 or branch \| branch 328 or branch \| branch \| branch 329 etc. 330 331 */branch* */\&* 3322. A branch is one or more concats, separated by "\&". It matches the last 333 concat, but only if all the preceding concats also match at the same 334 position. Examples: 335 "foobeep\&..." matches "foo" in "foobeep". 336 ".*Peter\&.*Bob" matches in a line containing both "Peter" and "Bob" 337 338 branch ::= concat 339 or concat \& concat 340 or concat \& concat \& concat 341 etc. 342 343 */concat* 3443. A concat is one or more pieces, concatenated. It matches a match for the 345 first piece, followed by a match for the second piece, etc. Example: 346 "f[0-9]b", first matches "f", then a digit and then "b". 347 348 concat ::= piece 349 or piece piece 350 or piece piece piece 351 etc. 352 353 */piece* 3544. A piece is an atom, possibly followed by a multi, an indication of how many 355 times the atom can be matched. Example: "a*" matches any sequence of "a" 356 characters: "", "a", "aa", etc. See |/multi|. 357 358 piece ::= atom 359 or atom multi 360 361 */atom* 3625. An atom can be one of a long list of items. Many atoms match one character 363 in the text. It is often an ordinary character or a character class. 364 Braces can be used to make a pattern into an atom. The "\z(\)" construct 365 is only for syntax highlighting. 366 367 atom ::= ordinary-atom |/ordinary-atom| 368 or \( pattern \) |/\(| 369 or \%( pattern \) |/\%(| 370 or \z( pattern \) |/\z(| 371 372 373 */\%#=* *two-engines* *NFA* 374Vim includes two regexp engines: 3751. An old, backtracking engine that supports everything. 3762. A new, NFA engine that works much faster on some patterns, possibly slower 377 on some patterns. 378 379Vim will automatically select the right engine for you. However, if you run 380into a problem or want to specifically select one engine or the other, you can 381prepend one of the following to the pattern: 382 383 \%#=0 Force automatic selection. Only has an effect when 384 'regexpengine' has been set to a non-zero value. 385 \%#=1 Force using the old engine. 386 \%#=2 Force using the NFA engine. 387 388You can also use the 'regexpengine' option to change the default. 389 390 *E864* *E868* *E874* *E875* *E876* *E877* *E878* 391If selecting the NFA engine and it runs into something that is not implemented 392the pattern will not match. This is only useful when debugging Vim. 393 394============================================================================== 3953. Magic */magic* 396 397Some characters in the pattern are taken literally. They match with the same 398character in the text. When preceded with a backslash however, these 399characters get a special meaning. 400 401Other characters have a special meaning without a backslash. They need to be 402preceded with a backslash to match literally. 403 404If a character is taken literally or not depends on the 'magic' option and the 405items mentioned next. 406 */\m* */\M* 407Use of "\m" makes the pattern after it be interpreted as if 'magic' is set, 408ignoring the actual value of the 'magic' option. 409Use of "\M" makes the pattern after it be interpreted as if 'nomagic' is used. 410 */\v* */\V* 411Use of "\v" means that after it, all ASCII characters except '0'-'9', 'a'-'z', 412'A'-'Z' and '_' have special meaning: "very magic" 413 414Use of "\V" means that after it, only a backslash and terminating character 415(usually / or ?) have special meaning: "very nomagic" 416 417Examples: 418after: \v \m \M \V matches ~ 419 'magic' 'nomagic' 420 $ $ $ \$ matches end-of-line 421 . . \. \. matches any character 422 * * \* \* any number of the previous atom 423 ~ ~ \~ \~ latest substitute string 424 () \(\) \(\) \(\) grouping into an atom 425 | \| \| \| separating alternatives 426 \a \a \a \a alphabetic character 427 \\ \\ \\ \\ literal backslash 428 \. \. . . literal dot 429 \{ { { { literal '{' 430 a a a a literal 'a' 431 432{only Vim supports \m, \M, \v and \V} 433 434It is recommended to always keep the 'magic' option at the default setting, 435which is 'magic'. This avoids portability problems. To make a pattern immune 436to the 'magic' option being set or not, put "\m" or "\M" at the start of the 437pattern. 438 439============================================================================== 4404. Overview of pattern items *pattern-overview* 441 *E865* *E866* *E867* *E869* 442 443Overview of multi items. */multi* *E61* *E62* 444More explanation and examples below, follow the links. *E64* *E871* 445 446 multi ~ 447 'magic' 'nomagic' matches of the preceding atom ~ 448|/star| * \* 0 or more as many as possible 449|/\+| \+ \+ 1 or more as many as possible 450|/\=| \= \= 0 or 1 as many as possible 451|/\?| \? \? 0 or 1 as many as possible 452 453|/\{| \{n,m} \{n,m} n to m as many as possible 454 \{n} \{n} n exactly 455 \{n,} \{n,} at least n as many as possible 456 \{,m} \{,m} 0 to m as many as possible 457 \{} \{} 0 or more as many as possible (same as *) 458 459|/\{-| \{-n,m} \{-n,m} n to m as few as possible 460 \{-n} \{-n} n exactly 461 \{-n,} \{-n,} at least n as few as possible 462 \{-,m} \{-,m} 0 to m as few as possible 463 \{-} \{-} 0 or more as few as possible 464 465 *E59* 466|/\@>| \@> \@> 1, like matching a whole pattern 467|/\@=| \@= \@= nothing, requires a match |/zero-width| 468|/\@!| \@! \@! nothing, requires NO match |/zero-width| 469|/\@<=| \@<= \@<= nothing, requires a match behind |/zero-width| 470|/\@<!| \@<! \@<! nothing, requires NO match behind |/zero-width| 471 472 473Overview of ordinary atoms. */ordinary-atom* 474More explanation and examples below, follow the links. 475 476 ordinary atom ~ 477 magic nomagic matches ~ 478|/^| ^ ^ start-of-line (at start of pattern) |/zero-width| 479|/\^| \^ \^ literal '^' 480|/\_^| \_^ \_^ start-of-line (used anywhere) |/zero-width| 481|/$| $ $ end-of-line (at end of pattern) |/zero-width| 482|/\$| \$ \$ literal '$' 483|/\_$| \_$ \_$ end-of-line (used anywhere) |/zero-width| 484|/.| . \. any single character (not an end-of-line) 485|/\_.| \_. \_. any single character or end-of-line 486|/\<| \< \< beginning of a word |/zero-width| 487|/\>| \> \> end of a word |/zero-width| 488|/\zs| \zs \zs anything, sets start of match 489|/\ze| \ze \ze anything, sets end of match 490|/\%^| \%^ \%^ beginning of file |/zero-width| *E71* 491|/\%$| \%$ \%$ end of file |/zero-width| 492|/\%V| \%V \%V inside Visual area |/zero-width| 493|/\%#| \%# \%# cursor position |/zero-width| 494|/\%'m| \%'m \%'m mark m position |/zero-width| 495|/\%l| \%23l \%23l in line 23 |/zero-width| 496|/\%c| \%23c \%23c in column 23 |/zero-width| 497|/\%v| \%23v \%23v in virtual column 23 |/zero-width| 498 499Character classes: */character-classes* 500 magic nomagic matches ~ 501|/\i| \i \i identifier character (see 'isident' option) 502|/\I| \I \I like "\i", but excluding digits 503|/\k| \k \k keyword character (see 'iskeyword' option) 504|/\K| \K \K like "\k", but excluding digits 505|/\f| \f \f file name character (see 'isfname' option) 506|/\F| \F \F like "\f", but excluding digits 507|/\p| \p \p printable character (see 'isprint' option) 508|/\P| \P \P like "\p", but excluding digits 509|/\s| \s \s whitespace character: <Space> and <Tab> 510|/\S| \S \S non-whitespace character; opposite of \s 511|/\d| \d \d digit: [0-9] 512|/\D| \D \D non-digit: [^0-9] 513|/\x| \x \x hex digit: [0-9A-Fa-f] 514|/\X| \X \X non-hex digit: [^0-9A-Fa-f] 515|/\o| \o \o octal digit: [0-7] 516|/\O| \O \O non-octal digit: [^0-7] 517|/\w| \w \w word character: [0-9A-Za-z_] 518|/\W| \W \W non-word character: [^0-9A-Za-z_] 519|/\h| \h \h head of word character: [A-Za-z_] 520|/\H| \H \H non-head of word character: [^A-Za-z_] 521|/\a| \a \a alphabetic character: [A-Za-z] 522|/\A| \A \A non-alphabetic character: [^A-Za-z] 523|/\l| \l \l lowercase character: [a-z] 524|/\L| \L \L non-lowercase character: [^a-z] 525|/\u| \u \u uppercase character: [A-Z] 526|/\U| \U \U non-uppercase character [^A-Z] 527|/\_| \_x \_x where x is any of the characters above: character 528 class with end-of-line included 529(end of character classes) 530 531 magic nomagic matches ~ 532|/\e| \e \e <Esc> 533|/\t| \t \t <Tab> 534|/\r| \r \r <CR> 535|/\b| \b \b <BS> 536|/\n| \n \n end-of-line 537|/~| ~ \~ last given substitute string 538|/\1| \1 \1 same string as matched by first \(\) 539|/\2| \2 \2 Like "\1", but uses second \(\) 540 ... 541|/\9| \9 \9 Like "\1", but uses ninth \(\) 542 *E68* 543|/\z1| \z1 \z1 only for syntax highlighting, see |:syn-ext-match| 544 ... 545|/\z1| \z9 \z9 only for syntax highlighting, see |:syn-ext-match| 546 547 x x a character with no special meaning matches itself 548 549|/[]| [] \[] any character specified inside the [] 550|/\%[]| \%[] \%[] a sequence of optionally matched atoms 551 552|/\c| \c \c ignore case, do not use the 'ignorecase' option 553|/\C| \C \C match case, do not use the 'ignorecase' option 554|/\Z| \Z \Z ignore differences in Unicode "combining characters". 555 Useful when searching voweled Hebrew or Arabic text. 556 557 magic nomagic matches ~ 558|/\m| \m \m 'magic' on for the following chars in the pattern 559|/\M| \M \M 'magic' off for the following chars in the pattern 560|/\v| \v \v the following chars in the pattern are "very magic" 561|/\V| \V \V the following chars in the pattern are "very nomagic" 562|/\%#=| \%#=1 \%#=1 select regexp engine |/zero-width| 563 564|/\%d| \%d \%d match specified decimal character (eg \%d123) 565|/\%x| \%x \%x match specified hex character (eg \%x2a) 566|/\%o| \%o \%o match specified octal character (eg \%o040) 567|/\%u| \%u \%u match specified multibyte character (eg \%u20ac) 568|/\%U| \%U \%U match specified large multibyte character (eg 569 \%U12345678) 570|/\%C| \%C \%C match any composing characters 571 572Example matches ~ 573\<\I\i* or 574\<\h\w* 575\<[a-zA-Z_][a-zA-Z0-9_]* 576 An identifier (e.g., in a C program). 577 578\(\.$\|\. \) A period followed by <EOL> or a space. 579 580[.!?][])"']*\($\|[ ]\) A search pattern that finds the end of a sentence, 581 with almost the same definition as the ")" command. 582 583cat\Z Both "cat" and "càt" ("a" followed by 0x0300) 584 Does not match "càt" (character 0x00e0), even 585 though it may look the same. 586 587 588============================================================================== 5895. Multi items *pattern-multi-items* 590 591An atom can be followed by an indication of how many times the atom can be 592matched and in what way. This is called a multi. See |/multi| for an 593overview. 594 595 */star* */\star* 596* (use \* when 'magic' is not set) 597 Matches 0 or more of the preceding atom, as many as possible. 598 Example 'nomagic' matches ~ 599 a* a\* "", "a", "aa", "aaa", etc. 600 .* \.\* anything, also an empty string, no end-of-line 601 \_.* \_.\* everything up to the end of the buffer 602 \_.*END \_.\*END everything up to and including the last "END" 603 in the buffer 604 605 Exception: When "*" is used at the start of the pattern or just after 606 "^" it matches the star character. 607 608 Be aware that repeating "\_." can match a lot of text and take a long 609 time. For example, "\_.*END" matches all text from the current 610 position to the last occurrence of "END" in the file. Since the "*" 611 will match as many as possible, this first skips over all lines until 612 the end of the file and then tries matching "END", backing up one 613 character at a time. 614 615 */\+* 616\+ Matches 1 or more of the preceding atom, as many as possible. 617 Example matches ~ 618 ^.\+$ any non-empty line 619 \s\+ white space of at least one character 620 621 */\=* 622\= Matches 0 or 1 of the preceding atom, as many as possible. 623 Example matches ~ 624 foo\= "fo" and "foo" 625 626 */\?* 627\? Just like \=. Cannot be used when searching backwards with the "?" 628 command. 629 630 */\{* *E60* *E554* *E870* 631\{n,m} Matches n to m of the preceding atom, as many as possible 632\{n} Matches n of the preceding atom 633\{n,} Matches at least n of the preceding atom, as many as possible 634\{,m} Matches 0 to m of the preceding atom, as many as possible 635\{} Matches 0 or more of the preceding atom, as many as possible (like *) 636 */\{-* 637\{-n,m} matches n to m of the preceding atom, as few as possible 638\{-n} matches n of the preceding atom 639\{-n,} matches at least n of the preceding atom, as few as possible 640\{-,m} matches 0 to m of the preceding atom, as few as possible 641\{-} matches 0 or more of the preceding atom, as few as possible 642 643 n and m are positive decimal numbers or zero 644 *non-greedy* 645 If a "-" appears immediately after the "{", then a shortest match 646 first algorithm is used (see example below). In particular, "\{-}" is 647 the same as "*" but uses the shortest match first algorithm. BUT: A 648 match that starts earlier is preferred over a shorter match: "a\{-}b" 649 matches "aaab" in "xaaab". 650 651 Example matches ~ 652 ab\{2,3}c "abbc" or "abbbc" 653 a\{5} "aaaaa" 654 ab\{2,}c "abbc", "abbbc", "abbbbc", etc. 655 ab\{,3}c "ac", "abc", "abbc" or "abbbc" 656 a[bc]\{3}d "abbbd", "abbcd", "acbcd", "acccd", etc. 657 a\(bc\)\{1,2}d "abcd" or "abcbcd" 658 a[bc]\{-}[cd] "abc" in "abcd" 659 a[bc]*[cd] "abcd" in "abcd" 660 661 The } may optionally be preceded with a backslash: \{n,m\}. 662 663 */\@=* 664\@= Matches the preceding atom with zero width. 665 Like "(?=pattern)" in Perl. 666 Example matches ~ 667 foo\(bar\)\@= "foo" in "foobar" 668 foo\(bar\)\@=foo nothing 669 */zero-width* 670 When using "\@=" (or "^", "$", "\<", "\>") no characters are included 671 in the match. These items are only used to check if a match can be 672 made. This can be tricky, because a match with following items will 673 be done in the same position. The last example above will not match 674 "foobarfoo", because it tries match "foo" in the same position where 675 "bar" matched. 676 677 Note that using "\&" works the same as using "\@=": "foo\&.." is the 678 same as "\(foo\)\@=..". But using "\&" is easier, you don't need the 679 braces. 680 681 682 */\@!* 683\@! Matches with zero width if the preceding atom does NOT match at the 684 current position. |/zero-width| 685 Like "(?!pattern)" in Perl. 686 Example matches ~ 687 foo\(bar\)\@! any "foo" not followed by "bar" 688 a.\{-}p\@! "a", "ap", "app", "appp", etc. not immediately 689 followed by a "p" 690 if \(\(then\)\@!.\)*$ "if " not followed by "then" 691 692 Using "\@!" is tricky, because there are many places where a pattern 693 does not match. "a.*p\@!" will match from an "a" to the end of the 694 line, because ".*" can match all characters in the line and the "p" 695 doesn't match at the end of the line. "a.\{-}p\@!" will match any 696 "a", "ap", "app", etc. that isn't followed by a "p", because the "." 697 can match a "p" and "p\@!" doesn't match after that. 698 699 You can't use "\@!" to look for a non-match before the matching 700 position: "\(foo\)\@!bar" will match "bar" in "foobar", because at the 701 position where "bar" matches, "foo" does not match. To avoid matching 702 "foobar" you could use "\(foo\)\@!...bar", but that doesn't match a 703 bar at the start of a line. Use "\(foo\)\@<!bar". 704 705 Useful example: to find "foo" in a line that does not contain "bar": > 706 /^\%(.*bar\)\@!.*\zsfoo 707< This pattern first checks that there is not a single position in the 708 line where "bar" matches. If ".*bar" matches somewhere the \@! will 709 reject the pattern. When there is no match any "foo" will be found. 710 The "\zs" is to have the match start just before "foo". 711 712 */\@<=* 713\@<= Matches with zero width if the preceding atom matches just before what 714 follows. |/zero-width| 715 Like "(?<=pattern)" in Perl, but Vim allows non-fixed-width patterns. 716 Example matches ~ 717 \(an\_s\+\)\@<=file "file" after "an" and white space or an 718 end-of-line 719 For speed it's often much better to avoid this multi. Try using "\zs" 720 instead |/\zs|. To match the same as the above example: 721 an\_s\+\zsfile 722 At least set a limit for the look-behind, see below. 723 724 "\@<=" and "\@<!" check for matches just before what follows. 725 Theoretically these matches could start anywhere before this position. 726 But to limit the time needed, only the line where what follows matches 727 is searched, and one line before that (if there is one). This should 728 be sufficient to match most things and not be too slow. 729 730 In the old regexp engine the part of the pattern after "\@<=" and 731 "\@<!" are checked for a match first, thus things like "\1" don't work 732 to reference \(\) inside the preceding atom. It does work the other 733 way around: 734 Bad example matches ~ 735 \%#=1\1\@<=,\([a-z]\+\) ",abc" in "abc,abc" 736 737 However, the new regexp engine works differently, it is better to not 738 rely on this behavior, do not use \@<= if it can be avoided: 739 Example matches ~ 740 \([a-z]\+\)\zs,\1 ",abc" in "abc,abc" 741 742\@123<= 743 Like "\@<=" but only look back 123 bytes. This avoids trying lots 744 of matches that are known to fail and make executing the pattern very 745 slow. Example, check if there is a "<" just before "span": 746 /<\@1<=span 747 This will try matching "<" only one byte before "span", which is the 748 only place that works anyway. 749 After crossing a line boundary, the limit is relative to the end of 750 the line. Thus the characters at the start of the line with the match 751 are not counted (this is just to keep it simple). 752 The number zero is the same as no limit. 753 754 */\@<!* 755\@<! Matches with zero width if the preceding atom does NOT match just 756 before what follows. Thus this matches if there is no position in the 757 current or previous line where the atom matches such that it ends just 758 before what follows. |/zero-width| 759 Like "(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns. 760 The match with the preceding atom is made to end just before the match 761 with what follows, thus an atom that ends in ".*" will work. 762 Warning: This can be slow (because many positions need to be checked 763 for a match). Use a limit if you can, see below. 764 Example matches ~ 765 \(foo\)\@<!bar any "bar" that's not in "foobar" 766 \(\/\/.*\)\@<!in "in" which is not after "//" 767 768\@123<! 769 Like "\@<!" but only look back 123 bytes. This avoids trying lots of 770 matches that are known to fail and make executing the pattern very 771 slow. 772 773 */\@>* 774\@> Matches the preceding atom like matching a whole pattern. 775 Like "(?>pattern)" in Perl. 776 Example matches ~ 777 \(a*\)\@>a nothing (the "a*" takes all the "a"'s, there can't be 778 another one following) 779 780 This matches the preceding atom as if it was a pattern by itself. If 781 it doesn't match, there is no retry with shorter sub-matches or 782 anything. Observe this difference: "a*b" and "a*ab" both match 783 "aaab", but in the second case the "a*" matches only the first two 784 "a"s. "\(a*\)\@>ab" will not match "aaab", because the "a*" matches 785 the "aaa" (as many "a"s as possible), thus the "ab" can't match. 786 787 788============================================================================== 7896. Ordinary atoms *pattern-atoms* 790 791An ordinary atom can be: 792 793 */^* 794^ At beginning of pattern or after "\|", "\(", "\%(" or "\n": matches 795 start-of-line; at other positions, matches literal '^'. |/zero-width| 796 Example matches ~ 797 ^beep( the start of the C function "beep" (probably). 798 799 */\^* 800\^ Matches literal '^'. Can be used at any position in the pattern. 801 802 */\_^* 803\_^ Matches start-of-line. |/zero-width| Can be used at any position in 804 the pattern. 805 Example matches ~ 806 \_s*\_^foo white space and blank lines and then "foo" at 807 start-of-line 808 809 */$* 810$ At end of pattern or in front of "\|", "\)" or "\n" ('magic' on): 811 matches end-of-line <EOL>; at other positions, matches literal '$'. 812 |/zero-width| 813 814 */\$* 815\$ Matches literal '$'. Can be used at any position in the pattern. 816 817 */\_$* 818\_$ Matches end-of-line. |/zero-width| Can be used at any position in the 819 pattern. Note that "a\_$b" never matches, since "b" cannot match an 820 end-of-line. Use "a\nb" instead |/\n|. 821 Example matches ~ 822 foo\_$\_s* "foo" at end-of-line and following white space and 823 blank lines 824 825. (with 'nomagic': \.) */.* */\.* 826 Matches any single character, but not an end-of-line. 827 828 */\_.* 829\_. Matches any single character or end-of-line. 830 Careful: "\_.*" matches all text to the end of the buffer! 831 832 */\<* 833\< Matches the beginning of a word: The next char is the first char of a 834 word. The 'iskeyword' option specifies what is a word character. 835 |/zero-width| 836 837 */\>* 838\> Matches the end of a word: The previous char is the last char of a 839 word. The 'iskeyword' option specifies what is a word character. 840 |/zero-width| 841 842 */\zs* 843\zs Matches at any position, and sets the start of the match there: The 844 next char is the first char of the whole match. |/zero-width| 845 Example: > 846 /^\s*\zsif 847< matches an "if" at the start of a line, ignoring white space. 848 Can be used multiple times, the last one encountered in a matching 849 branch is used. Example: > 850 /\(.\{-}\zsFab\)\{3} 851< Finds the third occurrence of "Fab". 852 This cannot be followed by a multi. *E888* 853 {not available when compiled without the |+syntax| feature} 854 */\ze* 855\ze Matches at any position, and sets the end of the match there: The 856 previous char is the last char of the whole match. |/zero-width| 857 Can be used multiple times, the last one encountered in a matching 858 branch is used. 859 Example: "end\ze\(if\|for\)" matches the "end" in "endif" and 860 "endfor". 861 This cannot be followed by a multi. |E888| 862 {not available when compiled without the |+syntax| feature} 863 864 */\%^* *start-of-file* 865\%^ Matches start of the file. When matching with a string, matches the 866 start of the string. 867 For example, to find the first "VIM" in a file: > 868 /\%^\_.\{-}\zsVIM 869< 870 */\%$* *end-of-file* 871\%$ Matches end of the file. When matching with a string, matches the 872 end of the string. 873 Note that this does NOT find the last "VIM" in a file: > 874 /VIM\_.\{-}\%$ 875< It will find the next VIM, because the part after it will always 876 match. This one will find the last "VIM" in the file: > 877 /VIM\ze\(\(VIM\)\@!\_.\)*\%$ 878< This uses |/\@!| to ascertain that "VIM" does NOT match in any 879 position after the first "VIM". 880 Searching from the end of the file backwards is easier! 881 882 */\%V* 883\%V Match inside the Visual area. When Visual mode has already been 884 stopped match in the area that |gv| would reselect. 885 This is a |/zero-width| match. To make sure the whole pattern is 886 inside the Visual area put it at the start and just before the end of 887 the pattern, e.g.: > 888 /\%Vfoo.*ba\%Vr 889< This also works if only "foo bar" was Visually selected. This: > 890 /\%Vfoo.*bar\%V 891< would match "foo bar" if the Visual selection continues after the "r". 892 Only works for the current buffer. 893 894 */\%#* *cursor-position* 895\%# Matches with the cursor position. Only works when matching in a 896 buffer displayed in a window. 897 WARNING: When the cursor is moved after the pattern was used, the 898 result becomes invalid. Vim doesn't automatically update the matches. 899 This is especially relevant for syntax highlighting and 'hlsearch'. 900 In other words: When the cursor moves the display isn't updated for 901 this change. An update is done for lines which are changed (the whole 902 line is updated) or when using the |CTRL-L| command (the whole screen 903 is updated). Example, to highlight the word under the cursor: > 904 /\k*\%#\k* 905< When 'hlsearch' is set and you move the cursor around and make changes 906 this will clearly show when the match is updated or not. 907 908 */\%'m* */\%<'m* */\%>'m* 909\%'m Matches with the position of mark m. 910\%<'m Matches before the position of mark m. 911\%>'m Matches after the position of mark m. 912 Example, to highlight the text from mark 's to 'e: > 913 /.\%>'s.*\%<'e.. 914< Note that two dots are required to include mark 'e in the match. That 915 is because "\%<'e" matches at the character before the 'e mark, and 916 since it's a |/zero-width| match it doesn't include that character. 917 WARNING: When the mark is moved after the pattern was used, the result 918 becomes invalid. Vim doesn't automatically update the matches. 919 Similar to moving the cursor for "\%#" |/\%#|. 920 921 */\%l* */\%>l* */\%<l* *E951* 922\%23l Matches in a specific line. 923\%<23l Matches above a specific line (lower line number). 924\%>23l Matches below a specific line (higher line number). 925 These three can be used to match specific lines in a buffer. The "23" 926 can be any line number. The first line is 1. 927 WARNING: When inserting or deleting lines Vim does not automatically 928 update the matches. This means Syntax highlighting quickly becomes 929 wrong. 930 Example, to highlight the line where the cursor currently is: > 931 :exe '/\%' . line(".") . 'l.*' 932< When 'hlsearch' is set and you move the cursor around and make changes 933 this will clearly show when the match is updated or not. 934 935 */\%c* */\%>c* */\%<c* 936\%23c Matches in a specific column. 937\%<23c Matches before a specific column. 938\%>23c Matches after a specific column. 939 These three can be used to match specific columns in a buffer or 940 string. The "23" can be any column number. The first column is 1. 941 Actually, the column is the byte number (thus it's not exactly right 942 for multi-byte characters). 943 WARNING: When inserting or deleting text Vim does not automatically 944 update the matches. This means Syntax highlighting quickly becomes 945 wrong. 946 Example, to highlight the column where the cursor currently is: > 947 :exe '/\%' . col(".") . 'c' 948< When 'hlsearch' is set and you move the cursor around and make changes 949 this will clearly show when the match is updated or not. 950 Example for matching a single byte in column 44: > 951 /\%>43c.\%<46c 952< Note that "\%<46c" matches in column 45 when the "." matches a byte in 953 column 44. 954 */\%v* */\%>v* */\%<v* 955\%23v Matches in a specific virtual column. 956\%<23v Matches before a specific virtual column. 957\%>23v Matches after a specific virtual column. 958 These three can be used to match specific virtual columns in a buffer 959 or string. When not matching with a buffer in a window, the option 960 values of the current window are used (e.g., 'tabstop'). 961 The "23" can be any column number. The first column is 1. 962 Note that some virtual column positions will never match, because they 963 are halfway through a tab or other character that occupies more than 964 one screen character. 965 WARNING: When inserting or deleting text Vim does not automatically 966 update highlighted matches. This means Syntax highlighting quickly 967 becomes wrong. 968 Example, to highlight all the characters after virtual column 72: > 969 /\%>72v.* 970< When 'hlsearch' is set and you move the cursor around and make changes 971 this will clearly show when the match is updated or not. 972 To match the text up to column 17: > 973 /^.*\%17v 974< Column 17 is not included, because this is a |/zero-width| match. To 975 include the column use: > 976 /^.*\%17v. 977< This command does the same thing, but also matches when there is no 978 character in column 17: > 979 /^.*\%<18v. 980< Note that without the "^" to anchor the match in the first column, 981 this will also highlight column 17: > 982 /.*\%17v 983< Column 17 is highlighted by 'hlsearch' because there is another match 984 where ".*" matches zero characters. 985< 986 987Character classes: 988\i identifier character (see 'isident' option) */\i* 989\I like "\i", but excluding digits */\I* 990\k keyword character (see 'iskeyword' option) */\k* 991\K like "\k", but excluding digits */\K* 992\f file name character (see 'isfname' option) */\f* 993\F like "\f", but excluding digits */\F* 994\p printable character (see 'isprint' option) */\p* 995\P like "\p", but excluding digits */\P* 996 997NOTE: the above also work for multi-byte characters. The ones below only 998match ASCII characters, as indicated by the range. 999 1000 *whitespace* *white-space* 1001\s whitespace character: <Space> and <Tab> */\s* 1002\S non-whitespace character; opposite of \s */\S* 1003\d digit: [0-9] */\d* 1004\D non-digit: [^0-9] */\D* 1005\x hex digit: [0-9A-Fa-f] */\x* 1006\X non-hex digit: [^0-9A-Fa-f] */\X* 1007\o octal digit: [0-7] */\o* 1008\O non-octal digit: [^0-7] */\O* 1009\w word character: [0-9A-Za-z_] */\w* 1010\W non-word character: [^0-9A-Za-z_] */\W* 1011\h head of word character: [A-Za-z_] */\h* 1012\H non-head of word character: [^A-Za-z_] */\H* 1013\a alphabetic character: [A-Za-z] */\a* 1014\A non-alphabetic character: [^A-Za-z] */\A* 1015\l lowercase character: [a-z] */\l* 1016\L non-lowercase character: [^a-z] */\L* 1017\u uppercase character: [A-Z] */\u* 1018\U non-uppercase character: [^A-Z] */\U* 1019 1020 NOTE: Using the atom is faster than the [] form. 1021 1022 NOTE: 'ignorecase', "\c" and "\C" are not used by character classes. 1023 1024 */\_* *E63* */\_i* */\_I* */\_k* */\_K* */\_f* */\_F* 1025 */\_p* */\_P* */\_s* */\_S* */\_d* */\_D* */\_x* */\_X* 1026 */\_o* */\_O* */\_w* */\_W* */\_h* */\_H* */\_a* */\_A* 1027 */\_l* */\_L* */\_u* */\_U* 1028\_x Where "x" is any of the characters above: The character class with 1029 end-of-line added 1030(end of character classes) 1031 1032\e matches <Esc> */\e* 1033\t matches <Tab> */\t* 1034\r matches <CR> */\r* 1035\b matches <BS> */\b* 1036\n matches an end-of-line */\n* 1037 When matching in a string instead of buffer text a literal newline 1038 character is matched. 1039 1040~ matches the last given substitute string */~* */\~* 1041 1042\(\) A pattern enclosed by escaped parentheses. */\(* */\(\)* */\)* 1043 E.g., "\(^a\)" matches 'a' at the start of a line. 1044 *E51* *E54* *E55* *E872* *E873* 1045 1046\1 Matches the same string that was matched by */\1* *E65* 1047 the first sub-expression in \( and \). 1048 Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc. 1049\2 Like "\1", but uses second sub-expression, */\2* 1050 ... */\3* 1051\9 Like "\1", but uses ninth sub-expression. */\9* 1052 Note: The numbering of groups is done based on which "\(" comes first 1053 in the pattern (going left to right), NOT based on what is matched 1054 first. 1055 1056\%(\) A pattern enclosed by escaped parentheses. */\%(\)* */\%(* *E53* 1057 Just like \(\), but without counting it as a sub-expression. This 1058 allows using more groups and it's a little bit faster. 1059 1060x A single character, with no special meaning, matches itself 1061 1062 */\* */\\* 1063\x A backslash followed by a single character, with no special meaning, 1064 is reserved for future expansions 1065 1066[] (with 'nomagic': \[]) */[]* */\[]* */\_[]* */collection* 1067\_[] 1068 A collection. This is a sequence of characters enclosed in brackets. 1069 It matches any single character in the collection. 1070 Example matches ~ 1071 [xyz] any 'x', 'y' or 'z' 1072 [a-zA-Z]$ any alphabetic character at the end of a line 1073 \c[a-z]$ same 1074 [А-яЁё] Russian alphabet (with utf-8 and cp1251) 1075 1076 */[\n]* 1077 With "\_" prepended the collection also includes the end-of-line. 1078 The same can be done by including "\n" in the collection. The 1079 end-of-line is also matched when the collection starts with "^"! Thus 1080 "\_[^ab]" matches the end-of-line and any character but "a" and "b". 1081 This makes it Vi compatible: Without the "\_" or "\n" the collection 1082 does not match an end-of-line. 1083 *E769* 1084 When the ']' is not there Vim will not give an error message but 1085 assume no collection is used. Useful to search for '['. However, you 1086 do get E769 for internal searching. And be aware that in a 1087 `:substitute` command the whole command becomes the pattern. E.g. 1088 ":s/[/x/" searches for "[/x" and replaces it with nothing. It does 1089 not search for "[" and replaces it with "x"! 1090 1091 *E944* *E945* 1092 If the sequence begins with "^", it matches any single character NOT 1093 in the collection: "[^xyz]" matches anything but 'x', 'y' and 'z'. 1094 - If two characters in the sequence are separated by '-', this is 1095 shorthand for the full list of ASCII characters between them. E.g., 1096 "[0-9]" matches any decimal digit. If the starting character exceeds 1097 the ending character, e.g. [c-a], E944 occurs. Non-ASCII characters 1098 can be used, but the character values must not be more than 256 apart 1099 in the old regexp engine. For example, searching by [\u3000-\u4000] 1100 after setting re=1 emits a E945 error. Prepending \%#=2 will fix it. 1101 - A character class expression is evaluated to the set of characters 1102 belonging to that character class. The following character classes 1103 are supported: 1104 Name Func Contents ~ 1105*[:alnum:]* [:alnum:] isalnum ASCII letters and digits 1106*[:alpha:]* [:alpha:] isalpha ASCII letters 1107*[:blank:]* [:blank:] space and tab 1108*[:cntrl:]* [:cntrl:] iscntrl ASCII control characters 1109*[:digit:]* [:digit:] decimal digits '0' to '9' 1110*[:graph:]* [:graph:] isgraph ASCII printable characters excluding 1111 space 1112*[:lower:]* [:lower:] (1) lowercase letters (all letters when 1113 'ignorecase' is used) 1114*[:print:]* [:print:] (2) printable characters including space 1115*[:punct:]* [:punct:] ispunct ASCII punctuation characters 1116*[:space:]* [:space:] whitespace characters: space, tab, CR, 1117 NL, vertical tab, form feed 1118*[:upper:]* [:upper:] (3) uppercase letters (all letters when 1119 'ignorecase' is used) 1120*[:xdigit:]* [:xdigit:] hexadecimal digits: 0-9, a-f, A-F 1121*[:return:]* [:return:] the <CR> character 1122*[:tab:]* [:tab:] the <Tab> character 1123*[:escape:]* [:escape:] the <Esc> character 1124*[:backspace:]* [:backspace:] the <BS> character 1125*[:ident:]* [:ident:] identifier character (same as "\i") 1126*[:keyword:]* [:keyword:] keyword character (same as "\k") 1127*[:fname:]* [:fname:] file name character (same as "\f") 1128 The brackets in character class expressions are additional to the 1129 brackets delimiting a collection. For example, the following is a 1130 plausible pattern for a UNIX filename: "[-./[:alnum:]_~]\+" That is, 1131 a list of at least one character, each of which is either '-', '.', 1132 '/', alphabetic, numeric, '_' or '~'. 1133 These items only work for 8-bit characters, except [:lower:] and 1134 [:upper:] also work for multi-byte characters when using the new 1135 regexp engine. See |two-engines|. In the future these items may 1136 work for multi-byte characters. For now, to get all "alpha" 1137 characters you can use: [[:lower:][:upper:]]. 1138 1139 The "Func" column shows what library function is used. The 1140 implementation depends on the system. Otherwise: 1141 (1) Uses islower() for ASCII and Vim builtin rules for other 1142 characters. 1143 (2) Uses Vim builtin rules 1144 (3) As with (1) but using isupper() 1145 */[[=* *[==]* 1146 - An equivalence class. This means that characters are matched that 1147 have almost the same meaning, e.g., when ignoring accents. This 1148 only works for Unicode, latin1 and latin9. The form is: 1149 [=a=] 1150 */[[.* *[..]* 1151 - A collation element. This currently simply accepts a single 1152 character in the form: 1153 [.a.] 1154 */\]* 1155 - To include a literal ']', '^', '-' or '\' in the collection, put a 1156 backslash before it: "[xyz\]]", "[\^xyz]", "[xy\-z]" and "[xyz\\]". 1157 (Note: POSIX does not support the use of a backslash this way). For 1158 ']' you can also make it the first character (following a possible 1159 "^"): "[]xyz]" or "[^]xyz]". 1160 For '-' you can also make it the first or last character: "[-xyz]", 1161 "[^-xyz]" or "[xyz-]". For '\' you can also let it be followed by 1162 any character that's not in "^]-\bdertnoUux". "[\xyz]" matches '\', 1163 'x', 'y' and 'z'. It's better to use "\\" though, future expansions 1164 may use other characters after '\'. 1165 - Omitting the trailing ] is not considered an error. "[]" works like 1166 "[]]", it matches the ']' character. 1167 - The following translations are accepted when the 'l' flag is not 1168 included in 'cpoptions': 1169 \e <Esc> 1170 \t <Tab> 1171 \r <CR> (NOT end-of-line!) 1172 \b <BS> 1173 \n line break, see above |/[\n]| 1174 \d123 decimal number of character 1175 \o40 octal number of character up to 0377 1176 \x20 hexadecimal number of character up to 0xff 1177 \u20AC hex. number of multibyte character up to 0xffff 1178 \U1234 hex. number of multibyte character up to 0xffffffff 1179 NOTE: The other backslash codes mentioned above do not work inside 1180 []! 1181 - Matching with a collection can be slow, because each character in 1182 the text has to be compared with each character in the collection. 1183 Use one of the other atoms above when possible. Example: "\d" is 1184 much faster than "[0-9]" and matches the same characters. However, 1185 the new |NFA| regexp engine deals with this better than the old one. 1186 1187 */\%[]* *E69* *E70* *E369* 1188\%[] A sequence of optionally matched atoms. This always matches. 1189 It matches as much of the list of atoms it contains as possible. Thus 1190 it stops at the first atom that doesn't match. For example: > 1191 /r\%[ead] 1192< matches "r", "re", "rea" or "read". The longest that matches is used. 1193 To match the Ex command "function", where "fu" is required and 1194 "nction" is optional, this would work: > 1195 /\<fu\%[nction]\> 1196< The end-of-word atom "\>" is used to avoid matching "fu" in "full". 1197 It gets more complicated when the atoms are not ordinary characters. 1198 You don't often have to use it, but it is possible. Example: > 1199 /\<r\%[[eo]ad]\> 1200< Matches the words "r", "re", "ro", "rea", "roa", "read" and "road". 1201 There can be no \(\), \%(\) or \z(\) items inside the [] and \%[] does 1202 not nest. 1203 To include a "[" use "[[]" and for "]" use []]", e.g.,: > 1204 /index\%[[[]0[]]] 1205< matches "index" "index[", "index[0" and "index[0]". 1206 {not available when compiled without the |+syntax| feature} 1207 1208 */\%d* */\%x* */\%o* */\%u* */\%U* *E678* 1209 1210\%d123 Matches the character specified with a decimal number. Must be 1211 followed by a non-digit. 1212\%o40 Matches the character specified with an octal number up to 0377. 1213 Numbers below 040 must be followed by a non-octal digit or a non-digit. 1214\%x2a Matches the character specified with up to two hexadecimal characters. 1215\%u20AC Matches the character specified with up to four hexadecimal 1216 characters. 1217\%U1234abcd Matches the character specified with up to eight hexadecimal 1218 characters, up to 0x7fffffff 1219 1220============================================================================== 12217. Ignoring case in a pattern */ignorecase* 1222 1223If the 'ignorecase' option is on, the case of normal letters is ignored. 1224'smartcase' can be set to ignore case when the pattern contains lowercase 1225letters only. 1226 */\c* */\C* 1227When "\c" appears anywhere in the pattern, the whole pattern is handled like 1228'ignorecase' is on. The actual value of 'ignorecase' and 'smartcase' is 1229ignored. "\C" does the opposite: Force matching case for the whole pattern. 1230{only Vim supports \c and \C} 1231Note that 'ignorecase', "\c" and "\C" are not used for the character classes. 1232 1233Examples: 1234 pattern 'ignorecase' 'smartcase' matches ~ 1235 foo off - foo 1236 foo on - foo Foo FOO 1237 Foo on off foo Foo FOO 1238 Foo on on Foo 1239 \cfoo - - foo Foo FOO 1240 foo\C - - foo 1241 1242Technical detail: *NL-used-for-Nul* 1243<Nul> characters in the file are stored as <NL> in memory. In the display 1244they are shown as "^@". The translation is done when reading and writing 1245files. To match a <Nul> with a search pattern you can just enter CTRL-@ or 1246"CTRL-V 000". This is probably just what you expect. Internally the 1247character is replaced with a <NL> in the search pattern. What is unusual is 1248that typing CTRL-V CTRL-J also inserts a <NL>, thus also searches for a <Nul> 1249in the file. 1250 1251 *CR-used-for-NL* 1252When 'fileformat' is "mac", <NL> characters in the file are stored as <CR> 1253characters internally. In the text they are shown as "^J". Otherwise this 1254works similar to the usage of <NL> for a <Nul>. 1255 1256When working with expression evaluation, a <NL> character in the pattern 1257matches a <NL> in the string. The use of "\n" (backslash n) to match a <NL> 1258doesn't work there, it only works to match text in the buffer. 1259 1260 *pattern-multi-byte* 1261Patterns will also work with multi-byte characters, mostly as you would 1262expect. But invalid bytes may cause trouble, a pattern with an invalid byte 1263will probably never match. 1264 1265============================================================================== 12668. Composing characters *patterns-composing* 1267 1268 */\Z* 1269When "\Z" appears anywhere in the pattern, all composing characters are 1270ignored. Thus only the base characters need to match, the composing 1271characters may be different and the number of composing characters may differ. 1272Only relevant when 'encoding' is "utf-8". 1273Exception: If the pattern starts with one or more composing characters, these 1274must match. 1275 */\%C* 1276Use "\%C" to skip any composing characters. For example, the pattern "a" does 1277not match in "càt" (where the a has the composing character 0x0300), but 1278"a\%C" does. Note that this does not match "cát" (where the á is character 12790xe1, it does not have a compositing character). It does match "cat" (where 1280the a is just an a). 1281 1282When a composing character appears at the start of the pattern of after an 1283item that doesn't include the composing character, a match is found at any 1284character that includes this composing character. 1285 1286When using a dot and a composing character, this works the same as the 1287composing character by itself, except that it doesn't matter what comes before 1288this. 1289 1290The order of composing characters does not matter. Also, the text may have 1291more composing characters than the pattern, it still matches. But all 1292composing characters in the pattern must be found in the text. 1293 1294Suppose B is a base character and x and y are composing characters: 1295 pattern text match ~ 1296 Bxy Bxy yes (perfect match) 1297 Bxy Byx yes (order ignored) 1298 Bxy By no (x missing) 1299 Bxy Bx no (y missing) 1300 Bx Bx yes (perfect match) 1301 Bx By no (x missing) 1302 Bx Bxy yes (extra y ignored) 1303 Bx Byx yes (extra y ignored) 1304 1305============================================================================== 13069. Compare with Perl patterns *perl-patterns* 1307 1308Vim's regexes are most similar to Perl's, in terms of what you can do. The 1309difference between them is mostly just notation; here's a summary of where 1310they differ: 1311 1312Capability in Vimspeak in Perlspeak ~ 1313---------------------------------------------------------------- 1314force case insensitivity \c (?i) 1315force case sensitivity \C (?-i) 1316backref-less grouping \%(atom\) (?:atom) 1317conservative quantifiers \{-n,m} *?, +?, ??, {}? 13180-width match atom\@= (?=atom) 13190-width non-match atom\@! (?!atom) 13200-width preceding match atom\@<= (?<=atom) 13210-width preceding non-match atom\@<! (?<!atom) 1322match without retry atom\@> (?>atom) 1323 1324Vim and Perl handle newline characters inside a string a bit differently: 1325 1326In Perl, ^ and $ only match at the very beginning and end of the text, 1327by default, but you can set the 'm' flag, which lets them match at 1328embedded newlines as well. You can also set the 's' flag, which causes 1329a . to match newlines as well. (Both these flags can be changed inside 1330a pattern using the same syntax used for the i flag above, BTW.) 1331 1332On the other hand, Vim's ^ and $ always match at embedded newlines, and 1333you get two separate atoms, \%^ and \%$, which only match at the very 1334start and end of the text, respectively. Vim solves the second problem 1335by giving you the \_ "modifier": put it in front of a . or a character 1336class, and they will match newlines as well. 1337 1338Finally, these constructs are unique to Perl: 1339- execution of arbitrary code in the regex: (?{perl code}) 1340- conditional expressions: (?(condition)true-expr|false-expr) 1341 1342...and these are unique to Vim: 1343- changing the magic-ness of a pattern: \v \V \m \M 1344 (very useful for avoiding backslashitis) 1345- sequence of optionally matching atoms: \%[atoms] 1346- \& (which is to \| what "and" is to "or"; it forces several branches 1347 to match at one spot) 1348- matching lines/columns by number: \%5l \%5c \%5v 1349- setting the start and end of the match: \zs \ze 1350 1351============================================================================== 135210. Highlighting matches *match-highlight* 1353 1354 *:mat* *:match* 1355:mat[ch] {group} /{pattern}/ 1356 Define a pattern to highlight in the current window. It will 1357 be highlighted with {group}. Example: > 1358 :highlight MyGroup ctermbg=green guibg=green 1359 :match MyGroup /TODO/ 1360< Instead of // any character can be used to mark the start and 1361 end of the {pattern}. Watch out for using special characters, 1362 such as '"' and '|'. 1363 1364 {group} must exist at the moment this command is executed. 1365 1366 The {group} highlighting still applies when a character is 1367 to be highlighted for 'hlsearch', as the highlighting for 1368 matches is given higher priority than that of 'hlsearch'. 1369 Syntax highlighting (see 'syntax') is also overruled by 1370 matches. 1371 1372 Note that highlighting the last used search pattern with 1373 'hlsearch' is used in all windows, while the pattern defined 1374 with ":match" only exists in the current window. It is kept 1375 when switching to another buffer. 1376 1377 'ignorecase' does not apply, use |/\c| in the pattern to 1378 ignore case. Otherwise case is not ignored. 1379 1380 'redrawtime' defines the maximum time searched for pattern 1381 matches. 1382 1383 When matching end-of-line and Vim redraws only part of the 1384 display you may get unexpected results. That is because Vim 1385 looks for a match in the line where redrawing starts. 1386 1387 Also see |matcharg()| and |getmatches()|. The former returns 1388 the highlight group and pattern of a previous |:match| 1389 command. The latter returns a list with highlight groups and 1390 patterns defined by both |matchadd()| and |:match|. 1391 1392 Highlighting matches using |:match| are limited to three 1393 matches (aside from |:match|, |:2match| and |:3match| are 1394 available). |matchadd()| does not have this limitation and in 1395 addition makes it possible to prioritize matches. 1396 1397 Another example, which highlights all characters in virtual 1398 column 72 and more: > 1399 :highlight rightMargin term=bold ctermfg=blue guifg=blue 1400 :match rightMargin /.\%>72v/ 1401< To highlight all character that are in virtual column 7: > 1402 :highlight col8 ctermbg=grey guibg=grey 1403 :match col8 /\%<8v.\%>7v/ 1404< Note the use of two items to also match a character that 1405 occupies more than one virtual column, such as a TAB. 1406 1407:mat[ch] 1408:mat[ch] none 1409 Clear a previously defined match pattern. 1410 1411 1412:2mat[ch] {group} /{pattern}/ *:2match* 1413:2mat[ch] 1414:2mat[ch] none 1415:3mat[ch] {group} /{pattern}/ *:3match* 1416:3mat[ch] 1417:3mat[ch] none 1418 Just like |:match| above, but set a separate match. Thus 1419 there can be three matches active at the same time. The match 1420 with the lowest number has priority if several match at the 1421 same position. 1422 The ":3match" command is used by the |matchparen| plugin. You 1423 are suggested to use ":match" for manual matching and 1424 ":2match" for another plugin. 1425 1426 1427 vim:tw=78:ts=8:noet:ft=help:norl: 1428