Mercurial > vim
annotate runtime/doc/usr_03.txt @ 18486:9d887cad7315
Added tag v8.1.2237 for changeset 63ee3c2b140fe1b4801389872a8e47aec19d028b
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Thu, 31 Oct 2019 20:00:04 +0100 |
| parents | 5c5908e81e93 |
| children | 99586852c2db |
| rev | line source |
|---|---|
| 13963 | 1 *usr_03.txt* For Vim version 8.1. Last change: 2017 Jul 21 |
| 7 | 2 |
| 3 VIM USER MANUAL - by Bram Moolenaar | |
| 4 | |
| 5 Moving around | |
| 6 | |
| 7 | |
| 8 Before you can insert or delete text the cursor has to be moved to the right | |
| 9 place. Vim has a large number of commands to position the cursor. This | |
| 10 chapter shows you how to use the most important ones. You can find a list of | |
| 11 these commands below |Q_lr|. | |
| 12 | |
| 13 |03.1| Word movement | |
| 14 |03.2| Moving to the start or end of a line | |
| 15 |03.3| Moving to a character | |
| 164 | 16 |03.4| Matching a parenthesis |
| 7 | 17 |03.5| Moving to a specific line |
| 18 |03.6| Telling where you are | |
| 19 |03.7| Scrolling around | |
| 20 |03.8| Simple searches | |
| 21 |03.9| Simple search patterns | |
| 22 |03.10| Using marks | |
| 23 | |
| 24 Next chapter: |usr_04.txt| Making small changes | |
| 25 Previous chapter: |usr_02.txt| The first steps in Vim | |
| 26 Table of contents: |usr_toc.txt| | |
| 27 | |
| 28 ============================================================================== | |
| 29 *03.1* Word movement | |
| 30 | |
| 31 To move the cursor forward one word, use the "w" command. Like most Vim | |
| 32 commands, you can use a numeric prefix to move past multiple words. For | |
| 33 example, "3w" moves three words. This figure shows how it works: | |
| 34 | |
| 35 This is a line with example text ~ | |
| 36 --->-->->-----------------> | |
| 37 w w w 3w | |
| 38 | |
| 39 Notice that "w" moves to the start of the next word if it already is at the | |
| 40 start of a word. | |
| 41 The "b" command moves backward to the start of the previous word: | |
| 42 | |
| 43 This is a line with example text ~ | |
| 44 <----<--<-<---------<--- | |
| 45 b b b 2b b | |
| 46 | |
| 47 There is also the "e" command that moves to the next end of a word and "ge", | |
| 48 which moves to the previous end of a word: | |
| 49 | |
| 50 This is a line with example text ~ | |
| 51 <- <--- -----> ----> | |
| 52 ge ge e e | |
| 53 | |
| 54 If you are at the last word of a line, the "w" command will take you to the | |
| 55 first word in the next line. Thus you can use this to move through a | |
| 56 paragraph, much faster than using "l". "b" does the same in the other | |
| 57 direction. | |
| 58 | |
| 59 A word ends at a non-word character, such as a ".", "-" or ")". To change | |
|
7384
aea5ebf352c4
commit https://github.com/vim/vim/commit/256972a9849b5d575b62a6a71be5b6934b5b0e8b
Christian Brabandt <cb@256bit.org>
parents:
6530
diff
changeset
|
60 what Vim considers to be a word, see the 'iskeyword' option. If you try this |
|
aea5ebf352c4
commit https://github.com/vim/vim/commit/256972a9849b5d575b62a6a71be5b6934b5b0e8b
Christian Brabandt <cb@256bit.org>
parents:
6530
diff
changeset
|
61 out in the help directly, 'iskeyword' needs to be reset for the examples to |
|
aea5ebf352c4
commit https://github.com/vim/vim/commit/256972a9849b5d575b62a6a71be5b6934b5b0e8b
Christian Brabandt <cb@256bit.org>
parents:
6530
diff
changeset
|
62 work: > |
|
aea5ebf352c4
commit https://github.com/vim/vim/commit/256972a9849b5d575b62a6a71be5b6934b5b0e8b
Christian Brabandt <cb@256bit.org>
parents:
6530
diff
changeset
|
63 :set iskeyword& |
|
aea5ebf352c4
commit https://github.com/vim/vim/commit/256972a9849b5d575b62a6a71be5b6934b5b0e8b
Christian Brabandt <cb@256bit.org>
parents:
6530
diff
changeset
|
64 It is also possible to move by white-space separated WORDs. This is not a |
| 7 | 65 word in the normal sense, that's why the uppercase is used. The commands for |
| 66 moving by WORDs are also uppercase, as this figure shows: | |
| 67 | |
| 68 ge b w e | |
| 69 <- <- ---> ---> | |
| 70 This is-a line, with special/separated/words (and some more). ~ | |
| 71 <----- <----- --------------------> -----> | |
| 72 gE B W E | |
| 73 | |
| 74 With this mix of lowercase and uppercase commands, you can quickly move | |
| 75 forward and backward through a paragraph. | |
| 76 | |
| 77 ============================================================================== | |
| 78 *03.2* Moving to the start or end of a line | |
| 79 | |
| 80 The "$" command moves the cursor to the end of a line. If your keyboard has | |
| 81 an <End> key it will do the same thing. | |
| 82 | |
| 83 The "^" command moves to the first non-blank character of the line. The "0" | |
| 84 command (zero) moves to the very first character of the line. The <Home> key | |
| 85 does the same thing. In a picture: | |
| 86 | |
| 87 ^ | |
| 88 <------------ | |
| 89 .....This is a line with example text ~ | |
| 90 <----------------- ---------------> | |
| 91 0 $ | |
| 92 | |
| 93 (the "....." indicates blanks here) | |
| 94 | |
| 95 The "$" command takes a count, like most movement commands. But moving to | |
| 96 the end of the line several times doesn't make sense. Therefore it causes the | |
| 97 editor to move to the end of another line. For example, "1$" moves you to | |
| 98 the end of the first line (the one you're on), "2$" to the end of the next | |
| 99 line, and so on. | |
| 100 The "0" command doesn't take a count argument, because the "0" would be | |
| 101 part of the count. Unexpectedly, using a count with "^" doesn't have any | |
| 102 effect. | |
| 103 | |
| 104 ============================================================================== | |
| 105 *03.3* Moving to a character | |
| 106 | |
| 107 One of the most useful movement commands is the single-character search | |
| 108 command. The command "fx" searches forward in the line for the single | |
| 109 character x. Hint: "f" stands for "Find". | |
| 110 For example, you are at the beginning of the following line. Suppose you | |
| 111 want to go to the h of human. Just execute the command "fh" and the cursor | |
| 112 will be positioned over the h: | |
| 113 | |
| 114 To err is human. To really foul up you need a computer. ~ | |
| 115 ---------->---------------> | |
| 116 fh fy | |
| 117 | |
| 118 This also shows that the command "fy" moves to the end of the word really. | |
| 119 You can specify a count; therefore, you can go to the "l" of "foul" with | |
| 120 "3fl": | |
| 121 | |
| 122 To err is human. To really foul up you need a computer. ~ | |
| 123 ---------------------> | |
| 124 3fl | |
| 125 | |
| 126 The "F" command searches to the left: | |
| 127 | |
| 128 To err is human. To really foul up you need a computer. ~ | |
| 129 <--------------------- | |
| 130 Fh | |
| 131 | |
| 132 The "tx" command works like the "fx" command, except it stops one character | |
| 133 before the searched character. Hint: "t" stands for "To". The backward | |
| 134 version of this command is "Tx". | |
| 135 | |
| 136 To err is human. To really foul up you need a computer. ~ | |
| 137 <------------ -------------> | |
| 138 Th tn | |
| 139 | |
| 140 These four commands can be repeated with ";". "," repeats in the other | |
| 141 direction. The cursor is never moved to another line. Not even when the | |
| 142 sentence continues. | |
| 143 | |
| 144 Sometimes you will start a search, only to realize that you have typed the | |
| 145 wrong command. You type "f" to search backward, for example, only to realize | |
| 146 that you really meant "F". To abort a search, press <Esc>. So "f<Esc>" is an | |
| 147 aborted forward search and doesn't do anything. Note: <Esc> cancels most | |
| 148 operations, not just searches. | |
| 149 | |
| 150 ============================================================================== | |
| 164 | 151 *03.4* Matching a parenthesis |
| 7 | 152 |
| 153 When writing a program you often end up with nested () constructs. Then the | |
| 154 "%" command is very handy: It moves to the matching paren. If the cursor is | |
| 155 on a "(" it will move to the matching ")". If it's on a ")" it will move to | |
| 156 the matching "(". | |
| 157 | |
| 158 % | |
| 159 <-----> | |
| 160 if (a == (b * c) / d) ~ | |
| 161 <----------------> | |
| 162 % | |
| 163 | |
| 164 This also works for [] and {} pairs. (This can be defined with the | |
| 165 'matchpairs' option.) | |
| 166 | |
| 167 When the cursor is not on a useful character, "%" will search forward to find | |
| 168 one. Thus if the cursor is at the start of the line of the previous example, | |
| 169 "%" will search forward and find the first "(". Then it moves to its match: | |
| 170 | |
| 171 if (a == (b * c) / d) ~ | |
| 172 ---+----------------> | |
| 173 % | |
| 174 | |
| 175 ============================================================================== | |
| 176 *03.5* Moving to a specific line | |
| 177 | |
| 178 If you are a C or C++ programmer, you are familiar with error messages such as | |
| 179 the following: | |
| 180 | |
| 181 prog.c:33: j undeclared (first use in this function) ~ | |
| 182 | |
| 183 This tells you that you might want to fix something on line 33. So how do you | |
| 184 find line 33? One way is to do "9999k" to go to the top of the file and "32j" | |
|
10895
c391bfbdb452
Updated runtime files.
Christian Brabandt <cb@256bit.org>
parents:
10198
diff
changeset
|
185 to go down thirty-two lines. It is not a good way, but it works. A much |
| 7 | 186 better way of doing things is to use the "G" command. With a count, this |
| 187 command positions you at the given line number. For example, "33G" puts you | |
| 188 on line 33. (For a better way of going through a compiler's error list, see | |
| 189 |usr_30.txt|, for information on the :make command.) | |
| 190 With no argument, "G" positions you at the end of the file. A quick way to | |
| 191 go to the start of a file use "gg". "1G" will do the same, but is a tiny bit | |
| 192 more typing. | |
| 193 | |
| 194 | first line of a file ^ | |
| 195 | text text text text | | |
| 196 | text text text text | gg | |
| 197 7G | text text text text | | |
| 198 | text text text text | |
| 199 | text text text text | |
| 200 V text text text text | | |
| 201 text text text text | G | |
| 202 text text text text | | |
| 203 last line of a file V | |
| 204 | |
| 205 Another way to move to a line is using the "%" command with a count. For | |
| 206 example "50%" moves you to halfway the file. "90%" goes to near the end. | |
| 207 | |
| 208 The previous assumes that you want to move to a line in the file, no matter if | |
| 209 it's currently visible or not. What if you want to move to one of the lines | |
| 210 you can see? This figure shows the three commands you can use: | |
| 211 | |
| 212 +---------------------------+ | |
| 213 H --> | text sample text | | |
| 214 | sample text | | |
| 215 | text sample text | | |
| 216 | sample text | | |
| 217 M --> | text sample text | | |
| 218 | sample text | | |
| 219 | text sample text | | |
| 220 | sample text | | |
| 221 L --> | text sample text | | |
| 222 +---------------------------+ | |
| 223 | |
| 224 Hints: "H" stands for Home, "M" for Middle and "L" for Last. | |
| 225 | |
| 226 ============================================================================== | |
| 227 *03.6* Telling where you are | |
| 228 | |
| 229 To see where you are in a file, there are three ways: | |
| 230 | |
| 231 1. Use the CTRL-G command. You get a message like this (assuming the 'ruler' | |
| 232 option is off): | |
| 233 | |
| 234 "usr_03.txt" line 233 of 650 --35%-- col 45-52 ~ | |
| 235 | |
| 236 This shows the name of the file you are editing, the line number where the | |
| 237 cursor is, the total number of lines, the percentage of the way through | |
| 238 the file and the column of the cursor. | |
| 239 Sometimes you will see a split column number. For example, "col 2-9". | |
| 240 This indicates that the cursor is positioned on the second character, but | |
| 241 because character one is a tab, occupying eight spaces worth of columns, | |
| 242 the screen column is 9. | |
| 243 | |
| 244 2. Set the 'number' option. This will display a line number in front of | |
| 245 every line: > | |
| 246 | |
| 247 :set number | |
| 248 < | |
| 249 To switch this off again: > | |
| 250 | |
| 251 :set nonumber | |
| 252 < | |
| 253 Since 'number' is a boolean option, prepending "no" to its name has the | |
| 254 effect of switching it off. A boolean option has only these two values, | |
| 255 it is either on or off. | |
| 256 Vim has many options. Besides the boolean ones there are options with | |
| 257 a numerical value and string options. You will see examples of this where | |
| 258 they are used. | |
| 259 | |
| 260 3. Set the 'ruler' option. This will display the cursor position in the | |
| 261 lower right corner of the Vim window: > | |
| 262 | |
| 263 :set ruler | |
| 264 | |
| 265 Using the 'ruler' option has the advantage that it doesn't take much room, | |
| 266 thus there is more space for your text. | |
| 267 | |
| 268 ============================================================================== | |
| 269 *03.7* Scrolling around | |
| 270 | |
| 271 The CTRL-U command scrolls down half a screen of text. Think of looking | |
| 272 through a viewing window at the text and moving this window up by half the | |
| 273 height of the window. Thus the window moves up over the text, which is | |
| 274 backward in the file. Don't worry if you have a little trouble remembering | |
| 275 which end is up. Most users have the same problem. | |
| 276 The CTRL-D command moves the viewing window down half a screen in the file, | |
| 277 thus scrolls the text up half a screen. | |
| 278 | |
| 279 +----------------+ | |
| 280 | some text | | |
| 281 | some text | | |
| 282 | some text | | |
| 283 +---------------+ | some text | | |
| 284 | some text | CTRL-U --> | | | |
| 285 | | | 123456 | | |
| 286 | 123456 | +----------------+ | |
| 287 | 7890 | | |
| 288 | | +----------------+ | |
| 289 | example | CTRL-D --> | 7890 | | |
| 290 +---------------+ | | | |
| 291 | example | | |
| 292 | example | | |
| 293 | example | | |
| 294 | example | | |
| 295 +----------------+ | |
| 296 | |
| 297 To scroll one line at a time use CTRL-E (scroll up) and CTRL-Y (scroll down). | |
| 298 Think of CTRL-E to give you one line Extra. (If you use MS-Windows compatible | |
| 299 key mappings CTRL-Y will redo a change instead of scroll.) | |
| 300 | |
| 301 To scroll forward by a whole screen (except for two lines) use CTRL-F. The | |
| 302 other way is backward, CTRL-B is the command to use. Fortunately CTRL-F is | |
| 303 Forward and CTRL-B is Backward, that's easy to remember. | |
| 304 | |
| 305 A common issue is that after moving down many lines with "j" your cursor is at | |
| 306 the bottom of the screen. You would like to see the context of the line with | |
| 307 the cursor. That's done with the "zz" command. | |
| 308 | |
| 309 +------------------+ +------------------+ | |
| 310 | some text | | some text | | |
| 311 | some text | | some text | | |
| 312 | some text | | some text | | |
| 313 | some text | zz --> | line with cursor | | |
| 314 | some text | | some text | | |
| 315 | some text | | some text | | |
| 316 | line with cursor | | some text | | |
| 317 +------------------+ +------------------+ | |
| 318 | |
| 319 The "zt" command puts the cursor line at the top, "zb" at the bottom. There | |
| 320 are a few more scrolling commands, see |Q_sc|. To always keep a few lines of | |
| 321 context around the cursor, use the 'scrolloff' option. | |
| 322 | |
| 323 ============================================================================== | |
| 324 *03.8* Simple searches | |
| 325 | |
| 326 To search for a string, use the "/string" command. To find the word include, | |
| 327 for example, use the command: > | |
| 328 | |
| 329 /include | |
| 330 | |
| 331 You will notice that when you type the "/" the cursor jumps to the last line | |
| 332 of the Vim window, like with colon commands. That is where you type the word. | |
| 333 You can press the backspace key (backarrow or <BS>) to make corrections. Use | |
| 334 the <Left> and <Right> cursor keys when necessary. | |
| 335 Pressing <Enter> executes the command. | |
| 336 | |
| 337 Note: | |
| 236 | 338 The characters .*[]^%/\?~$ have special meanings. If you want to use |
| 7 | 339 them in a search you must put a \ in front of them. See below. |
| 340 | |
| 341 To find the next occurrence of the same string use the "n" command. Use this | |
| 342 to find the first #include after the cursor: > | |
| 343 | |
| 344 /#include | |
| 345 | |
| 346 And then type "n" several times. You will move to each #include in the text. | |
| 347 You can also use a count if you know which match you want. Thus "3n" finds | |
| 348 the third match. Using a count with "/" doesn't work. | |
| 349 | |
| 350 The "?" command works like "/" but searches backwards: > | |
| 351 | |
| 352 ?word | |
| 353 | |
| 354 The "N" command repeats the last search the opposite direction. Thus using | |
|
11763
21f3930dfe6e
Documentation updates.
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
355 "N" after a "/" command searches backwards, using "N" after "?" searches |
| 7 | 356 forward. |
| 357 | |
| 358 | |
| 359 IGNORING CASE | |
| 360 | |
| 361 Normally you have to type exactly what you want to find. If you don't care | |
| 362 about upper or lowercase in a word, set the 'ignorecase' option: > | |
| 363 | |
| 364 :set ignorecase | |
| 365 | |
| 366 If you now search for "word", it will also match "Word" and "WORD". To match | |
| 367 case again: > | |
| 368 | |
| 369 :set noignorecase | |
| 370 | |
| 371 | |
| 372 HISTORY | |
| 373 | |
| 374 Suppose you do three searches: > | |
| 375 | |
| 376 /one | |
| 377 /two | |
| 378 /three | |
| 379 | |
| 380 Now let's start searching by typing a simple "/" without pressing <Enter>. If | |
| 381 you press <Up> (the cursor key), Vim puts "/three" on the command line. | |
| 382 Pressing <Enter> at this point searches for three. If you do not press | |
| 383 <Enter>, but press <Up> instead, Vim changes the prompt to "/two". Another | |
| 384 press of <Up> moves you to "/one". | |
| 385 You can also use the <Down> cursor key to move through the history of | |
| 386 search commands in the other direction. | |
| 387 | |
| 388 If you know what a previously used pattern starts with, and you want to use it | |
| 389 again, type that character before pressing <Up>. With the previous example, | |
| 390 you can type "/o<Up>" and Vim will put "/one" on the command line. | |
| 391 | |
| 392 The commands starting with ":" also have a history. That allows you to recall | |
| 393 a previous command and execute it again. These two histories are separate. | |
| 394 | |
| 395 | |
| 396 SEARCHING FOR A WORD IN THE TEXT | |
| 397 | |
| 398 Suppose you see the word "TheLongFunctionName" in the text and you want to | |
| 399 find the next occurrence of it. You could type "/TheLongFunctionName", but | |
| 400 that's a lot of typing. And when you make a mistake Vim won't find it. | |
| 401 There is an easier way: Position the cursor on the word and use the "*" | |
| 402 command. Vim will grab the word under the cursor and use it as the search | |
| 403 string. | |
| 404 The "#" command does the same in the other direction. You can prepend a | |
| 405 count: "3*" searches for the third occurrence of the word under the cursor. | |
| 406 | |
| 407 | |
| 408 SEARCHING FOR WHOLE WORDS | |
| 409 | |
| 410 If you type "/the" it will also match "there". To only find words that end | |
| 411 in "the" use: > | |
| 412 | |
| 413 /the\> | |
| 414 | |
| 415 The "\>" item is a special marker that only matches at the end of a word. | |
|
7557
502ca0a62fd8
commit https://github.com/vim/vim/commit/acb4f221c715a333f4c49a2235a8006c6ac6e4d5
Christian Brabandt <cb@256bit.org>
parents:
7384
diff
changeset
|
416 Similarly "\<" only matches at the beginning of a word. Thus to search for |
|
502ca0a62fd8
commit https://github.com/vim/vim/commit/acb4f221c715a333f4c49a2235a8006c6ac6e4d5
Christian Brabandt <cb@256bit.org>
parents:
7384
diff
changeset
|
417 the word "the" only: > |
| 7 | 418 |
| 419 /\<the\> | |
| 420 | |
| 421 This does not match "there" or "soothe". Notice that the "*" and "#" commands | |
| 422 use these start-of-word and end-of-word markers to only find whole words (you | |
| 423 can use "g*" and "g#" to match partial words). | |
| 424 | |
| 425 | |
| 426 HIGHLIGHTING MATCHES | |
| 427 | |
| 428 While editing a program you see a variable called "nr". You want to check | |
| 429 where it's used. You could move the cursor to "nr" and use the "*" command | |
| 430 and press "n" to go along all the matches. | |
| 431 There is another way. Type this command: > | |
| 432 | |
| 433 :set hlsearch | |
| 434 | |
| 435 If you now search for "nr", Vim will highlight all matches. That is a very | |
| 436 good way to see where the variable is used, without the need to type commands. | |
| 437 To switch this off: > | |
| 438 | |
| 439 :set nohlsearch | |
| 440 | |
| 441 Then you need to switch it on again if you want to use it for the next search | |
| 442 command. If you only want to remove the highlighting, use this command: > | |
| 443 | |
| 444 :nohlsearch | |
| 445 | |
| 446 This doesn't reset the option. Instead, it disables the highlighting. As | |
| 447 soon as you execute a search command, the highlighting will be used again. | |
| 448 Also for the "n" and "N" commands. | |
| 449 | |
| 450 | |
| 451 TUNING SEARCHES | |
| 452 | |
| 453 There are a few options that change how searching works. These are the | |
| 454 essential ones: | |
| 455 > | |
| 456 :set incsearch | |
| 457 | |
| 458 This makes Vim display the match for the string while you are still typing it. | |
| 459 Use this to check if the right match will be found. Then press <Enter> to | |
| 460 really jump to that location. Or type more to change the search string. | |
| 461 > | |
| 462 :set nowrapscan | |
| 463 | |
| 464 This stops the search at the end of the file. Or, when you are searching | |
| 465 backwards, at the start of the file. The 'wrapscan' option is on by default, | |
| 466 thus searching wraps around the end of the file. | |
| 467 | |
| 468 | |
| 469 INTERMEZZO | |
| 470 | |
| 471 If you like one of the options mentioned before, and set it each time you use | |
| 472 Vim, you can put the command in your Vim startup file. | |
| 473 Edit the file, as mentioned at |not-compatible|. Or use this command to | |
| 474 find out where it is: > | |
| 475 | |
| 476 :scriptnames | |
| 477 | |
| 478 Edit the file, for example with: > | |
| 479 | |
| 480 :edit ~/.vimrc | |
| 481 | |
| 482 Then add a line with the command to set the option, just like you typed it in | |
| 483 Vim. Example: > | |
| 484 | |
| 485 Go:set hlsearch<Esc> | |
| 486 | |
| 487 "G" moves to the end of the file. "o" starts a new line, where you type the | |
| 488 ":set" command. You end insert mode with <Esc>. Then write the file: > | |
| 489 | |
| 490 ZZ | |
| 491 | |
| 492 If you now start Vim again, the 'hlsearch' option will already be set. | |
| 493 | |
| 494 ============================================================================== | |
| 495 *03.9* Simple search patterns | |
| 496 | |
| 497 The Vim editor uses regular expressions to specify what to search for. | |
| 498 Regular expressions are an extremely powerful and compact way to specify a | |
| 499 search pattern. Unfortunately, this power comes at a price, because regular | |
| 500 expressions are a bit tricky to specify. | |
| 501 In this section we mention only a few essential ones. More about search | |
| 502 patterns and commands in chapter 27 |usr_27.txt|. You can find the full | |
| 503 explanation here: |pattern|. | |
| 504 | |
| 505 | |
| 506 BEGINNING AND END OF A LINE | |
| 507 | |
| 508 The ^ character matches the beginning of a line. On an English-US keyboard | |
| 509 you find it above the 6. The pattern "include" matches the word include | |
| 510 anywhere on the line. But the pattern "^include" matches the word include | |
| 511 only if it is at the beginning of a line. | |
| 512 The $ character matches the end of a line. Therefore, "was$" matches the | |
| 513 word was only if it is at the end of a line. | |
| 514 | |
|
11763
21f3930dfe6e
Documentation updates.
Christian Brabandt <cb@256bit.org>
parents:
10895
diff
changeset
|
515 Let's mark the places where "/the" matches in this example line with "x"s: |
| 7 | 516 |
| 517 the solder holding one of the chips melted and the ~ | |
| 518 xxx xxx xxx | |
| 519 | |
| 520 Using "/the$" we find this match: | |
| 521 | |
| 522 the solder holding one of the chips melted and the ~ | |
| 523 xxx | |
| 524 | |
| 525 And with "/^the" we find this one: | |
| 526 the solder holding one of the chips melted and the ~ | |
| 527 xxx | |
| 528 | |
| 529 You can try searching with "/^the$", it will only match a single line | |
| 530 consisting of "the". White space does matter here, thus if a line contains a | |
| 531 space after the word, like "the ", the pattern will not match. | |
| 532 | |
| 533 | |
| 534 MATCHING ANY SINGLE CHARACTER | |
| 535 | |
| 536 The . (dot) character matches any existing character. For example, the | |
| 537 pattern "c.m" matches a string whose first character is a c, whose second | |
| 6530 | 538 character is anything, and whose third character is m. Example: |
| 7 | 539 |
| 540 We use a computer that became the cummin winter. ~ | |
| 541 xxx xxx xxx | |
| 542 | |
| 543 | |
| 544 MATCHING SPECIAL CHARACTERS | |
| 545 | |
| 546 If you really want to match a dot, you must avoid its special meaning by | |
| 547 putting a backslash before it. | |
| 548 If you search for "ter.", you will find these matches: | |
| 549 | |
| 550 We use a computer that became the cummin winter. ~ | |
| 551 xxxx xxxx | |
| 552 | |
| 553 Searching for "ter\." only finds the second match. | |
| 554 | |
| 555 ============================================================================== | |
| 556 *03.10* Using marks | |
| 557 | |
| 558 When you make a jump to a position with the "G" command, Vim remembers the | |
| 559 position from before this jump. This position is called a mark. To go back | |
| 560 where you came from, use this command: > | |
| 561 | |
| 562 `` | |
| 563 | |
| 564 This ` is a backtick or open single-quote character. | |
| 565 If you use the same command a second time you will jump back again. That's | |
| 566 because the ` command is a jump itself, and the position from before this jump | |
| 567 is remembered. | |
| 568 | |
| 569 Generally, every time you do a command that can move the cursor further than | |
| 570 within the same line, this is called a jump. This includes the search | |
| 571 commands "/" and "n" (it doesn't matter how far away the match is). But not | |
| 572 the character searches with "fx" and "tx" or the word movements "w" and "e". | |
| 573 Also, "j" and "k" are not considered to be a jump. Even when you use a | |
| 574 count to make them move the cursor quite a long way away. | |
| 575 | |
| 576 The `` command jumps back and forth, between two points. The CTRL-O command | |
| 577 jumps to older positions (Hint: O for older). CTRL-I then jumps back to newer | |
| 578 positions (Hint: I is just next to O on the keyboard). Consider this sequence | |
| 579 of commands: > | |
| 580 | |
| 581 33G | |
| 582 /^The | |
| 583 CTRL-O | |
| 584 | |
| 585 You first jump to line 33, then search for a line that starts with "The". | |
| 586 Then with CTRL-O you jump back to line 33. Another CTRL-O takes you back to | |
| 587 where you started. If you now use CTRL-I you jump to line 33 again. And | |
| 588 to the match for "The" with another CTRL-I. | |
| 589 | |
| 590 | |
| 591 | example text ^ | | |
| 592 33G | example text | CTRL-O | CTRL-I | |
| 593 | example text | | | |
| 594 V line 33 text ^ V | |
| 595 | example text | | | |
| 596 /^The | example text | CTRL-O | CTRL-I | |
| 597 V There you are | V | |
| 598 example text | |
| 599 | |
| 600 Note: | |
| 601 CTRL-I is the same as <Tab>. | |
| 602 | |
| 603 The ":jumps" command gives a list of positions you jumped to. The entry which | |
| 604 you used last is marked with a ">". | |
| 605 | |
| 606 | |
| 255 | 607 NAMED MARKS *bookmark* |
| 7 | 608 |
| 609 Vim enables you to place your own marks in the text. The command "ma" marks | |
| 610 the place under the cursor as mark a. You can place 26 marks (a through z) in | |
| 611 your text. You can't see them, it's just a position that Vim remembers. | |
| 1121 | 612 To go to a mark, use the command `{mark}, where {mark} is the mark letter. |
| 7 | 613 Thus to move to the a mark: |
| 614 > | |
| 615 `a | |
| 616 | |
| 617 The command 'mark (single quotation mark, or apostrophe) moves you to the | |
| 618 beginning of the line containing the mark. This differs from the `mark | |
| 619 command, which moves you to marked column. | |
| 620 | |
| 621 The marks can be very useful when working on two related parts in a file. | |
| 622 Suppose you have some text near the start of the file you need to look at, | |
| 623 while working on some text near the end of the file. | |
| 624 Move to the text at the start and place the s (start) mark there: > | |
| 625 | |
| 626 ms | |
| 627 | |
| 1121 | 628 Then move to the text you want to work on and put the e (end) mark there: > |
| 7 | 629 |
| 630 me | |
| 631 | |
| 632 Now you can move around, and when you want to look at the start of the file, | |
| 633 you use this to jump there: > | |
| 634 | |
| 635 's | |
| 636 | |
| 637 Then you can use '' to jump back to where you were, or 'e to jump to the text | |
| 638 you were working on at the end. | |
| 639 There is nothing special about using s for start and e for end, they are | |
| 640 just easy to remember. | |
| 641 | |
| 642 You can use this command to get a list of marks: > | |
| 643 | |
| 644 :marks | |
| 645 | |
| 646 You will notice a few special marks. These include: | |
| 647 | |
| 648 ' The cursor position before doing a jump | |
| 649 " The cursor position when last editing the file | |
| 650 [ Start of the last change | |
| 651 ] End of the last change | |
| 652 | |
| 653 ============================================================================== | |
| 654 | |
| 655 Next chapter: |usr_04.txt| Making small changes | |
| 656 | |
| 14519 | 657 Copyright: see |manual-copyright| vim:tw=78:ts=8:noet:ft=help:norl: |