{"id":259,"date":"2015-04-26T18:17:08","date_gmt":"2015-04-26T18:17:08","guid":{"rendered":"https:\/\/notiz.comanet.xyz\/?p=259"},"modified":"2019-03-03T19:42:29","modified_gmt":"2019-03-03T18:42:29","slug":"vi-editor-manual","status":"publish","type":"post","link":"https:\/\/notiz.comanet.xyz\/?p=259","title":{"rendered":"vi Editor Manual"},"content":{"rendered":"
\n
\n

\t\"\"<\/h1>\n

\tLinux and Unix vi command<\/h1>\n

\tQuick links<\/h2>\n

\tAbout Vi<\/a>
\tSyntax<\/a>
\tUsing Vi<\/a>
\tMoving Around in Vi<\/a>
\tMaking Simple Changes<\/a>
\tRearranging and Duplicating Text<\/a>
\tHigh Level Commands<\/a>
\tSpecial Topics<\/a>
\tTechnical Details<\/a>
\tQuick Reference<\/a>
\tExamples<\/a>
\tRelated commands<\/a>
\tLinux and Unix main page<\/a><\/p>\n

\t<\/a>About vi<\/h2>\n

\tOriginally developed by William Joy<\/a> in the late 1970s, vi<\/b> (pronounced "vee-eye") is a vi<\/b>sual text editor.<\/p>\n

\t<\/a>Syntax<\/h2>\n
vi [ -| -s ] [-l] [-L] [-R] [ -r [ filename<\/i> ] ] [-S] [-t tag<\/i>] [-v] [-V]    [-x] [-w] [-n ] [-C] [+command<\/i> | -c command<\/i> ] filename<\/i><\/pre>\n
 \tDescription<\/h2>\n
 \tvi<\/b> is actaully the command which starts the visual mode of ex<\/a><\/b>, the landmark editing program developed by Joy. As ex<\/b> gained popularity, Joy noticed that most users were exclusively using its visual mode, so to make things more convenient for his users, he added a link to ex<\/b> which started it in visual mode automatically. Today vi<\/b> is the most popular text editor among Linux<\/a> users.<\/p>\n
 \tA more feature-rich implementation of vi<\/b> named vim<\/b> (which stands for "vi improved") is also available. For more information, please see our vim<\/b> documentation<\/a>.<\/p>\n
 \tOptions<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \t\t\t\t–<\/b> | -s<\/b><\/td>\n \t\t\t\tSuppress all interactive user feedback. This is useful when processing editor scripts<\/a>.<\/td>\n<\/tr>\n
 \t\t\t\t-l<\/b><\/td>\n \t\t\t\tSet up for editing LISP<\/a> programs.<\/td>\n<\/tr>\n
 \t\t\t\t-r<\/b><\/td>\n \t\t\t\tList the name of all files saved as the result of an editor or system crash.<\/td>\n<\/tr>\n
 \t\t\t\t-r<\/b> filename<\/i><\/td>\n \t\t\t\tEdit filename<\/i> after an editor or system crash. (Recovers the version of filename<\/i> that was in the buffer when the crash occurred.)<\/td>\n<\/tr>\n
 \t\t\t\t-L<\/b><\/td>\n \t\t\t\tSame as -r<\/b><\/td>\n<\/tr>\n
 \t\t\t\t-R<\/b><\/td>\n \t\t\t\tReadonly<\/a> mode; the readonly flag is set, preventing accidental overwriting of the file.<\/td>\n<\/tr>\n
 \t\t\t\t-S<\/b><\/td>\n \t\t\t\tThis option is used in conjunction with the -t<\/b> tag option to tell vi<\/b> that the tags file may not be sorted and that, if the binary search (which relies on a sorted tags file) for tag<\/i> fails to find it, the much slower linear search should also be done. Since the linear search is slow, users of large tags files should ensure that the tags files are sorted rather than use this flag. Creation of tags files normally produces sorted tags files. See ctags<\/a><\/b> for more information on tags files.<\/td>\n<\/tr>\n
 \t\t\t\t-t<\/b> tag<\/i><\/td>\n \t\t\t\tEdit the file containing the tag tag<\/i>, and position the editor at its definition.<\/td>\n<\/tr>\n
 \t\t\t\t-V<\/b><\/td>\n \t\t\t\tVerbose<\/a> mode. When ex<\/b> commands are read by means of standard input<\/a>, the input will be echoed to standard error. This may be useful when processing ex<\/b> commands within shell scripts.<\/td>\n<\/tr>\n
 \t\t\t\t-x<\/b><\/td>\n \t\t\t\tEncryption<\/a> option; when used, vi<\/b> simulates the X<\/b> command of ex<\/b> and prompts the user for a key. This key is used to encrypt<\/a> and decrypt<\/a> text using the algorithm<\/a> of the crypt<\/a> command. The X<\/b> command makes an educated guess to determine whether text read in is encrypted or not. The temporary buffer<\/a> file is encrypted also, using a transformed version of the key typed in for the -x<\/b> option. If an empty encryption key is entered (that is, if the return key is pressed right after the prompt<\/a>), the file will not be encrypted. This is a good way to decrypt a file erroneously encrypted with a mistyped encryption key, such as a backspace or undo key.<\/td>\n<\/tr>\n
 \t\t\t\t-w<\/b>n<\/i><\/td>\n \t\t\t\tSet the default window size to n<\/i>. This is useful when using the editor over a slow speed line.<\/td>\n<\/tr>\n
 \t\t\t\t-C<\/b><\/td>\n \t\t\t\tEncryption option; same as the -x<\/b> option, except that vi<\/b> simulates the C command of ex<\/b>. The C command is like the X<\/b> command of ex<\/b>, except that all text read in is assumed to have been encrypted.<\/td>\n<\/tr>\n
 \t\t\t\t+<\/b>command<\/i> | -c<\/b> command<\/i><\/td>\n \t\t\t\tBegin editing by executing the specified editor command (usually a search or positioning command).<\/td>\n<\/tr>\n
 \t\t\t\tfilename<\/i><\/td>\n \t\t\t\tThe file to be edited.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \t<\/a>Using Vi<\/h1>\n
 \tvi<\/b> is an interactive text editor which is display-oriented<\/i>: the screen of your terminal<\/a> acts as a window into the file you are editing. Changes you make to the file are reflected in what you see.<\/p>\n
 \tUsing vi<\/b> you can insert text anywhere in the file very easily. Most of the vi<\/b> commands move the cursor<\/a> around in the file. You can move the cursor forward and backward in units of characters, words, sentences, and paragraphs. Some of the operators, like d<\/b> for delete and c<\/b> for change, can be combined with the motion commands to make them operate on entire words, paragraphs, etc., in a natural way.<\/p>\n
 \tEditing A File<\/h2>\n
 \tThe most common way to start a vi<\/b> session is to tell it which file to edit. To edit a file named filename<\/b>, use the command:<\/p>\n
vi filename<\/pre>\n
 \tThe screen will clear and the text of your file will appear on the screen. If filename<\/b> doesn't exist yet, vi<\/b> will start you in a new file, and when you tell it to save your work, it will use the filename<\/b> that you specified.<\/p>\n
 \tThe Editor's Copy: The "Buffer"<\/h2>\n
 \tThe editor does not directly modify the file you are editing. Instead, it makes a copy of this file in memory called the buffer<\/i>. You do not actually affect the contents of the file until you write the changes you've made back into the original file.<\/p>\n
 \tArrow Keys<\/h2>\n
 \tOn most terminals, you can use the arrow keys to move the cursor around. Left and right moves the cursor left or right one character, and up and down move the cursor up or down one line. The other way to move the cursor is with the h<\/b>, j<\/b>, k<\/b>, and l<\/b> keys:<\/p>\n\n\n\n\n\n\n
 \t\t\t\th<\/b><\/td>\n \t\t\t\tleft<\/td>\n<\/tr>\n
 \t\t\t\tj<\/b><\/td>\n \t\t\t\tdown<\/td>\n<\/tr>\n
 \t\t\t\tk<\/b><\/td>\n \t\t\t\tup<\/td>\n<\/tr>\n
 \t\t\t\tl<\/b><\/td>\n \t\t\t\tright<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \tA bit of historical trivia: the hjkl<\/b> keys are used because the original computer system Bill Joy developed with did not have separate arrow keys. Instead, the keyboard used hjkl<\/b> keys as the arrow keys.<\/p>\n
 \tHardcore vi<\/b> users will tell you that the hjkl<\/b> keys are the only "true" way to move the cursor because you can keep your hands in the typing position, but you should use whatever you're comfortable with.<\/p>\n
 \tSpecial Keys: Esc, Return, and Delete<\/h2>\n
 \tThe Escape key is very important in vi<\/b>: it is used to cancel any command you've started typing, and to return to command-mode after you've been inserting or adding text. Escape is a safe key to hit if you've lost track of what mode you're in or what you're doing. You can hit it several times to return to command mode and cancel anything that you've been doing.<\/p>\n
 \tThe Return (or "Enter") key is used to complete certain commands and execute them.<\/p>\n
 \tThe Delete key is another "safe" key to press. It interrupts anything that the editor has been doing and brings you back to the default state of the editor, sometimes also called the "quiescent" state.<\/p>\n
 \tExiting vi<\/h2>\n
 \tThe command ZZ<\/b> will write the contents of the buffer into the file you are editing, and quit vi<\/b>.<\/p>\n
 \tIf there are no changes to be saved, you can also quit the editor with the command :q<\/b>. If you have made changes that haven't been saved yet, the editor won't let you exit this way.<\/p>\n
 \tIf you want to quit and discard the changes you've made, you can tell the editor you're sure you know what you're doing by quitting with the command :q!<\/b>. This will exit vi<\/b> immediately, and any unsaved changes will be lost.<\/p>\n
 \t<\/a>Moving Around In Your File<\/h1>\n
 \tScrolling And Paging<\/h2>\n
 \tThe editor has several commands for moving around within your file. One of the most useful of these is Control-D<\/b> (also represented as ^D<\/b>). This command "scrolls" down in the file (the D<\/b> stands for "down"). ^U<\/b> ("up") is similar: it scrolls up one page in the file. Both of these commands will also move the cursor to the new location.<\/p>\n
 \tIf you just want to see more of the file, but leave the cursor where it is, you can use ^E<\/b> to "expose" one more line at the bottom of the screen. ^Y<\/b> (which doesn't stand for anything, but it's next to the U<\/b> on the keyboard) exposes one line at the top of the screen.<\/p>\n
 \tThere are other ways to move around in the file. The keys ^F<\/b> and ^B<\/b> move forward and backward one page (this is called "paging"), keeping a couple of lines of continuity between screens so that it is possible to read through a file using these rather than ^D<\/b> and ^U<\/b> if you wish.<\/p>\n
 \tNotice the difference between "scrolling" (^U<\/b>, ^D<\/b>) and "paging" (^B<\/b>, ^F<\/b>). Scrolling leaves more context, but paging only leaves you a couple of lines. It's up to you which one is easier for moving around and reading your file.<\/p>\n
 \tSearching<\/h2>\n
 \tAnother way to position yourself in the file is by giving the editor a string<\/a> to search for. If you type "\/<\/b>" followed by a string of characters and press Enter, the editor will search for the next occurrence of this string in your file, and place the cursor there. Pressing n<\/b> will go to the next occurrence after that.<\/p>\n
 \tIf instead of forward, you want to search backward for a string, use ?<\/b> instead of \/<\/b>. In a ?<\/b> string search, pressing n<\/b> will take you to successive occurrences in the same (backward) direction.<\/p>\n
 \tIf the search string you give the editor is not present in the file, the editor will print a message letting you know it couldn't find it, and your cursor will not be moved.<\/p>\n
 \tIf you want your search string only to match if it's at the beginning of a line, you should begin the search string with a carat ("^<\/b>"). To match only at the end of a line, end the search string with a dollar sign ("$<\/b>"). So using the command<\/p>\n
\/^mystring<\/pre>\n
 \twill only find a match if "mystring<\/b>" is at the very begining of a line. Similarly, the command<\/p>\n
\/mystring$<\/pre>\n
 \twill only match any occurrences of "mystring<\/b>" that are at the very end of a line.<\/p>\n
 \t"Goto"-ing<\/h2>\n
 \tThe command G<\/b>, when preceded by a number, will "goto" a line: it will go to that line number and position the cursor there. If you simply use G<\/b> with no number, it will move the cursor to the last line of the file.<\/p>\n
 \tSo, using the command<\/p>\n
1G<\/pre>\n
 \tWill move your cursor to the first line in the file;<\/p>\n
30G<\/pre>\n
 \tWill move your cursor to line 30, and<\/p>\n
G<\/pre>\n
 \tWill move your cursor to the last line, whatever number that may be.<\/p>\n
 \tFinding Out Where You Are In The File<\/h2>\n
 \tYou can find out where you're at in the file by pressing ^G<\/b>. This sill show you the name of the file you are editing, the number of the current line, the number of lines in the buffer, and the percentage of the way through the buffer your cursor is currently at.<\/p>\n
 \tGetting Back To Where You Just Were<\/h2>\n
 \tAny time you move the cursor in any of these ways, you can move the cursor back to where it just was by typing “<\/b> (two back quotes<\/a>). So, if you type<\/p>\n
G<\/pre>\n
 \tto move to the end of the file, but then you realize you need to get back to where you were (whether you remember where that is or not), you can type<\/p>\n
``<\/pre>\n
 \tTo get back to your original location. This also works after performing a search. Remember this command, because it's very useful!<\/p>\n
 \tLines Past The End Of Your File<\/h2>\n
 \tIf you're near the end of your file, and the last line is not at the bottom of the screen, vi<\/b> will print a tilde<\/a> ("~<\/b>") on any lines after the end of your actual file. This indicates that the last line of your file is on the screen; that is, any lines showing "~<\/b>" are past the end of your file. You'll notice this, for instance, when you start editing a new file: every line will begin with a tilde.<\/p>\n
 \tMoving Around On The Screen<\/h2>\n
 \tAs we've already mentioned, you can use the arrow keys or h<\/b>, j<\/b>, k<\/b>, and l<\/b> to move the cursor left and right one cursor, or up and down one line.<\/p>\n
 \tYou can also use +<\/b> to move to the next line or –<\/b> to move to the previous line. This is similar to using up<\/b> and down<\/b> (or j<\/b> and k<\/b>), except that your cursor will automatically be placed at the first non-whitespace<\/a> character on the line.<\/p>\n
 \tAny of these keys, if they would take you before the first line on the screen or after the last line, will scroll the display one line in the correct direction. Pressing the Return<\/b> key is the same as pressing +<\/b>. You can also position the cursor at the top, middle, or bottom of the currently-displayed screen of text:<\/p>\n
 \tH<\/b> will take you to the top ("home") line on the screen. Preceding H<\/b> with a number will take you to the home line plus that number of lines. For instance, 3H<\/b> will move your cursor to the third line of text displayed on the screen.<\/p>\n
 \tM<\/b> is a similar command: it moves your cursor to the middle of the screen.<\/p>\n
 \tL<\/b> moves your cursor to the last line of the screen. If you precede it with a number, it will move your cursor to that number of lines before the last line displayed. So 5L<\/b> will move your cursor to the fifth-to-last line currently displayed.<\/p>\n
 \tMoving Within A Line<\/h2>\n
 \tw<\/b> will advance the cursor to the next word on the line, and b<\/b> will back up the cursor to the previous word.<\/p>\n
 \te<\/b> advances you to the end of the current word rather than the beginning of the next word.<\/p>\n
 \tIf words are punctuated, for instance with an apostrophe or a comma, w<\/b> and b<\/b> will stop at the punctuation. If you use W<\/b> and B<\/b> instead, they will move the cursor while ignoring punctuation.<\/p>\n
 \tThese commands all wrap at the end (or beginning) of a line, moving to the previous or next line if their search for the next or previous word goes that far.<\/p>\n
 \tSummary: Movement Keys<\/h2>\n
 \tHere's a recap of the movement keys we just discussed, and a few extras.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \t\t\t\tSPACE BAR<\/td>\n \t\t\t\tadvance the cursor one position<\/td>\n<\/tr>\n
 \t\t\t\t^B<\/b><\/td>\n \t\t\t\tpage backward<\/td>\n<\/tr>\n
 \t\t\t\t^D<\/b><\/td>\n \t\t\t\tscroll down<\/td>\n<\/tr>\n
 \t\t\t\t^E<\/b><\/td>\n \t\t\t\texpose a line at the bottom of the screen<\/td>\n<\/tr>\n
 \t\t\t\t^F<\/b><\/td>\n \t\t\t\tpage forward<\/td>\n<\/tr>\n
 \t\t\t\t^G<\/b><\/td>\n \t\t\t\tPositional status check<\/td>\n<\/tr>\n
 \t\t\t\t^N<\/b><\/td>\n \t\t\t\tnext line, same column<\/td>\n<\/tr>\n
 \t\t\t\t^P<\/b><\/td>\n \t\t\t\tprevious line, same column<\/td>\n<\/tr>\n
 \t\t\t\t^U<\/b><\/td>\n \t\t\t\tscroll up<\/td>\n<\/tr>\n
 \t\t\t\t^Y<\/b><\/td>\n \t\t\t\texpose a line at the top of the screen<\/td>\n<\/tr>\n
 \t\t\t\t+<\/b><\/td>\n \t\t\t\tnext line, at the first non-whitespace character<\/td>\n<\/tr>\n
 \t\t\t\t–<\/b><\/td>\n \t\t\t\tprevious line, at the first non-whitespace character<\/td>\n<\/tr>\n
 \t\t\t\t\/<\/b>string<\/i><\/td>\n \t\t\t\tScan forward for string<\/i>. If no string<\/i> is specified, scans for the last string<\/i> scanned for.<\/td>\n<\/tr>\n
 \t\t\t\t?<\/b><\/td>\n \t\t\t\tScan backwards for string<\/i>. If no string<\/i> is specified, scans for the last string<\/i> scanned for.<\/td>\n<\/tr>\n
 \t\t\t\tB<\/b><\/td>\n \t\t\t\tbackwards one word, ignoring punctuation<\/td>\n<\/tr>\n
 \t\t\t\tlinenumber<\/i>G<\/b><\/td>\n \t\t\t\tGo to specified linenumber<\/i> (an integer<\/a>). Defaults to the last line.<\/td>\n<\/tr>\n
 \t\t\t\tH<\/b><\/td>\n \t\t\t\tmove cursor to first line of screen<\/td>\n<\/tr>\n
 \t\t\t\tM<\/b><\/td>\n \t\t\t\tmiddle line of screen<\/td>\n<\/tr>\n
 \t\t\t\tL<\/b><\/td>\n \t\t\t\tlast line of screen<\/td>\n<\/tr>\n
 \t\t\t\tW<\/b><\/td>\n \t\t\t\tforward a word, ignoring punctuation<\/td>\n<\/tr>\n
 \t\t\t\tb<\/b><\/td>\n \t\t\t\tbackwards a word<\/td>\n<\/tr>\n
 \t\t\t\te<\/b><\/td>\n \t\t\t\tend of current word<\/td>\n<\/tr>\n
 \t\t\t\tn<\/b><\/td>\n \t\t\t\tnext instance of \/<\/b> or ?<\/b> search pattern<\/td>\n<\/tr>\n
 \t\t\t\tw<\/b><\/td>\n \t\t\t\tnext word<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \t<\/a>Making Simple Changes<\/h1>\n
 \tThe most basic command for making changes to your file is the i<\/i> (insert) command. After you type i<\/i>, everything you type until you hit ESC<\/b> is inserted at your cursor position into the buffer.<\/p>\n
 \tThe companion to the i<\/i> command is the a<\/b> ("append") command. This works exactly like i<\/i>, except it starts inserting the text after<\/i> the cursor location, not at<\/i> the cursor location.<\/p>\n
 \tSometimes, you want to start editing on a new line right after the line your cursor is at. To do this, use the o<\/i> command. To start a new line before<\/i> the line your cursor is at, use the O<\/b> command. Just like with i<\/i> and a<\/i>, any text you type will be inserted into the buffer until you press ESC<\/b>.<\/p>\n
 \tWhile you are inserting text with any of these commands, you can use ^W<\/b> to erase a whole word and leave your cursor one space after the previous word.
 \tOne thing to note is that when you backspace, you will not erase any characters that you haven't inserted. Also, you can't backspace to the previous line; backspacing will stop when you get to the beginning of the current line.<\/p>\n
 \tMaking Small Corrections<\/h2>\n
 \tIt's easy to make small corrections in vi<\/b>. If you need to remove a character that shouldn't be there, move the cursor over it and press x<\/b> to delete it. You can also supply a number before pressing x<\/b>, and it will delete that many characters. So if you have the word "discovery<\/b>", and you move the cursor over the v<\/b> and type<\/p>\n
4x <\/pre>\n
 \t…you will be left with the word "disco<\/b>".<\/p>\n
 \tIf you want to replace a single character with another character, move the cursor over it and press r<\/b> and then the character that should replace it. So, if you type "mistoke<\/b>", and move the cursor over the "o<\/b>" and type<\/p>\n
ra<\/pre>\n
 \t…the o<\/b> will be replaced with an a<\/b>, leaving you with the word "mistake<\/b>."<\/p>\n
 \tThe R<\/b> command is similar, but you can use it to replace more than one character; if you press R<\/b> and start typing, every character you type will replace every character that was already there. So, if you have the word "mistake<\/b>", and you move the cursor over the letter t<\/b> and type<\/p>\n
Rsile<\/pre>\n
 \t…you will see that the word "mistake<\/b>" has turned into the word "missile<\/b>". You might also notice that if you backspace in this mode, your original text will be restored, letter by letter. When you're done, press ESC<\/b> to stop replacing characters.<\/p>\n
 \tOperators<\/h2>\n
 \tThe command d<\/b> acts as a delete operator<\/i>: presing d<\/b> and then a movement key will delete wherever the cursor would have moved. For instance, typing dw<\/b> will delete the next word, and typing db<\/b> will delete backwards to the previous word. Typing d<\/b>SPACE will delete one character; this is the same as typing x<\/b>.<\/p>\n
 \tAnother useful operator is c<\/b>, which stands for change<\/i>. The command cw<\/b> will change a single word: it will delete everything to the end of a word, and place you into insert mode to type the text that should replace it.<\/p>\n
 \tRepeating A Change<\/h2>\n
 \tAny time you make a change with a command, you can type ".<\/b>" to repeat the change. So if you delete a word with dw<\/b>, typing .<\/b> will delete the next word as well. You can repeat this over and over by typing .<\/b> several times, like an ellipsis ("…<\/b>").<\/p>\n
 \tOperating On Lines<\/h2>\n
 \tTyping dd<\/b> will delete an entire line.<\/p>\n
 \tTyping cc<\/b> will change an entire line, deleting it and placing you in insert mode.<\/p>\n
 \tYou can delete or change more than one line at a time by preceding dd<\/b> or cc<\/b> with a number. For instance, 5dd<\/b> will delete 5 lines. You can also give a command like dL<\/b> which will delete every line from the cursor up to and including the last line on the screen, or d3L<\/b> which will delete every line from the cursor to the third-to-last line. When you make big changes like this, especially if you make changes that go beyond what you can see in one screen, the editor will give you a message telling you what's been done.<\/p>\n
 \tUndoing<\/h2>\n
 \tTo undo the last change, type u<\/b>. To re-do (to undo an undo), type u<\/b> again.<\/p>\n
 \tUnlike vim<\/b><\/a>, vi<\/b> only offers one level of undo. However, you can use U<\/b> (capital U) to undo any changes that were made to the current line; pressing U<\/b> restores the current line to the way it was before you started changing it.<\/p>\n
 \tSummary: Making Changes<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \t\t\t\tSPACE<\/td>\n \t\t\t\tadvance the cursor one position<\/td>\n<\/tr>\n
 \t\t\t\t^W<\/b><\/td>\n \t\t\t\terase a word during insert<\/td>\n<\/tr>\n
 \t\t\t\t.<\/b><\/td>\n \t\t\t\trepeats the last change command<\/td>\n<\/tr>\n
 \t\t\t\tO<\/b><\/td>\n \t\t\t\topens and inputs a new line, above the current line<\/td>\n<\/tr>\n
 \t\t\t\tU<\/b><\/td>\n \t\t\t\tundoes the changes you made to the current line<\/td>\n<\/tr>\n
 \t\t\t\ta<\/b><\/td>\n \t\t\t\tappends text after the cursor<\/td>\n<\/tr>\n
 \t\t\t\tc<\/b><\/td>\n \t\t\t\tchanges the object you specify to the text you type in after<\/td>\n<\/tr>\n
 \t\t\t\td<\/b><\/td>\n \t\t\t\tdeletes the object that you specify<\/td>\n<\/tr>\n
 \t\t\t\ti<\/b><\/td>\n \t\t\t\tinserts text before the cursor<\/td>\n<\/tr>\n
 \t\t\t\to<\/b><\/td>\n \t\t\t\topens and inputs new lines, below the current line<\/td>\n<\/tr>\n
 \t\t\t\tu<\/b><\/td>\n \t\t\t\tundoes the last change<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \t<\/a>Rearranging and Duplicating Text<\/h1>\n
 \tLow-Level Character Motions<\/h2>\n
 \tf<\/b>x<\/i> moves the cursor finds the next x<\/i> character on the current line. After that, if you press ;<\/b> your cursor will move to the next occurrence of the same character. F<\/b> is a similar command, but searches backwards in the same line, rather than forwards.<\/p>\n
 \tThe f<\/b> and F<\/b> commands can be combined, for example, with the d<\/b> command. Typing df<\/b>x<\/i> will delete everything from the cursor through the next occurrence of x<\/i> in the line. Sometimes you want to delete up to, but not including, the next occurrence of character x<\/i>. In this case, use the command dt<\/b>x<\/i>. t<\/b> stands for "to".<\/p>\n
 \tThe beginning of the line is represented by zero ("0<\/b>"), the carat ("^<\/b>") represents the first non-whitespace character on the line, and the end of the line is represented by the dollar sign ("$<\/b>"). If you press ^<\/b>, the cursor will be placed at the first non-whitespace character of the line; if you press 0<\/b>, the cursor will be placed at the beginning of the line; and if you press $<\/b>, the cursor will be placed at the end of the line.<\/p>\n
 \tTo delete everything from the cursor to the end of the line, type d$<\/b>. To delete everything from the cursor to the beginning of the line, type d0<\/b>… and so on.<\/p>\n
 \tHigher-Level Text Objects<\/h2>\n
 \tSometimes it's helpful to move around in units of entire sentences. The (<\/b> and )<\/b> commands move to the beginning of the previous and next sentences, respectively. So the command d)<\/b> deletes everything through the end of the current sentence; and d(<\/b> deletes everything through the beginning of the current sentence, or the entire previous sentence if you're already at the beginning of a sentence.<\/p>\n
 \tA sentence is defined as ending at a period (".<\/b>"), exclamation point ("!<\/b>"), or question mark ("?<\/b>") which is followed either by the end of the line or a space. Any number of closing )<\/b>, ]<\/b>, "<\/b>, and '<\/b> characters may appear after the .<\/b>, ?<\/b>, or !<\/b> before the space or the end of the line.<\/p>\n
 \tThe {<\/b> and }<\/b> commands move over paragraphs, and the operations [[<\/b> and ]]<\/b> move over sections. (A "section" can be defined by a special macro, or by a formfeed at the beginning of a line.)<\/p>\n
 \tRearranging And Duplicating Text<\/h2>\n
 \tThe editor has a special unnamed buffer where the last deleted or changed-away text is saved, and a set of named buffers a<\/b> through z<\/b> which you can use to save copies of text and to move text around in your file (or files).<\/p>\n
 \tThe y<\/b> command "yanks" a copy of an object into the unnamed buffer. If preceded by a buffer name, it places this object into the named buffer. The way to specify the buffer is double quotes ("<\/b>), then a letter a<\/b>–z<\/b>, then the y<\/b> command. So "ay<\/b> will yank an object into the buffer named a<\/b>.<\/p>\n
 \tText in a buffer (either the unnamed buffer or one of your named buffers) can be pasted into your document with the commands p<\/b> or P<\/b>. p<\/b> will paste the buffer contents after the cursor location (much like an append), and P<\/b> will paste the buffer contents at the cursor location (much like an insert).<\/p>\n
 \tIf the text which you yank forms part of a line, or is an object such as a sentence which partially spans more than one line, then when you put the text back, it will be placed after the cursor (or before it if you used P<\/b>). If the yanked text forms whole lines, they will be put back as whole lines, without changing the current line. In this case, the paste acts much more like an o<\/b> or O<\/b> command. So, the command YP<\/b> will make a copy of the current line and place you at the location of the copy, which is placed before the current line. Y<\/b> is a convenient abbreviation for yy<\/b>.<\/p>\n
 \tThe command Yp<\/b> will also make a copy of the current line, and place it after the current line. You can give Y<\/b> a number of lines to yank, and thus duplicate several lines; for instance, 3YP<\/b> will duplicate three lines, and place them before the current line.<\/p>\n
 \tTo move text within the buffer, you need to delete it in one place, and put it back in another. You can precede a delete operation by the name of a buffer in which the text is to be stored, as in "a5dd<\/b>, which deletes 5 lines into the named buffer a<\/b>. You can then move the cursor to the eventual resting place of these lines and do a "ap<\/b> or "aP<\/b> to put them back. In fact, you can switch and edit another file before you put the lines back, by giving a command of the form :e <\/b>name<\/i>, where name<\/i> is the name of the other file you want to edit. (You will have to write the contents of the current editor buffer (or discard them) if you have made changes, before the editor will allow you to edit a new file.)<\/p>\n
 \tAn ordinary delete command saves the text in the unnamed buffer, so that an ordinary paste will place it back in the file. However, the unnamed buffer is lost when you change files, so to move text from one file to another you should use a named buffer.<\/p>\n
 \tSummary of Moving And Rearranging Text<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \t\t\t\t^<\/b><\/td>\n \t\t\t\tFirst non-whitespace character on line<\/td>\n<\/tr>\n
 \t\t\t\t0<\/b><\/td>\n \t\t\t\tBeginning of the line<\/td>\n<\/tr>\n
 \t\t\t\t$<\/b><\/td>\n \t\t\t\tEnd of the line<\/td>\n<\/tr>\n
 \t\t\t\t)<\/b><\/td>\n \t\t\t\tForward to next sentence break<\/td>\n<\/tr>\n
 \t\t\t\t(<\/b><\/td>\n \t\t\t\tBackward to previous sentence break<\/td>\n<\/tr>\n
 \t\t\t\t}<\/b><\/td>\n \t\t\t\tForward to next paragraph break<\/td>\n<\/tr>\n
 \t\t\t\t{<\/b><\/td>\n \t\t\t\tBackward to previous paragraph break<\/td>\n<\/tr>\n
 \t\t\t\t]]<\/b><\/td>\n \t\t\t\tForward to next section break<\/td>\n<\/tr>\n
 \t\t\t\t[[<\/b><\/td>\n \t\t\t\tBackward to previous section break<\/td>\n<\/tr>\n
 \t\t\t\tf<\/b>x<\/i><\/td>\n \t\t\t\tFind character x<\/i> forward in the line<\/td>\n<\/tr>\n
 \t\t\t\tF<\/b>x<\/i><\/td>\n \t\t\t\tFind character x<\/i> backward in the line<\/td>\n<\/tr>\n
 \t\t\t\tp<\/b><\/td>\n \t\t\t\tPaste text after cursor<\/td>\n<\/tr>\n
 \t\t\t\tP<\/b><\/td>\n \t\t\t\tPaste text before cursor<\/td>\n<\/tr>\n
 \t\t\t\ty<\/b><\/td>\n \t\t\t\tyank<\/td>\n<\/tr>\n
 \t\t\t\tY<\/b><\/td>\n \t\t\t\tyank a whole line<\/td>\n<\/tr>\n
 \t\t\t\tt<\/b><\/td>\n \t\t\t\tforward to character x<\/i>, for operations<\/td>\n<\/tr>\n
 \t\t\t\tT<\/b>x<\/i><\/td>\n \t\t\t\tback to character x<\/i>, for operations<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \t<\/a>High Level Commands<\/h1>\n
 \tWriting, Quitting, and Editing New Files<\/h2>\n
 \tSo far we have seen how to write our file to disk and quit (ZZ<\/b>), or simply write our file and continue editing(:w<\/b>).<\/p>\n
 \tIf you have changed your file but you want to quit without saving, use the command :q!<\/b>. The command :q<\/b> quits the editor, but it will only let you do this if you haven't made any changes since your last write (your last save). The exclamation point, however, tells the editor "yes, I really want to do this."<\/p>\n
 \tSimilarly, you can edit another file with the :e<\/b> name<\/i> command, where name<\/i> is the name of the file you want to edit. But the editor won't let you do this if you have unsaved changes. However, if you use the exclamation mark again (:e!<\/b> name<\/i>), the editor will do as you ask: it will discard your changes and open file name<\/i> for editing.<\/p>\n
 \tIf you don't specify a filename, and just use the command :e!<\/b>, the editor will re-load your saved version of the file you're working on. This is like the "revert" command in other file editors. It will discard your changes, and revert to the last-saved version of the file.<\/p>\n
 \tEscaping To The Shell<\/h2>\n
 \tIf you want run a shell command without exiting the editor, you can use the command :!<\/b>command<\/i>. The system will run the command command<\/i>, and when the command finishes, the editor will ask you to press Enter before returning you to the editing screen. You can also give another :<\/b> command when it asks you to press Enter; this will run the next command without redrawing the screen.<\/p>\n
 \tIf you want to drop entirely to your shell's command prompt, use the command :sh<\/b>. This will drop you into your shell, where you can use it as you normally would; when you're done, type Control-D (^D<\/b>), and you will be returned to vi<\/b>.<\/p>\n
 \tOn many systems, you can also simply type ^Z<\/b> from within the editor at any time to drop into your shell. This technically puts vi<\/b> in the background. To return to vi<\/b>, type fg<\/b> ("foreground") at your shell command prompt, and vi<\/b> will become your foreground process again.<\/p>\n
 \tMarking And Returning<\/h2>\n
 \tAs already mentioned, the command “<\/b> (two back quotes) returns you to the previous place after a motion of the cursor by a command such as \/<\/b>, \/<\/b>, or G<\/b>. You can also mark your position in the file with single-letter tags and return to these marks later. The marking is done with the command m<\/b>x<\/i>, where x<\/i> is the letter you want to assign to the mark. To return to the place that you marked, you can use the command `<\/b>x<\/i><\/p>\n
 \tFor example, if you type ma<\/b>, you will mark the current cursor position with the letter a<\/b>. Then, if you move the cursor anywhere else in the file, you can always return to that line with the command `a<\/b>. Marks last until you start editing another file, or until you overwrite the mark by setting it somewhere else.<\/p>\n
 \tWhen using operators such as d<\/b> and referring to marked lines, sometimes you'll want to refer to the line that you marked, and not the actual cursor position within the line. At any time, you can use '<\/b>x<\/i> (as opposed to `<\/b>x<\/i>) to refer to the line itself. So, the command d`<\/b>a<\/i> will delete everything from the current cursor position up to the exact position at mark a<\/b>, whereas the command d'a<\/b> will delete everything up to (and including) the entire line where mark a<\/b> resides.<\/p>\n
 \tUsed without an operator, '<\/b>x<\/i> moves you to the first non-whitespace character in the line where mark x<\/i> resides.<\/p>\n
 \tAdjusting The Screen<\/h2>\n
 \tIf the screen image is messed up for any reason, you can refresh the screen with Control-L (^L<\/b>).<\/p>\n
 \tIf you want to center the screen on your cursor at any time, type z-<\/b>. To adjust the screen so that the line with your cursor is at the top of the screen, type z<\/b> and press Enter. To adjust the screen so that the line with your cursor is at the bottom of the screen, type z.<\/b>.<\/p>\n
 \tzz<\/b> is the same as z-<\/b>, and will center the screen so that the line with your cursor is at the center of the screen.<\/p>\n
 \t<\/a>Special Topics<\/h1>\n
 \tSetting Options, and Using Editor Startup Files<\/h2>\n
 \tThe editor has a set of options, which you can set with the :set<\/b> command. To set option opt<\/i> to value val<\/i>, use the command :set<\/b> opt<\/i>=<\/b>val<\/i>.<\/p>\n
 \tToggle options can be set with the commands set<\/b> opt<\/i>, and unset with the command set no<\/b>opt<\/i>.<\/p>\n
 \tHere are some of the most useful options you can set:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
 \t\t\t\toption name<\/th>\n \t\t\t\tdefault value<\/th>\n \t\t\t\tdescription<\/th>\n<\/tr>\n
 \t\t\t\tautoindent<\/b><\/td>\n \t\t\t\tnoai<\/td>\n \t\t\t\tSupply indentation automatically<\/td>\n<\/tr>\n
 \t\t\t\tautowrite<\/b><\/td>\n \t\t\t\tnoaw<\/td>\n \t\t\t\tAutomatically write to file while editing<\/td>\n<\/tr>\n
 \t\t\t\tignorecase<\/b><\/td>\n \t\t\t\tnoic<\/td>\n \t\t\t\tIgnore case when searching<\/td>\n<\/tr>\n
 \t\t\t\tlisp<\/b><\/td>\n \t\t\t\tnolisp<\/td>\n \t\t\t\t(<\/b>, {<\/b>, )<\/b>, and }<\/b> commands deal with S-expressions<\/td>\n<\/tr>\n
 \t\t\t\tlist<\/b><\/td>\n \t\t\t\tnolist<\/td>\n \t\t\t\tTabs print as ^I<\/b>; end of lines marked with $<\/b><\/td>\n<\/tr>\n
 \t\t\t\tmagic<\/b><\/td>\n \t\t\t\tnomagic<\/td>\n \t\t\t\tThe characters .<\/b>, [<\/b>, and *<\/b> are special ("magical") in scans<\/td>\n<\/tr>\n
 \t\t\t\tnumber<\/b><\/td>\n \t\t\t\tnonu<\/td>\n \t\t\t\tLines are displayed prefixed with their line numbers<\/td>\n<\/tr>\n
 \t\t\t\tparagraphs<\/b><\/td>\n \t\t\t\tpara=IPLPPPQPbpP<\/td>\n \t\t\t\tLI Macro names which start paragraphs<\/td>\n<\/tr>\n
 \t\t\t\tredraw<\/b><\/td>\n \t\t\t\tnore<\/td>\n \t\t\t\tSimulate a smart terminal on a dumb terminal<\/td>\n<\/tr>\n
 \t\t\t\tsections<\/b><\/td>\n \t\t\t\tsect=NHSHH<\/td>\n \t\t\t\tHU Macro names which start new sections<\/td>\n<\/tr>\n
 \t\t\t\tshiftwidth<\/b><\/td>\n \t\t\t\tsw=8<\/td>\n \t\t\t\tShift distance for <<\/b>, ><\/b>, and other "shift" commands<\/td>\n<\/tr>\n
 \t\t\t\tshowmatch<\/b><\/td>\n \t\t\t\tnosm<\/td>\n \t\t\t\tShow matching (<\/b> or {<\/b> locations as )<\/b> or }<\/b> is typed, for example<\/td>\n<\/tr>\n
 \t\t\t\tshowmode<\/b><\/td>\n \t\t\t\tnosmd<\/td>\n \t\t\t\tShow input mode description<\/td>\n<\/tr>\n
 \t\t\t\tslowopen<\/b><\/td>\n \t\t\t\tslow<\/td>\n \t\t\t\tPostpone display updates during inserts<\/td>\n<\/tr>\n
 \t\t\t\tterm<\/b><\/td>\n \t\t\t\tdumb<\/td>\n \t\t\t\tThe kind of terminal you are using<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 \tThese statements can be placed in the environment variable<\/a> EXINIT<\/b>, or can be given while you are running vi<\/b> by preceding them with a :<\/b>, as described above.<\/p>\n
 \tYou can view a list of all options and their settings by typing :set<\/b> within vi<\/b> at any time. To view the current setting of a particular option, use the command :set<\/b> opt<\/i>?<\/b>.<\/p>\n
 \tset<\/b> can be appreviated as se<\/b>. Multiple options can be set on one line, for instance :se ai aw nu<\/b>.<\/p>\n
 \tOptions set with :set<\/b> only last for your current editor session.<\/p>\n
 \tIf you want to place your default settings into the environment variable EXINIT<\/b> so that they are loaded every time you run vi<\/b>, you can specify multiple commands on a single line by separating them with the vertical bar ("|<\/b>"). For instance, if your shell is csh<\/b><\/a>, you could set EXINIT<\/b> with the following shell command:<\/p>\n
setenv EXINIT 'set ai aw terse|map @ dd|map # x'<\/pre>\n
 \tRecovering Lost Lines<\/h2>\n
 \tYou might have a problem if you delete several lines and then want them back. However, the editor saves the last 9 deleted blocks of text in a set of registers numbered 1<\/b> through 9<\/b>. You can get the n<\/i>th previous deleted text back in your file by the command "<\/b>n<\/i>p<\/b>. These are similar to your named buffers, except they refer to the number of the previous block of text that was deleted.<\/p>\n
 \tUsually, when you type a single period (".<\/b>"), it repeats the last change you've made. As a special case, when this period repeats a change that refers to a numbered buffer, the number is incremented before the command is repeated. Let's see how this works, and why it's useful:<\/p>\n
 \tLet's say you deleted something important, and you know it's in one of your nine previous block-deletes, but you're not sure which one. If you want to go back and look at all nine previously deleted blocks, here's how you could do it: you could use the command<\/p>\n
"1p<\/pre>\n
 \tTo paste the contents of the most recently-deleted text (buffer number 1<\/b>). If that's not the text you wanted, you could then undo (u<\/b>) and repeat the command with .<\/b>, pasting the command of buffer 2<\/b>. In other words, typing the command<\/p>\n
"1pu.u.u.u.<\/pre>\n
 \tis the same as typing<\/p>\n
"1pu"2pu"3pu"4pu"5p<\/pre>\n
 \tand you can go back in the numbered buffers easily until you find the text you want to have back.<\/p>\n
 \tThe command P<\/b> can, of course, be used instead of p<\/b> in the above example, to place the text before the cursor instead of after it.<\/p>\n
 \tRecovering Lost Files<\/h2>\n
 \tIf the system crashes, you can recover the work you were doing to within a few changes. When you get back into your system, use this command to start vi<\/b>:<\/p>\n
vi -r name<\/i><\/pre>\n
 \tWhere name<\/i> is the name of the file you were editing. This will recover your work to a point as close as possible to where you left off.<\/p>\n
 \tIf you don't specify a file with name<\/i> and instead just type<\/p>\n
vi -r<\/pre>\n
 \tthen you will receive a list of files which can be recovered.<\/p>\n
 \tContinuous Text Input<\/h2>\n
 \tWhen you are typing in large amounts of text it is convenient to have lines broken near the right margin automatically. You can cause this to happen by giving the command :se wm=10<\/b>. This causes all lines to be broken at a space at least 10 columns from the right hand edge of the screen.<\/p>\n
 \tIf the editor breaks an input line and you wish to put it back together you can tell it to join the lines with J<\/b>. You can give J<\/b> a count of the number of lines to be joined as in 3J<\/b> to join 3 lines. The editor supplies white space, if appropriate, at the juncture of the joined lines, and leaves the cursor at this white space. You can kill the white space with x<\/b> if you don't want it.<\/p>\n
 \tFeatures For Editing Programs<\/h2>\n
 \tThe editor has a number of commands for editing programs. The thing that most distinguishes editing of programs from editing of text is the indented structure to the body of the program. The editor has an autoindent<\/b> facility for helping you generate correctly indented programs.<\/p>\n
 \tTo enable this facility you can give the command :se ai<\/b>. Now try opening a new line with o<\/b> and type some characters on the line after a few tabs. If you now start another line, notice that the editor supplies white space at the beginning of the line to line it up with the previous line. You cannot backspace over this indentation, but you can use ^D<\/b> key to backtab over the supplied indentation.<\/p>\n
 \tEach time you type ^D<\/b> you back up one position, normally to an 8 column boundary. This amount is settable; the editor has an option called shiftwidth<\/b> which you can set to change this value. Try giving the command :se sw=4<\/b> and then experimenting with autoindent<\/b> again.<\/p>\n
 \tFor shifting lines in the program left and right, there are operators <<\/b> and ><\/b>. These shift the lines you specify right or left by one shiftwidth. Try <<<\/b> and >><\/b> which shift one line left or right, and <L<\/b> and >L<\/b> shifting the rest of the display left and right.<\/p>\n
 \tIf you have a complicated expression and wish to see how the parentheses match, put the cursor at a left or right parenthesis and hit %<\/b>. This will show you the matching parenthesis. This works also for braces {<\/b> and }<\/b>, and brackets [<\/b> and ]<\/b>.<\/p>\n
 \tIf you are editing C<\/a> programs, you can use the [[<\/b> and ]]<\/b> keys to advance or retreat to a line starting with a {<\/b>, i.e. a function declaration at a time. When ]]<\/b> is used with an operator it stops after a line which starts with }<\/b>; this is sometimes useful with y]]<\/b>.<\/p>\n
 \tFiltering Portions of the Buffer<\/h2>\n
 \tYou can run system commands over portions of the buffer using the operator !<\/b> (the exclamation point). Essentially, it sends a section of your file as standard input<\/a> to a shell command, then replaces that portion of your text with the standard output of the command.<\/p>\n
 \tAll togehter, the way to specify what text to send and what command to send it to, is !<\/b>(movement-specifier) command-name<\/i>. The movement-specifier<\/i> could be w<\/b> for operating on the next word, for instance, or }<\/b> for the next paragraph, etc. The command-name<\/i> is the shell command, and any arguments it may take.<\/p>\n
 \tThis is especially useful for sorting using the sort<\/b><\/a> command. You can use this to sort lines in your file. For instance, if you were to type in a list of random words, one per line, and end them with a blank line, then you backed up to the beginning of the list and gave the command !}sort<\/b>, this would sort the data you just typed in, right before your eyes. This is a very powerful function! Try it for yourself.<\/p>\n
 \tCommands For Editing LISP Code<\/h2>\n
 \tIf you are editing a LISP<\/a> program you should set the option lisp<\/b> by doing :se lisp<\/b>. This changes the (<\/b> and )<\/b> commands to move backward and forward over s-expressions. The {<\/b> and }<\/b> commands are like (<\/b> and )<\/b> but don't stop at atoms. These can be used to skip to the next list, or through a comment<\/a> quickly.<\/p>\n
 \tThe autoindent<\/b> option works differently for LISP, supplying indent to align at the first argument<\/a> to the last open list. If there is no such argument then the indent is two spaces more than the last level.<\/p>\n
 \tThere is another option which is useful for typing in LISP, the showmatch<\/b> option. Try setting it with :se sm<\/b> and then try typing a "(<\/b>", some words, and then a ")<\/b>". Notice that the cursor shows the position of the "(<\/b>" which matches the ")<\/b>" briefly. This happens only if the matching "(<\/b>" is on the screen, and the cursor stays there for at most one second.<\/p>\n
 \tThe editor also has an operator to realign existing lines as though they had been typed in with lisp<\/b> and autoindent<\/b> set. This is the =<\/b> operator. Try the command =%<\/b> at the beginning of a function<\/a>. This will realign all the lines of the function declaration.<\/p>\n
 \tWhen you are editing LISP, the [[<\/b> and ]]<\/b> advance and retreat to lines beginning with a (<\/b>, and are useful for dealing with entire function definitions.<\/p>\n
 \tMacros<\/h2>\n
 \tvi<\/b> has a parameterless macro<\/a> facility, which lets you set it up so that when you hit a single keystroke, the editor will act as though you had hit some longer sequence of keys. You can set this up if you find yourself typing the same sequence of commands repeatedly.<\/p>\n
 \tThere are two general kinds of macros:<\/p>\n
    \n
  1.  \t\tOnes where you put the macro body in a named macro buffer x<\/i>. You can then type @<\/b>x<\/i> to invoke the macro. The @<\/b> may be followed by another @<\/b> to repeat the last macro.<\/li>\n
  2.  \t\tYou can use the map command from vi<\/b> (typically in your EXINIT<\/b> environment variable) with a command of the form:\n
    :map lhs rhsCR<\/pre>\n
     \t\tmapping lhs<\/b> into rhs<\/b>. There are restrictions: lhs<\/b> should be one keystroke (either 1 character or one function key) since it must be entered within one second (unless notimeout<\/b> is set, in which case you can type it as slowly as you wish, and vi<\/b> will wait for you to finish it before it echoes anything). The lhs can be no longer than 10 characters, the rhs<\/b> no longer than 100. To get a space, tab or newline<\/a> into lhs<\/b> or rhs<\/b> you should escape them with a ^V<\/b>. (It may be necessary to double the ^V<\/b> if the map command is given inside vi<\/b>, rather than in ex<\/b>.) Spaces and tabs inside the rhs<\/b> need not be escaped.<\/li>\n<\/ol>\n
     \tThus to make the q<\/b> key write and exit the editor, you can give the command<\/p>\n
    :map q :wq^V^VCR CR<\/pre>\n
     \twhich means that whenever you type q<\/b>, it will be as though you had typed the four characters :wqCR<\/b>. A ^V<\/b>'s is needed because without it the carriage return would end the :<\/b> command, rather than becoming part of the map definition. There are two ^V<\/b>'s because from within vi<\/b>, two ^V<\/b>'s must be typed to get one. The first CR is part of the rhs<\/b>, the second terminates the :<\/b> command.<\/p>\n
     \tMacros can be deleted with<\/p>\n
    unmap lhs<\/pre>\n
     \tIf the lhs<\/b> of a macro is “#0<\/b>” through “#9<\/b>”, this maps the particular function key instead of the 2 character “#<\/b>” sequence. So that terminals without function keys can access such definitions, the form “#x<\/b>” will mean function key x<\/b> on all terminals (and need not be typed within one second.) The character “#<\/b>” can be changed by using a macro in the usual way:<\/p>\n
    :map ^V^V^I #<\/pre>\n
     \tto use tab, for example. (This won't affect the map<\/b> command, which still uses #<\/b>, but just the invocation from visual mode.)<\/p>\n
     \tThe undo<\/b> command reverses an entire macro call as a unit, if it made any changes.<\/p>\n
     \tPlacing a "!<\/b>" after the word map causes the mapping to apply to input mode, rather than command mode. Thus, to arrange for ^T<\/b> to be the same as 4 spaces in input mode, you can type:<\/p>\n
    :map! ^T ^Vb\/b\/b\/b\/<\/pre>\n
     \twhere b\/<\/b> is a blank. The ^V<\/b> is necessary to prevent the blanks from being taken as white space between the lhs<\/b> and rhs<\/b>.<\/p>\n
     \tWord Abbreviations<\/h2>\n
     \tA feature similar to macros in input mode is word abbreviation. This allows you to type a short word and have it expanded into a longer word or words. The commands are :abbreviate<\/b> and :unabbreviate<\/b> (:ab<\/b> and :una<\/b>) and have the same syntax as :map<\/b>. For example:<\/p>\n
    :ab eecs Electrical Engineering and Computer Sciences<\/pre>\n
     \tcauses the word "eecs<\/b>" to always be changed into the phrase "Electrical Engineering and Computer Sciences<\/b>". Word abbreviation is different from macros in that only whole words are affected. If "eecs<\/b>" were typed as part of a larger word, it would be left alone. Also, the partial word is echoed as it is typed. There is no need for an abbreviation to be a single keystroke, as it should be with a macro.<\/p>\n
     \t<\/a>Technial Details<\/h1>\n
     \tLine Representation In The Display<\/h2>\n
     \tThe editor folds long logical lines onto many physical lines in the display. Commands which advance lines advance logical lines and will skip over all the segments of a line in one motion. The command |<\/b> moves the cursor to a specific column, and may be useful for getting near the middle of a long line to split it in half.<\/p>\n
     \tThe editor only puts full lines on the display; if there is not enough room on the display to fit a logical line, the editor leaves the physical line empty, placing only an @<\/b> on the line as a place holder. When you delete lines on a dumb terminal, the editor will often just clear the lines to @<\/b> to save time (rather than rewriting the rest of the screen.) You can always maximize the information on the screen by giving the ^R<\/b> command.<\/p>\n
     \tIf you wish, you can have the editor place line numbers before each line on the display. Give the command :se nu<\/b> to enable this, and the command :se nonu<\/b> to turn it off. You can have tabs represented as ^I<\/b> and the ends of lines indicated with "$<\/b>" by giving the command :se list<\/b>; :se nolist<\/b> turns this off.<\/p>\n
     \tFinally, lines consisting of only the character "~<\/b>" are displayed when the last line in the file is in the middle of the screen. These represent physical lines which are past the logical end of file.<\/p>\n
     \tMore File Manipulation Commands<\/h2>\n
     \tThe following table lists the file manipulation commands which you can use when you are in vi<\/b>.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t:w<\/b><\/td>\n \t\t\t\twrite back changes<\/td>\n<\/tr>\n
     \t\t\t\t:wq<\/b><\/td>\n \t\t\t\twrite and quit<\/td>\n<\/tr>\n
     \t\t\t\t\ud83d\ude21<\/b><\/td>\n \t\t\t\twrite (if necessary) and quit (same as ZZ<\/b>).<\/td>\n<\/tr>\n
     \t\t\t\t:e<\/b> name<\/i><\/td>\n \t\t\t\tedit file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:e!<\/b><\/td>\n \t\t\t\treedit, discarding changes<\/td>\n<\/tr>\n
     \t\t\t\t:e +<\/b> name<\/i><\/td>\n \t\t\t\tedit, starting at end<\/td>\n<\/tr>\n
     \t\t\t\t:e +<\/b>n<\/i><\/td>\n \t\t\t\tedit, starting at line n<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:e #<\/b><\/td>\n \t\t\t\tedit alternate file<\/td>\n<\/tr>\n
     \t\t\t\t:w<\/b> name<\/i><\/td>\n \t\t\t\twrite file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:w!<\/b> name<\/i><\/td>\n \t\t\t\toverwrite file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:x<\/i>,<\/b>y<\/i>w<\/b> name<\/i><\/b><\/td>\n \t\t\t\twrite lines x<\/i> through y<\/i> to name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:r<\/b> name<\/i><\/td>\n \t\t\t\tread file name<\/i> into buffer<\/td>\n<\/tr>\n
     \t\t\t\t:r !<\/b>cmd<\/i><\/td>\n \t\t\t\tread output of cmd<\/i> into buffer<\/td>\n<\/tr>\n
     \t\t\t\t:<\/b>n<\/i><\/td>\n \t\t\t\tedit next file in argument list<\/td>\n<\/tr>\n
     \t\t\t\t:<\/b>n<\/i>!<\/b><\/td>\n \t\t\t\tedit next file, discarding changes to current<\/td>\n<\/tr>\n
     \t\t\t\t:<\/b>n<\/i> args<\/i><\/td>\n \t\t\t\tspecify new argument list<\/td>\n<\/tr>\n
     \t\t\t\t:ta<\/b> tag<\/i><\/td>\n \t\t\t\tedit file containing tag tag<\/i>, at tag<\/i><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tAll of these commands are followed by a CR or ESC. The most basic commands are :w<\/b> and :e<\/b>. A normal editing session on a single file will end with a ZZ<\/b> command. If you are editing for a long period of time you can give :w<\/b> commands occasionally after major amounts of editing, and then finish with a ZZ<\/b>. When you edit more than one file, you can finish with one with a :w<\/b> and start editing a new file by giving a :e<\/b> command, or set autowrite<\/b> and use :n<\/b> file<\/i>.<\/p>\n
     \tIf you make changes to the editor's copy of a file, but do not wish to write them back, then you must give an !<\/b> after the command you would otherwise use; this forces the editor to discard any changes you have made. Use this carefully.<\/p>\n
     \tThe :e<\/b> command can be given a +<\/b> argument to start at the end of the file, or a +<\/b>n<\/i> argument to start at line n<\/i>. In actuality, n<\/i> may be any editor command not containing a space, usefully a scan like +\/<\/b>pat<\/i> or +?<\/b>pat<\/i>. In forming new names to the e<\/b> command, you can use the character %<\/b> which is replaced by the current file name, or the character #<\/b> which is replaced by the alternate file name<\/i>. The alternate file name<\/i> is generally the last name you typed other than the current file. Thus if you try to do a :e<\/b> and get a diagnostic that you haven't written the file, you can give a :w<\/b> command and then a :e #<\/b> command to redo the previous :e<\/b>.<\/p>\n
     \tYou can write part of the buffer to a file by finding out the lines that bound the range to be written using ^G<\/b>, and giving these numbers after the :<\/b> and before the w<\/b>, separated by ,<\/b>'s. You can also mark these lines with m<\/b> and then use an address of the form '<\/b>x<\/i>,'<\/b>y<\/i> on the w<\/b> command here.<\/p>\n
     \tYou can read another file into the buffer after the current line by using the :r<\/b> command. You can similarly read in the output from a command, just use !cmd<\/b> instead of a file name.<\/p>\n
     \tIf you wish to edit a set of files in succession, you can give all the names on the command line, and then edit each one in turn using the command :n<\/b>. It is also possible to respecify the list of files to be edited by giving the :n<\/b> command a list of file names, or a pattern to be expanded as you would have given it on the initial vi<\/b> command.<\/p>\n
     \tIf you are editing large programs, you will find the :ta<\/b> command very useful. It utilizes a data base of function names and their locations, which can be created by programs such as ctags<\/b><\/a>, to quickly find a function whose name you give. If the :ta<\/b> command will require the editor to switch files, then you must :w<\/b> or abandon any changes before switching. You can repeat the :ta<\/b> command without any arguments to look for the same tag again.<\/p>\n
     \tMore About Searching For Strings<\/h2>\n
     \tWhen you are searching for strings in the file with \/<\/b> and ?<\/b>, the editor normally places you at the next or previous occurrence of the string. If you are using an operator such as d<\/b>, c<\/b> or y<\/b>, then you may well wish to affect lines up to the line before the line containing the pattern. You can give a search of the form \/<\/b>pat<\/i>\/-<\/b>n<\/i> to refer to the n<\/i>'th line before the next line containing pat<\/i>, or you can use +<\/b> instead of –<\/b> to refer to the lines after the one containing pat<\/i>. If you don't give a line offset, then the editor will affect characters up to the match place, rather than whole lines; thus use “+0<\/b>” to affect to the line which matches.<\/p>\n
     \tYou can have the editor ignore the case of words in the searches it does by giving the command :se ic<\/b>. The command :se noic<\/b> turns this off.<\/p>\n
     \tStrings given to searches may actually be regular expressions<\/a>. If you do not want or need this facility, you should<\/p>\n
    set nomagic<\/pre>\n
     \tin your EXINIT<\/b>. In this case, only the characters ^<\/b> and $<\/b> are special in patterns. The character \\<\/b> is also then special (as it is most everywhere in the system), and may be used to get at the an extended pattern matching facility. It is also necessary to use a \\<\/b> before a \/<\/b> in a forward scan or a ?<\/b> in a backward scan, in any case. The following table gives the extended forms when magic is set.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t^<\/b><\/td>\n \t\t\t\tat beginning of pattern, matches beginning of line<\/td>\n<\/tr>\n
     \t\t\t\t$<\/b><\/td>\n \t\t\t\tat end of pattern, matches end of line<\/td>\n<\/tr>\n
     \t\t\t\t.<\/b><\/td>\n \t\t\t\tmatches any character<\/td>\n<\/tr>\n
     \t\t\t\t\\<<\/b><\/td>\n \t\t\t\tmatches the beginning of a word<\/td>\n<\/tr>\n
     \t\t\t\t\\><\/b><\/td>\n \t\t\t\tmatches the end of a word<\/td>\n<\/tr>\n
     \t\t\t\t[<\/b>str<\/i>]<\/b><\/td>\n \t\t\t\tmatches any single character in str<\/i><\/td>\n<\/tr>\n
     \t\t\t\t[<\/b>str<\/i>]<\/b><\/td>\n \t\t\t\tmatches any single character not in str<\/i><\/td>\n<\/tr>\n
     \t\t\t\t[<\/b>x<\/i>–<\/b>y<\/i>]<\/b><\/td>\n \t\t\t\tmatches any character between x<\/i> and y<\/i><\/td>\n<\/tr>\n
     \t\t\t\t*<\/b><\/td>\n \t\t\t\tmatches any number of the preceding pattern<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tIf you use nomagic<\/b> mode, then the . [<\/b> and *<\/b> primitives are given with a preceding \\<\/b>.<\/p>\n
     \tMore About Input Mode<\/h2>\n
     \tThere are a number of characters which you can use to make corrections during input mode. These are summarized in the following table.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t^H<\/b><\/td>\n \t\t\t\tdeletes the last input character<\/td>\n<\/tr>\n
     \t\t\t\t^W<\/b><\/td>\n \t\t\t\tdeletes the last input word, defined as by b<\/b><\/td>\n<\/tr>\n
     \t\t\t\terase<\/td>\n \t\t\t\tyour erase character, same as ^H<\/b><\/td>\n<\/tr>\n
     \t\t\t\tkill<\/td>\n \t\t\t\tyour kill character, deletes the input on this line<\/td>\n<\/tr>\n
     \t\t\t\t\\<\/b><\/td>\n \t\t\t\tescapes a following ^H<\/b> and your erase and kill<\/td>\n<\/tr>\n
     \t\t\t\tESC<\/td>\n \t\t\t\tends an insertion<\/td>\n<\/tr>\n
     \t\t\t\tDEL<\/td>\n \t\t\t\tinterrupts an insertion, terminating it abnormally<\/td>\n<\/tr>\n
     \t\t\t\tCR<\/td>\n \t\t\t\tstarts a new line<\/td>\n<\/tr>\n
     \t\t\t\t^D<\/b><\/td>\n \t\t\t\tbacktabs over autoindent<\/td>\n<\/tr>\n
     \t\t\t\t0^D<\/b><\/td>\n \t\t\t\tkills all the autoindent<\/td>\n<\/tr>\n
     \t\t\t\t^^D<\/b><\/td>\n \t\t\t\t(caret-control-D) same as 0^D<\/b>, but restores indent next line<\/td>\n<\/tr>\n
     \t\t\t\t^V<\/b><\/td>\n \t\t\t\tquotes the next non-printing character into the file<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tThe most usual way of making corrections to input is by typing ^H<\/b> to correct a single character, or by typing one or more ^W<\/b>'s to back over incorrect words. If you use #<\/b> as your erase character in the normal system, it will work like ^H<\/b>.<\/p>\n
     \tYour system kill character, normally @<\/b>, ^X<\/b> or ^U<\/b>, will erase all the input you have given on the current line. In general, you can neither erase input back around a line boundary nor can you erase characters which you did not insert with this insertion command. To make corrections on the previous line after a new line has been started you can hit ESC to end the insertion, move over and make the correction, and then return to where you were to continue. The command A<\/b> which appends at the end of the current line is often useful for continuing.<\/p>\n
     \tIf you wish to type in your erase or kill character (say #<\/b> or @<\/b>) then you must precede it with a \\<\/b>, just as you would do at the normal system command level. A more general way of typing non-printing characters into the file is to precede them with a ^V<\/b>. The ^V<\/b> echoes as a ^<\/b> character on which the cursor rests. This indicates that the editor expects you to type a control character. In fact you may type any character and it will be inserted into the file at that point.<\/p>\n
     \tIf you are using autoindent<\/b> you can backtab over the indent which it supplies by typing a ^D<\/b>. This backs up to a shiftwidth<\/b> boundary. This only works immediately after the supplied autoindent<\/b>.<\/p>\n
     \tWhen you are using autoindent<\/b> you may wish to place a label at the left margin of a line. The way to do this easily is to type ^<\/b> and then ^D<\/b>. The editor will move the cursor to the left margin for one line, and restore the previous indent on the next. You can also type a 0<\/b> followed immediately by a ^D<\/b> if you wish to kill all the indent and not have it come back on the next line.<\/p>\n
     \tUppercase-Only Terminals<\/h2>\n
     \tIf your terminal has only upper case, you can still use vi<\/b> by using the normal system convention for typing on such a terminal. Characters which you normally type are converted to lower case, and you can type upper case letters by preceding them with a \\<\/b>. The characters {<\/b> ~<\/b> }<\/b> |<\/b> `<\/b> are not available on such terminals, but you can escape them as \\(<\/b> \\^<\/b> \\)<\/b> \\!<\/b> \\'<\/b>. These characters are represented on the display in the same way they are typed.<\/p>\n
     \tVi and Ex<\/h2>\n
     \tvi<\/b> is actually one mode of editing within the editor ex<\/b><\/a>. When you are running vi<\/b> you can escape to the line oriented editor of ex<\/b> by giving the command Q<\/b>. All of the :<\/b> commands which were introduced above are available in ex<\/b>. Likewise, most ex<\/b> commands can be invoked from vi<\/b> using :<\/b>. Just give them without the :<\/b> and follow them with a CR.<\/p>\n
     \tIn rare instances, an internal error may occur in vi<\/b>. In this case you will get a diagnostic and be left in the command mode of ex<\/b>. You can then save your work and quit if you wish by giving a command x<\/b> after the :<\/b> which ex<\/b> prompts you with, or you can reenter vi<\/b> by giving ex<\/b> a vi<\/b> command.<\/p>\n
     \tThere are a number of things which you can do more easily in ex<\/b> than in vi<\/b>. Systematic changes in line-oriented material are particularly easy. You can read the advanced editing documents for the editor ed<\/b> to find out a lot more about this style of editing. Experienced users often mix their use of ex<\/b> command mode and vi<\/b> command mode to speed the work they are doing.<\/p>\n
     \t<\/a>Quick Reference<\/h1>\n
     \tThis is a summary of all the most useful vi<\/b> commands. Refer to it any time you need to remember any of vi<\/b>'s functions quickly, and at a glance.<\/p>\n
     \tEntering\/Leaving the Editor<\/h2>\n
     \tFrom the command line:<\/p>\n\n\n\n\n\n\n\n\n\n
     \t\t\t\tvi<\/b> name<\/i><\/td>\n \t\t\t\tlaunch vi<\/b>, and load the file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> +<\/b> n<\/i> name<\/i><\/td>\n \t\t\t\tlaunch vi<\/b>, and load file name<\/i>, placing the cursor at line n<\/i><\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> -t<\/b> tag<\/i><\/td>\n \t\t\t\tlaunch vi<\/b>, and start editing at tag<\/i><\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> -r<\/b><\/td>\n \t\t\t\tlist files that can be recovered<\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> -r<\/b> name<\/i><\/td>\n \t\t\t\tlaunch vi<\/b>, and recover previously-edited file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> name1<\/i> name2<\/i> …<\/b><\/td>\n \t\t\t\tlaunch vi<\/b>, loading file name1<\/i> for editing; any other files named are loaded with the :n<\/b> command<\/td>\n<\/tr>\n
     \t\t\t\tvi<\/b> -R<\/b> name<\/i><\/td>\n \t\t\t\tlaunch vi<\/b>, and load file name<\/i> in read-only<\/a> mode<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tFrom within vi<\/b>:<\/p>\n\n\n\n\n
     \t\t\t\tZZ<\/b><\/td>\n \t\t\t\texit from vi<\/b>, saving changes<\/td>\n<\/tr>\n
     \t\t\t\t^Z<\/b><\/td>\n \t\t\t\tbackground vi<\/b> and return to the command shell. Resume foreground vi<\/b> operation with the fg<\/b> shell builtin command<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tFile Manipulation<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t:w<\/b><\/td>\n \t\t\t\twrite changes (save the file)<\/td>\n<\/tr>\n
     \t\t\t\t:wq<\/b><\/td>\n \t\t\t\twrite changes (save) and quit<\/td>\n<\/tr>\n
     \t\t\t\t:q<\/b><\/td>\n \t\t\t\tquit immediately, if there are no unsaved changes<\/td>\n<\/tr>\n
     \t\t\t\t:q!<\/b><\/td>\n \t\t\t\tquit immediately, discarding any unsaved changes<\/td>\n<\/tr>\n
     \t\t\t\t:e<\/b> name<\/i><\/td>\n \t\t\t\tedit file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:e!<\/b><\/td>\n \t\t\t\trevert to the last-saved version of the current file<\/td>\n<\/tr>\n
     \t\t\t\t:e<\/b> +<\/b> name<\/i><\/td>\n \t\t\t\tload file name<\/i> for editing, placing the cursor at the end of the file<\/td>\n<\/tr>\n
     \t\t\t\t:e<\/b> +<\/b>n<\/i> name<\/i><\/td>\n \t\t\t\tload file name<\/i> for editing, starting at line n<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:e<\/b> #<\/b><\/td>\n \t\t\t\tedit alternate file<\/td>\n<\/tr>\n
     \t\t\t\t^^<\/b><\/td>\n \t\t\t\t(control-caret). synonym for :e #<\/b><\/td>\n<\/tr>\n
     \t\t\t\t:w<\/b> name<\/i><\/td>\n \t\t\t\twrite to file name<\/i> (save as…)<\/td>\n<\/tr>\n
     \t\t\t\t:w!<\/b> name<\/i><\/td>\n \t\t\t\toverwrite file name<\/i><\/td>\n<\/tr>\n
     \t\t\t\t:sh<\/b><\/td>\n \t\t\t\tdrop to command line shell; ^D<\/b> to return<\/td>\n<\/tr>\n
     \t\t\t\t:!<\/b>cmd<\/i><\/td>\n \t\t\t\trun shell command cmd<\/i>, then return to vi<\/b><\/td>\n<\/tr>\n
     \t\t\t\t:n<\/b><\/td>\n \t\t\t\tedit next file that was specified as an argument to vi<\/b><\/td>\n<\/tr>\n
     \t\t\t\t:n<\/b> args<\/i><\/td>\n \t\t\t\tspecify new argument list of files for vi<\/b> to edit<\/td>\n<\/tr>\n
     \t\t\t\t:f<\/b><\/td>\n \t\t\t\tshow current file being edited, and current line count<\/td>\n<\/tr>\n
     \t\t\t\t^G<\/b><\/td>\n \t\t\t\tsynonym for :f<\/b><\/td>\n<\/tr>\n
     \t\t\t\t:ta<\/b> tag<\/i><\/td>\n \t\t\t\tto tag file entry tag<\/i><\/td>\n<\/tr>\n
     \t\t\t\t^]<\/b><\/td>\n \t\t\t\tsame as :ta<\/b>, and the following word is the tag<\/i><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tPositioning Within File<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t^F<\/b><\/td>\n \t\t\t\tposition forward one screenful<\/td>\n<\/tr>\n
     \t\t\t\t^B<\/b><\/td>\n \t\t\t\tposition backward one screenful<\/td>\n<\/tr>\n
     \t\t\t\t^D<\/b><\/td>\n \t\t\t\tscroll down one half-screenful<\/td>\n<\/tr>\n
     \t\t\t\t^U<\/b><\/td>\n \t\t\t\tscroll up one half-screenful<\/td>\n<\/tr>\n
     \t\t\t\tnum<\/i>G<\/b><\/td>\n \t\t\t\tgoto line num<\/i> (the last line if num<\/i> not specified)<\/td>\n<\/tr>\n
     \t\t\t\t\/<\/b>pat<\/i><\/td>\n \t\t\t\tsearch for next occurrence of pattern pat<\/i><\/td>\n<\/tr>\n
     \t\t\t\t?<\/b>pat<\/i><\/td>\n \t\t\t\tsearch for previous occurrence of pattern pat<\/i><\/td>\n<\/tr>\n
     \t\t\t\tn<\/b><\/td>\n \t\t\t\trepeat last search, in last search direction<\/td>\n<\/tr>\n
     \t\t\t\tN<\/b><\/td>\n \t\t\t\trepeat last search, in the opposite of last search direction<\/td>\n<\/tr>\n
     \t\t\t\t\/<\/b>pat<\/i>\/+<\/b>n<\/i><\/td>\n \t\t\t\tsearch to the n<\/i>th line after next occurrence of pattern pat<\/i><\/td>\n<\/tr>\n
     \t\t\t\t?<\/b>pat<\/i>?-<\/b>n<\/i><\/td>\n \t\t\t\tsearch to the n<\/i>th line before the previous occurence of pattern pat<\/i><\/td>\n<\/tr>\n
     \t\t\t\t]]<\/b><\/td>\n \t\t\t\tmove to next section\/function<\/td>\n<\/tr>\n
     \t\t\t\t[[<\/b><\/td>\n \t\t\t\tmove to previous section\/function<\/td>\n<\/tr>\n
     \t\t\t\t%<\/b><\/td>\n \t\t\t\tfind matching (<\/b>, )<\/b>, {<\/b>, or }<\/b><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tInsert and Replace<\/h2>\n
     \tThe ESC<\/b> key exits each of the following text-entry modes, except for r<\/b>, which is only used to enter a single character.<\/p>\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\ti<\/b><\/td>\n \t\t\t\tinsert mode: text is inserted before the cursor<\/td>\n<\/tr>\n
     \t\t\t\ta<\/b><\/td>\n \t\t\t\tappend mode: text is appended after the cursor<\/td>\n<\/tr>\n
     \t\t\t\tA<\/b><\/td>\n \t\t\t\ttext is appended at the end of the line<\/td>\n<\/tr>\n
     \t\t\t\tI<\/b><\/td>\n \t\t\t\ttext is inserted at the beginning of the line<\/td>\n<\/tr>\n
     \t\t\t\to<\/b><\/td>\n \t\t\t\topen a new line, after the current line, for text entry<\/td>\n<\/tr>\n
     \t\t\t\tO<\/b><\/td>\n \t\t\t\topen a new line, before the current line, for text entry<\/td>\n<\/tr>\n
     \t\t\t\tr<\/b>x<\/i><\/td>\n \t\t\t\treplace a the character under the cursor with character x<\/i><\/td>\n<\/tr>\n
     \t\t\t\tR<\/b><\/td>\n \t\t\t\treplace multiple characters<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tLine Positioning<\/h2>\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\tH<\/b><\/td>\n \t\t\t\tmove cursor to the first ("home") line of the window<\/td>\n<\/tr>\n
     \t\t\t\tL<\/b><\/td>\n \t\t\t\tmove cursor to the last line of the window<\/td>\n<\/tr>\n
     \t\t\t\tM<\/b><\/td>\n \t\t\t\tmove cursor to the middle line of the window<\/td>\n<\/tr>\n
     \t\t\t\t+<\/b><\/td>\n \t\t\t\tmove cursor to the first non-whitespace character of the next line<\/td>\n<\/tr>\n
     \t\t\t\t–<\/b><\/td>\n \t\t\t\tmove cursor to the first non-whitespace character of the previous line<\/td>\n<\/tr>\n
     \t\t\t\tCR<\/b><\/td>\n \t\t\t\t(carriage return\/the Enter key.) same as +<\/b><\/td>\n<\/tr>\n
     \t\t\t\tdown<\/b> or j<\/b><\/td>\n \t\t\t\tnext line, same column<\/td>\n<\/tr>\n
     \t\t\t\tup<\/b> or k<\/b><\/td>\n \t\t\t\tprevious line, same column<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tCharacter Positioning<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t^<\/b><\/td>\n \t\t\t\tmove cursor to first non-whitespace character on the line<\/td>\n<\/tr>\n
     \t\t\t\t0<\/b><\/td>\n \t\t\t\tmove cursor to beginning of line<\/td>\n<\/tr>\n
     \t\t\t\t$<\/b><\/td>\n \t\t\t\tmove cursor to end of line<\/td>\n<\/tr>\n
     \t\t\t\tright<\/b> or l<\/b> or SPACE<\/b><\/td>\n \t\t\t\tmove cursor forward one character<\/td>\n<\/tr>\n
     \t\t\t\tleft<\/b> or h<\/b> or ^H<\/b><\/td>\n \t\t\t\tmove cursor back one character<\/td>\n<\/tr>\n
     \t\t\t\tf<\/b>x<\/i><\/td>\n \t\t\t\tfind the next occurrence of character x<\/i> in the line<\/td>\n<\/tr>\n
     \t\t\t\tF<\/b>x<\/i><\/td>\n \t\t\t\tfind the previous occurrence of character x<\/i> in the line<\/td>\n<\/tr>\n
     \t\t\t\tt<\/b>x<\/i><\/td>\n \t\t\t\tmove up to x<\/i> forward<\/td>\n<\/tr>\n
     \t\t\t\tT<\/b>x<\/i><\/td>\n \t\t\t\tmove back to x<\/i> backward<\/td>\n<\/tr>\n
     \t\t\t\t;<\/b><\/td>\n \t\t\t\trepeat last f<\/b>, F<\/b>, t<\/b>, or T<\/b><\/td>\n<\/tr>\n
     \t\t\t\t,<\/b><\/td>\n \t\t\t\tinverse of ;<\/b><\/td>\n<\/tr>\n
     \t\t\t\tnum<\/i>|<\/b><\/td>\n \t\t\t\tMove to column num<\/i><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tOperators<\/h2>\n
     \t(Each of these commands can be used twice to affect entire lines):<\/p>\n\n\n\n\n\n\n\n\n\n
     \t\t\t\td<\/b><\/td>\n \t\t\t\tdelete<\/td>\n<\/tr>\n
     \t\t\t\tc<\/b><\/td>\n \t\t\t\tchange (like delete, but places you in insert mode to enter the text it should change to)<\/td>\n<\/tr>\n
     \t\t\t\t<<\/b><\/td>\n \t\t\t\tshift line left shiftwidth<\/b> number of spaces<\/td>\n<\/tr>\n
     \t\t\t\t><\/b><\/td>\n \t\t\t\tshift line right shiftwidth<\/b> number of spaces<\/td>\n<\/tr>\n
     \t\t\t\t!<\/b>(movement-command)<\/i>shell-command<\/i><\/td>\n \t\t\t\tfilter text through a shell command<\/td>\n<\/tr>\n
     \t\t\t\t=<\/b><\/td>\n \t\t\t\tindent for LISP<\/td>\n<\/tr>\n
     \t\t\t\ty<\/b><\/td>\n \t\t\t\tyank lines into buffer<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tWords, Sentences, Paragraphs<\/h2>\n\n\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\tw<\/b><\/td>\n \t\t\t\tword forward<\/td>\n<\/tr>\n
     \t\t\t\tb<\/b><\/td>\n \t\t\t\tword backward<\/td>\n<\/tr>\n
     \t\t\t\te<\/b><\/td>\n \t\t\t\tend of word<\/td>\n<\/tr>\n
     \t\t\t\t)<\/b><\/td>\n \t\t\t\tto next sentence break<\/td>\n<\/tr>\n
     \t\t\t\t}<\/b><\/td>\n \t\t\t\tto next paragraph break<\/td>\n<\/tr>\n
     \t\t\t\t(<\/b><\/td>\n \t\t\t\tto previous sentence break<\/td>\n<\/tr>\n
     \t\t\t\t{<\/b><\/td>\n \t\t\t\tto previous paragraph break<\/td>\n<\/tr>\n
     \t\t\t\tW<\/b><\/td>\n \t\t\t\tto next blank-delimited word<\/td>\n<\/tr>\n
     \t\t\t\tB<\/b><\/td>\n \t\t\t\tto previous blank-delimited word<\/td>\n<\/tr>\n
     \t\t\t\tE<\/b><\/td>\n \t\t\t\tto end of blank-delimited word<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tYank to Buffer, and Paste from Buffer<\/h2>\n\n\n\n\n\n\n\n
     \t\t\t\tp<\/b><\/td>\n \t\t\t\tpaste after cursor<\/td>\n<\/tr>\n
     \t\t\t\tP<\/b><\/td>\n \t\t\t\tpaste before cursor<\/td>\n<\/tr>\n
     \t\t\t\t"<\/b>x<\/i>p<\/b><\/td>\n \t\t\t\tpaste from buffer x<\/i><\/td>\n<\/tr>\n
     \t\t\t\t"<\/b>x<\/i>y<\/b><\/td>\n \t\t\t\tyank into buffer x<\/i><\/td>\n<\/tr>\n
     \t\t\t\t"<\/b>x<\/i>d<\/b><\/td>\n \t\t\t\tdelete into buffer x<\/i><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tUndo, Redo, Retrieve<\/h2>\n\n\n\n\n\n\n
     \t\t\t\tu<\/b><\/td>\n \t\t\t\tundo last change<\/td>\n<\/tr>\n
     \t\t\t\tU<\/b><\/td>\n \t\t\t\trestore current line<\/td>\n<\/tr>\n
     \t\t\t\t.<\/b><\/td>\n \t\t\t\trepeat last change<\/td>\n<\/tr>\n
     \t\t\t\t"<\/b>d<\/i>p<\/b><\/td>\n \t\t\t\tretrieve d<\/i>th last delete<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tMarking and Returning<\/h2>\n\n\n\n\n\n\n\n
     \t\t\t\t“<\/b><\/td>\n \t\t\t\tgo to previous location<\/td>\n<\/tr>\n
     \t\t\t\t''<\/b><\/td>\n \t\t\t\tgo to previous location, at first non-whitespace in line<\/td>\n<\/tr>\n
     \t\t\t\tm<\/b>x<\/i><\/td>\n \t\t\t\tMark position with letter x<\/i><\/td>\n<\/tr>\n
     \t\t\t\t`<\/b>x<\/i><\/td>\n \t\t\t\tmove to the position marked x<\/i><\/td>\n<\/tr>\n
     \t\t\t\t'<\/b>x<\/i><\/td>\n \t\t\t\tmove to the position marked x<\/i>, at the first non-whitespace character in the line<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tMiscellaneous Operations<\/h2>\n\n\n\n\n\n\n\n\n\n\n
     \t\t\t\tC<\/b><\/td>\n \t\t\t\tchange rest of line<\/td>\n<\/tr>\n
     \t\t\t\tD<\/b><\/td>\n \t\t\t\tdelete rest of line<\/td>\n<\/tr>\n
     \t\t\t\ts<\/b><\/td>\n \t\t\t\tsubstitute characters<\/td>\n<\/tr>\n
     \t\t\t\tS<\/b><\/td>\n \t\t\t\tsubstitute lines<\/td>\n<\/tr>\n
     \t\t\t\tJ<\/b><\/td>\n \t\t\t\tjoin lines<\/td>\n<\/tr>\n
     \t\t\t\tx<\/b><\/td>\n \t\t\t\tdelete a single character<\/td>\n<\/tr>\n
     \t\t\t\tX<\/b><\/td>\n \t\t\t\tdelete a single character before<\/i> the cursor<\/td>\n<\/tr>\n
     \t\t\t\tY<\/b><\/td>\n \t\t\t\tyank a line; same as yy<\/b><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tAdjusting the Screen<\/h2>\n\n\n\n\n\n\n\n\n\n
     \t\t\t\t^L<\/b><\/td>\n \t\t\t\tclear and redraw<\/td>\n<\/tr>\n
     \t\t\t\tz<\/b>(Enter)<\/td>\n \t\t\t\tredraw screen with current line at top<\/td>\n<\/tr>\n
     \t\t\t\tz-<\/b><\/td>\n \t\t\t\tredraw screen with current line at bottom<\/td>\n<\/tr>\n
     \t\t\t\tz.<\/b><\/td>\n \t\t\t\tredraw screen with current line at center<\/td>\n<\/tr>\n
     \t\t\t\tzz<\/b><\/td>\n \t\t\t\tsame as z.<\/b><\/td>\n<\/tr>\n
     \t\t\t\t^E<\/b><\/td>\n \t\t\t\tscroll window down one line (but don't move cursor)<\/td>\n<\/tr>\n
     \t\t\t\t^Y<\/b><\/td>\n \t\t\t\tscroll window up one line (but don't move cursor)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \tUseful Command Combinations<\/h2>\n\n\n\n\n\n\n\n\n\n
     \t\t\t\tdw<\/b><\/td>\n \t\t\t\tdelete a word<\/td>\n<\/tr>\n
     \t\t\t\tde<\/b><\/td>\n \t\t\t\tdelete a word, leaving any of its punctuation intact<\/td>\n<\/tr>\n
     \t\t\t\tdd<\/b><\/td>\n \t\t\t\tdelete a line<\/td>\n<\/tr>\n
     \t\t\t\t3dd<\/b><\/td>\n \t\t\t\tdelete 3 lines (for example)<\/td>\n<\/tr>\n
     \t\t\t\tcw<\/b>new<\/i><\/td>\n \t\t\t\tchange word to new<\/i><\/td>\n<\/tr>\n
     \t\t\t\teas<\/b><\/td>\n \t\t\t\tpluralize a word (stick an s at the end of it)<\/td>\n<\/tr>\n
     \t\t\t\txp<\/b><\/td>\n \t\t\t\ttranspose two characters<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
     \t<\/a>Examples<\/h2>\n
    vi myfile.txt<\/pre>\n
     \tEdits the file myfile.txt<\/b>.<\/p>\n
     \t <\/p>\n
     \t <\/p>\n<\/article>\n<\/section>\n","protected":false},"excerpt":{"rendered":"
    Linux and Unix vi command Quick links About Vi Syntax Using Vi Moving Around in Vi Making Simple Changes Rearranging and Duplicating Text High Level Commands Special Topics Technical Details Quick Reference Examples Related commands Linux and Unix main page About vi Originally developed by William Joy in the late 1970s, vi (pronounced "vee-eye") is…<\/p>\n","protected":false},"author":1,"featured_media":258,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6],"tags":[],"class_list":["post-259","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux"],"_links":{"self":[{"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/posts\/259","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=259"}],"version-history":[{"count":1,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/posts\/259\/revisions"}],"predecessor-version":[{"id":382,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/posts\/259\/revisions\/382"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=\/wp\/v2\/media\/258"}],"wp:attachment":[{"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=259"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=259"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/notiz.comanet.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=259"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}