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