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