Section 9.7. Alphabetical Summary of ex Commands


9.7. Alphabetical Summary of ex Commands

ex commands can be entered by specifying any unique abbreviation. In this listing, the full name appears in the margin, and the shortest possible abbreviation is used in the syntax line. Examples are assumed to be typed from vi, so they include the : prompt.

abbreviate

      ab [string text] 

Define string when typed to be translated into text. If string and text are not specified, list all current abbreviations.

Examples

Note: ^M appears when you type ^V followed by Enter.

     :ab ora O'Reilly Media, Inc.     :ab id Name:^MRank:^MPhone: 

append

     [address] a[!]     text     . 

Append new text at specified address, or at present address if none is specified. Add a ! to toggle the autoindent setting that is used during input. That is, if autoindent was enabled, ! disables it. Enter new text after entering the command. Terminate input of new text by entering a line consisting of just a period.

Example

     :a                  Begin appending to current line.     Append this line     and this line too.     .                  Terminate input of text to append. 

args

     ar     args file ... 

Print the members of the argument list (files named on the command line), with the current argument printed in brackets ([ ]).

The second syntax is for vim, which allows you to reset the list of files to be edited.

bdelete

     [num] bd[!] [num] 

Unload buffer num and remove it from the buffer list. Add a ! to force removal of an unsaved buffer. The buffer may also be specified by filename. If no buffer is specified, remove the current buffer. {vim}

buffer

     [num] b[!] [num] 

Begin editing buffer num in the buffer list. Add a ! to force a switch from an unsaved buffer. The buffer may also be specified by filename. If no buffer is specified, continue editing the current buffer. {vim}

buffers

     buffers[!] 

Print the members of the buffer list. Some buffers (e.g., deleted buffers) will not be listed. Add ! to show unlisted buffers. ls is another abbreviation for this command. {vim}

cd

     cd dir     chdir dir 

Change current directory within the editor to dir.

center

     [address] ce [width] 

Center line within the specified width. If width is not specified, use textwidth. {vim}

change

     [address] c[!]     text     . 

Replace the specified lines with text. Add a ! to switch the autoindent setting during input of text. Terminate input by entering a line consisting of just a period.

close

     clo[!] 

Close current window unless it is the last window. If buffer in window is not open in another window, unload it from memory. This command will not close a buffer with unsaved changes, but you may add ! to hide it instead. {vim}

copy

     [address] co destination 

Copy the lines included in address to the specified destination address. The command t (short for "to") is a synonym for copy.

Example

          :1,10 co 50        Copy first 10 lines to just after line 50 

delete

     [address] d [register] 

Delete the lines included in address. If register is specified, save or append the text to the named register. Register names are the lowercase letters a-z. Uppercase names append text to the corresponding register.

Examples

     :/Part I/,/Part II/-1d      Delete to line above "Part II"          :/main/+d     Delete line below "main"     :.,$d x       Delete from this line to last line into                                           register x 

edit

     e[!] [+num] [filename] 

Begin editing on filename. If no filename is given, start over with a copy of the current file. Add a ! to edit the new file even if the current file has not been saved since the last change. With the +num argument, begin editing on line num. Or num may be a pattern, of the form /pattern.

Examples

     :e file          Edit file in current editing buffer     :e +/^Index #    Edit alternate file at pattern match     :e!              Start over again on current file 

file

     f [filename] 

Change the filename for the current buffer to filename. The next time the buffer is written, it will be written to file filename. When the name is changed, the buffer's "not edited" flag is set, to indicate you are not editing an existing file. If the new filename is the same as a file that already exists on the disk, you will need to use :w! to overwrite the existing file. When specifying a filename, the % character can be used to indicate the current filename. A # can be used to indicate the alternate filename. If no filename is specified, print the current name and status of the buffer.

Example

          :f%.new 

fold

          address fo 

Fold the lines specified by address. A fold collapses several lines on the screen into one line, which later can be unfolded. It doesn't affect the text of the file. {vim}

foldclose

     [address] foldc[!] 

Close folds in specified address, or at present address if none is specified. Add a ! to close more than one level of folds. {vim}

foldopen

     [address] foldo[!] 

Open folds in specified address, or at present address if none is specified. Add a ! to open more than one level of folds. {vim}

global

     [address] g[!]/pattern/[commands] 

Execute commands on all lines which contain pattern or, if address is specified, on all lines within that range. If commands are not specified, print all such lines. Add a ! to execute commands on all lines not containing pattern. See also v.

Examples

     :g/Unix/p            Print all lines containing "Unix"     :g/Name:/s/tom/Tom/   Change "tom" to "Tom" on all lines                                         containing "Name:" 

hide

     hid 

Close current window unless it is the last window, but do not remove the buffer from memory. This is a safe command to use on an unsaved buffer. {vim}

insert

     [address] i[!]     text     . 

Insert text at line before the specified address, or at present address if none is specified. Add a ! to switch the autoindent setting during input of text. Terminate input of new text by entering a line consisting of just a period.

join

     [address] j[!] [count] 

Place the text in the specified range on one line, with whitespace adjusted to provide two space characters after a period (.), no space characters before a ), and one space character otherwise. Add a ! to prevent whitespace adjustment.

Example

     :1,5j!   Join first five lines, preserving whitespace 

jumps

     ju 

Print jump list used with Ctrl-I and Ctrl-O commands. The jump list is a record of most movement commands that skip over multiple lines. It records the position of the cursor before each jump. {vim}

k

     [address] k char 

Same as mark; see mark, later in this list.

left

      [address] le [count] 

Left-align lines specified by address, or current line if no address is specified. Indent lines by count spaces. {vim}

list

      [address] l [count] 

Print the specified lines so that tabs display as ^I, and the ends of lines display as $. l is like a temporary version of :set list.

map

     map[!] [string commands] 

Define a keyboard macro named string as the specified sequence of commands. string is usually a single character, or the sequence #num, representing a function key on the keyboard. Use a ! to create a macro for input mode. With no arguments, list the currently defined macros.

Examples

     :map K dwwP         Transpose two words     :map q :w^M:n^M        Write current file; go to next     :map! + ^[bi(^[ea)    Enclose previous word in parentheses 

NOTE

vim has K and q commands, which the above aliases would hide.

mark

     [address] ma char 

Mark the specified line with char, a single lowercase letter. Return later to the line with 'x (where x is the same as char). vim also uses uppercase and numeric characters for marks. Lowercase letters work the same as in vi. Uppercase letters are associated with filenames and can be used between multiple files. Numbered marks, however, are maintained in a special viminfo file and cannot be set using this command. Same as k.

marks

     marks [chars] 

Print list of marks specified by chars, or all current marks if no chars specified. {vim}

Example

     :marks abc     Print marks a, b and c. 

mkexrc

     mk[!] file 

Create an .exrc file containing set commands for changed ex options and key mappings. This saves the current option settings, allowing you to restore them later.

move

     [address] m destination 

Move the lines specified by address to the destination address.

Example

          :.,/Note/m /END/        Move text block to after line containing "END" 

new

     [count] new 

Create a new window count lines high with an empty buffer. {vim}

next

     num[!] [[+num] filelist] 

Edit the next file from the command-line argument list. Use args to list these files. If filelist is provided, replace the current argument list with filelist and begin editing on the first file. With the +num argument, begin editing on line num. Or num may be a pattern, of the form /pattern.

Example

     :n chap*      Start editing all "chapter" files 

nohlsearch

     noh 

Temporarily stop highlighting all matches to a search when using the hlsearch option. Highlighting is resumed with the next search. {vim}

number

     [address] nu [count] 

Print each line specified by address, preceded by its buffer line number. Use # as an alternate abbreviation for number. count specifies the number of lines to show, starting with address.

only

     on [!] 

Make the current window be the only one on the screen. Windows open on modified buffers are not removed from the screen (hidden), unless you also use the ! character. {vim}

open

     [address] o [/pattern/] 

Enter open mode (vi) at the lines specified by address, or at the lines matching pattern. Exit open mode with Q. Open mode lets you use the regular vi commands, but only one line at a time. It can be useful on slow dial-up lines (or on very distant Internet ssh connections).

preserve

     pre 

Save the current editor buffer as though the system were about to crash.

previous

     prev[!] 

Edit the previous file from the command-line argument list. {vim}

print

     [address] p [count] 

Print the lines specified by address. count specifies the number of lines to print, starting with address. P is another abbreviation.

Example

     :100;+5p       Show line 100 and the next five lines 

put

     [address] pu [char] 

Restore previously deleted or yanked lines from named register specified by char, to the line specified by address. If char is not specified, the last deleted or yanked text is restored.

qall

     qa[!] 

Close all windows and terminate current editing session. Use ! to discard changes made since the last save. {vim}

quit

     q[!] 

Terminate current editing session. Use ! to discard changes made since the last save. If the editing session includes additional files in the argument list that were never accessed, quit by typing q! or by typing q twice. vim only closes the editing window if there are still other windows open on the screen.

read

     [address] r filename 

Copy the text of filename after the line specified by address. If filename is not specified, the current filename is used.

Example

     :0r $HOME/data         Read file in at top of current file 

read

     [address] r !command 

Read the output of shell command into the text after the line specified by address.

Example

     :$r !spell %            Place results of spell checking at end of file 

recover

     rec [file] 

Recover file from the system save area.

redo

     red 

Restore last undone change. Same as Ctrl-R. {vim}

resize

     res [[±]num] 

Resize current window to be num lines high. If + or - is specified, increase or decrease the current window height by num lines. {vim}

rewind

     rew[!] 

Rewind argument list and begin editing the first file in the list. Add a ! to rewind even if the current file has not been saved since the last change.

right

     [address] ri [width] 

Right-align lines specified by address, or current line if no address is specified, to column width. Use textwidth option if no width is specified. {vim}

sbnext

     [count] sbn [count] 

Split the current window and begin editing the count'th next buffer from the buffer list. If no count is specified, edit the next buffer in the buffer list. {vim}

sbuffer

     [num] sb [num] 

Split the current window and begin editing buffer num from the buffer list in the new window. The buffer to be edited may also be specified by filename. If no buffer is specified, open the current buffer in the new window. {vim}

set

      se parameter1     parameter2 ... 

Set a value to an option with each parameter, or, if no parameter is supplied, print all options that have been changed from their defaults. For boolean options, each parameter can be phrased as option or nooption; other options can be assigned with the syntax option=value. Specify all to list current settings. The form set option? displays the value of option. See the list of set options in the section The :set Command," earlier in this chapter.

Examples

          :set nows wm=10          :set all 

shell

     sh 

Create a new shell. Resume editing when the shell terminates.

snext

     [count] sn [[+num] filelist] 

Split the current window and begin editing the next file from the command-line argument list. If count is provided, edit the count'th next file. If filelist is provided, replace the current argument list with filelist and begin editing the first file. With the +n argument, begin editing on line num. Alternately, num may be a pattern of the form /pattern. {vim}

source

     so file 

Read (source) and execute ex commands from file.

Example

     :so $HOME/.exrc 

split

     [count] sp [+num] [filename] 

Split the current window and load filename in the new window, or the same buffer in both windows if no file is specified. Make the new window count lines high, or, if count is not specified, split the window into equal parts. With the +n argument, begin editing on line num. num may also be a pattern of the form /pattern. {vim}

sprevious

     [count] spr [+num] 

Split the current window and begin editing the previous file from the command-line argument list in the new window. If count is specified, edit the count'th previous file. With the +num argument, begin editing on line num. num may also be a pattern of the form /pattern. {vim}

stop

     st 

Suspend the editing session. Same as Ctrl-Z. Use the shell fg command to resume the session.

substitute

     [address] s [/pattern/replacement/] [options] [count] 

Replace the first instance of pattern on each of the specified lines with replacement. If pattern and replacement are omitted, repeat last substitution. count specifies the number of lines on which to substitute, starting with address. See additional examples in Chapter 7.

Options


c

Prompt for confirmation before each change.


g

Substitute all instances of pattern on each line (global).


p

Print the last line on which a substitution was made.

Examples

     :1,10s/yes/no/g      Substitute on first 10 lines     :%s/[Hh]ello/Hi/gc   Confirm global substitutions     :s/Fortran/\U&/ 3    Uppercase "Fortran" on next three lines     :g/^[0-9][0-9]*/s//Line &:/   For every line beginning with one or                                                 more digits, add "Line" and a colon 

suspend

     su 

Suspend the editing session. Same as Ctrl-Z. Use the shell fg command to resume the session.

sview

     [count] sv [+num] [filename] 

Same as the split command, but set the readonly option for the new buffer. {vim}

t

     [address] t destination 

Copy the lines included in address to the specified destination address. t is equivalent to copy.

Example

     :%t$       Copy the file and add it to the end 

tag

     [address] ta tag 

In the tags file, locate the file and line matching tag, and start editing there.

Example

Run ctags, then switch to the file containing myfunction:

     :!ctags *.c     :tag myfunction 

tags

     tags 

Print list of tags in the tag stack. {vim}

unabbreviate

     una word 

Remove word from the list of abbreviations.

undo

     u 

Reverse the changes made by the last editing command. In vi, the undo command will undo itself, redoing what you undid. vim supports multiple levels of undo. Use redo to redo an undone change in vim.

unhide

     [count] unh 

Split screen to show one window for each active buffer in the buffer list. If specified, limit the number of windows to count. {vim}

unmap

     unm[!] string 

Remove string from the list of keyboard macros. Use ! to remove a macro for input mode.

v

     [address] v/pattern/[command] 

Execute command on all lines not containing pattern. If command is not specified, print all such lines. v is equivalent to g!. See global.

Example

          :v/#include/d           Delete all lines except "#include" lines 

version

     ve 

Print the editor's current version number and date of last change.

view

     vie[[+num] filename] 

Same as edit, but set file to readonly. When executed in ex mode, return to normal or visual mode. {vim}

visual

     [address] vi [type] [count] 

Enter visual mode (vi) at the line specified by address. Return to ex mode with Q. type can be one of -, ^, or . (See the z command). count specifies an initial window size.

visual

     vi [+ num] file 

Begin editing file in visual mode (vi), optionally at line num.

vsplit

     [count] vs [+num] [filename] 

Same as the split command, but split the screen vertically. The count argument can be used to specify a width for the new window. {vim}

wall

     wa[!] 

Write all changed buffers with filenames. Add ! to force writing of any buffers marked readonly. {vim}

wnext

     [count] wn[!] [[+num] filename] 

Write current buffer and open next file in argument list, or the count'th next file if specified. If filename is specified, edit it next. With the +num argument, begin editing on line num. num may also be a pattern of the form /pattern. {vim}

write

     [address] w[!] [[>>] file] 

Write lines specified by address to file, or write full contents of buffer if address is not specified. If file is also omitted, save the contents of the buffer to the current filename. If >> file is used, append lines to the end of the specified file. Add a ! to force the editor to write over any current contents of file.

Examples

      :1,10w name_list      Copy first 10 lines to file name_list      :50w >> name_list       Now append line 50 

write

     [address] w !command 

Write lines specified by address to command.

Example

          :1,66w !pr -h myfile | lp           Print first page of file 

wq

     wq[!] 

Write and quit the file in one movement. The file is always written. The ! flag forces the editor to write over any current contents of file.

wqall

     wqa[!] 

Write all changed buffers and quit the editor. Add ! to force writing of any buffers marked readonly. xall is another alias for this command. {vim}

X

     X 

Prompt for an encryption key. This command can be preferable to :set key, as typing the key is not echoed to the console. To remove an encryption key, just reset the key option to an empty value. {vim}

xit

     x 

Write the file if it was changed since the last write, then quit.

yank

     [address] y [char] [count] 

Place lines specified by address in named register char. Register names are the lowercase letters a-z. Uppercase names append text to the corresponding register. If no char is given, place lines in general register. count specifies the number of lines to yank, starting with address.

Example

     :101,200 ya a      Copy lines 100-200 to register "a" 

z

     [address] z [type] [count] 

Print a window of text with the line specified by address at the top. count specifies the number of lines to be displayed.

Type


+

Place specified line at the top of the window (default).


-

Place specified line at the bottom of the window.


.

Place specified line in the center of the window.


^

Print the previous window.


=

Place specified line in the center of the window and leave the current line at this line.

!

     [address] !command 

Execute Unix command in a shell. If address is specified, use the lines contained in address as standard input to command, and replace the lines with the output and error output. (This is called filtering the text through the command.)

Examples

      :!ls             List files in the current directory      :11,20!sort -f   Sort lines 11-20 of current file 

=

     [address] = 

Print the line number of the line indicated by address. Default is line number of the last line.

< >

      [address] < [count]      [address] > [count] 

Shift lines specified by address either left (<) or right (>). Only leading spaces and tabs are added or removed when shifting lines. count specifies the number of lines to shift, starting with address. The shiftwidth option controls the number of columns that are shifted. Repeating the < or > increases the shift amount. For example, :>>> shifts three times as much as :>.

address

          address 

Print the lines specified in address.

Enter

Print the next line in the file. (For ex only; not from the : prompt in vi.)

@

     [address] @ [char] 

Execute contents of register specified by char. If address is given, move cursor to the specified address first. If char is @, repeat the last @ command.

&

     [address] & [options] [count] 

Repeat the previous substitute (s) command. count specifies the number of lines on which to substitute, starting with address. options are the same as for the substitute command.

Examples

     :s/Overdue/Paid/           Substitute once on current line     :g/Status/&            Redo substitution on all "Status" lines 

~

     [address] ~ [count] 

Replace the last-used regular expression (even if from a search, and not from an s command) with the replacement pattern from the most recent s (substitute) command. This is rather obscure; see Chapter 6 of Learning the vi Editor (O'Reilly) for details.



Linux in a Nutshell
Linux in a Nutshell
ISBN: 0596154488
EAN: 2147483647
Year: 2004
Pages: 147

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net