motion.txt - html version
motion.txt - html version
*motion.txt* For Vim version 5.3. Last modification: 1998 Aug 16
VIM REFERENCE MANUAL by Bram Moolenaar
Cursor motions *cursor-motions*
These commands move the cursor position. If the new position is off of the
screen, the screen is scrolled to show the cursor (see also 'scrolljump' and
'scrolloff' options).
1. Motions and operators |operator|
2. Left-right motions |left-right-motions|
3. Up-down motions |up-down-motions|
4. Word motions |word-motions|
5. Text object motions |object-motions|
6. Text object selection |object-select|
7. Various motions |various-motions|
1. motions and operators *operator*
The motion commands can be used after an operator command, to have the command
operate on the text that was moved over. That is the text between the cursor
position before and after the motion. Operators are generally used to delete
or change text. The following operators are available:
|c| c change
|d| d delete
|y| y yank into register (does not change the text)
|~| ~ swap case (only if 'tildeop' is set)
|g~| g~ swap case
|gu| gu make lower case
|gU| gU make upper case
|!| ! filter through an external program
|=| = filter through 'equalprg' or C-indenting if empty
|gq| gq text formatting
|>| > shift right
|<| < shift left
If the motion includes a count and the operator also had a count before it,
the two counts are multiplied. For example: "2d3w" deletes six words.
*linewise* *characterwise*
The operator either affects whole lines, or the characters between the start
and end position. Generally, motions that move between lines affect lines
(are linewise), and motions that move within a line affect characters (are
characterwise). However, there are some exceptions.
A character motion is either inclusive or exclusive. When inclusive, the start
and end position of the motion are included in the operation. When exclusive,
the last character towards the end of the buffer is not included. Linewise
motions always include the start and end position.
Which motions are linewise, inclusive or exclusive is mentioned below. There
are however, two general exceptions:
1. If the motion is exclusive and the end of the motion is in column 1, the
end of the motion is moved to the end of the previous line and the motion
becomes inclusive. Example: "}" ends at the first line after a paragraph,
but "V}" will not include that line.
2. If the motion is exclusive, the end of the motion is in column 1 and the
start of the motion was at or before the first non-blank in the line, the
motion becomes linewise. Example: If a paragraph begins with some blanks
and you do "d}" while standing on the first non-blank, all the lines of
the paragraph are deleted, including the blanks. If you do a put now, the
deleted lines will be inserted below the cursor position.
Note that when the operator is pending (the operator command is typed, but the
motion isn't yet), a special set of mappings can be used. See |:omap|.
Instead of first giving the operator and then a motion you can use Visual
mode: mark the start of the text with "v", move the cursor to the end of the
text that is to be affected and then hit the operator. The text between the
start and the cursor position is highlighted, so you can see what text will
be operated upon. This allows much more freedom, but requires more key
strokes and has limited redo functionality. See the chapter on Visual mode
|Visual-mode|.
If you want to know where you are in the file use the "CTRL-G" command
|CTRL-G| or the "g CTRL-G command |g_CTRL-G|. If you set the 'ruler' option,
the cursor position is continuously shown in the status line (which slows down
Vim a little).
NOTE: Experienced users prefer the hjkl keys because they are always right
under their fingers. Beginners often prefer the arrow keys, because they
do not know what the hjkl keys do. The mnemonic value of hjkl is clear from
looking at the keyboard. Think of j as an arrow pointing downwards.
2. Left-right motions *left-right-motions*
h or *h*
<Left> or *<Left>*
CTRL-H or *CTRL-H* *<BS>*
<BS> [count] characters to the left (exclusive).
Note: If you prefer <BS> to delete a character, use
the mapping:
:map CTRL-V<BS> X
(to enter "CTRL-V<BS>" type the CTRL-V key, followed
by the <BS> key)
See |:fixdel| if the <BS> key does not do what you
want.
l or *l*
<Right> or *<Right>* *<Space>*
<Space> [count] characters to the right (exclusive).
*0*
0 To the first character of the line (exclusive). When
moving up or down, stay in same screen column (if
possible).
*<Home>* *<kHome>*
<Home> To the first character of the line (exclusive). When
moving up or down, stay in same text column (if
possible). Works like "1|", which differs from "0"
when the line starts with a <Tab>. {not in Vi}
*^*
^ To the first non-blank character of the line
(exclusive).
*$* *<End>* *<kEnd>*
$ or <End> To the end of the line and [count - 1] lines downward
(inclusive).
*g0* *g<Home>*
g0 or g<Home> When lines wrap ('wrap on): To the first character of
the screen line (exclusive). Differs from "0" when a
line is wider than the screen.
When lines don't wrap ('wrap' off): To the leftmost
character of the current line that is on the screen.
Differs from "0" when the first character of the line
is not on the screen. {not in Vi}
*g^*
g^ When lines wrap ('wrap' on): To the first non-blank
character of the screen line (exclusive). Differs
from "^" when a line is wider than the screen.
When lines don't wrap ('wrap' off): To the leftmost
non-blank character of the current line that is on the
screen. Differs from "^" when the first non-blank
character of the line is not on the screen. {not in
Vi}
*g$* *g<End>*
g$ or g<End> When lines wrap ('wrap' on): To the last character of
the screen line and [count - 1] screen lines downward
(inclusive). Differs from "$" when a line is wider
than the screen.
When lines don't wrap ('wrap' off): To the rightmost
character of the current line that is visible on the
screen. Differs from "$" when the last character of
the line is not on the screen or when a count is used.
{not in Vi}
*bar*
| To screen column [count] in the current line
(exclusive).
*f*
f{char} To [count]'th occurrence of {char} to the right. The
cursor is placed on {char} (inclusive).
*F*
F{char} To the [count]'th occurrence of {char} to the left.
The cursor is placed on {char} (inclusive).
*t*
t{char} Till before [count]'th occurrence of {char} to the
right. The cursor is placed on the character left of
{char} (inclusive).
*T*
T{char} Till after [count]'th occurrence of {char} to the
left. The cursor is placed on the character right of
{char} (inclusive).
*;*
; Repeat latest f, t, F or T [count] times.
*,*
, Repeat latest f, t, F or T in opposite direction
[count] times.
These commands move the cursor to the specified column in the current line.
They stop at the first column and at the end of the line, except "$", which
may move to one of the next lines. See 'whichwrap' option to make some of the
commands move accross line boundaries.
3. Up-down motions *up-down-motions*
k or *k*
<Up> or *<Up>* *CTRL-P*
CTRL-P [count] lines upward (linewise).
j or *j*
<Down> or *<Down>*
CTRL-J or *CTRL-J*
<NL> or *<NL>* *CTRL-N*
CTRL-N [count] lines downward (linewise).
gk or *gk* *g<Up>*
g<Up> [count] display lines upward (exclusive). Differs
from 'k' when lines wrap, and when used with an
operator, because it's not linewise. {not in Vi}
gj or *gj* *g<Down>*
g<Down> [count] display lines downward (exclusive). Differs
from 'j' when lines wrap, and when used with an
operator, because it's not linewise. {not in Vi}
*-*
- <minus> [count] lines upward, on the first non-blank
character (linewise).
+ or *+*
CTRL-M or *CTRL-M* *<CR>*
<CR> [count] lines downward, on the first non-blank
character (linewise).
*_*
_ <underscore> [count] - 1 lines downward, on the first non-blank
character (linewise).
<C-End> or *G* *<C-End>*
G Goto line [count], default last line, on the first
non-blank character (linewise). If 'startofline' not
set, keep the same column.
<C-Home> or *gg* *<C-Home>*
gg Goto line [count], default first line, on the first
non-blank character (linewise). If 'startofline' not
set, keep the same column.
:[range] Set the cursor on the (last) specified line number
(cannot be used with an operator).
*N%*
{count}% Go to {count} percentage in the file, on the first
non-blank in the line (linewise). To compute the new
line number this formula is used: {count} *
number-of-lines / 100. See also 'startofline'
option. {not in Vi}
These commands move to the specified line. They stop when reaching the first
or the last line. The first two commands put the cursor in the same column
(if possible) as it was after the last command that changed the column,
except after the "$" command, then the cursor will be put on the last
character of the line.
4. Word motions *word-motions*
<S-Right> or *<S-Right>* *w*
w [count] words forward (exclusive).
<C-Right> or *<C-Right>* *W*
W [count] WORDS forward (exclusive).
*e*
e Forward to the end of word [count] (inclusive).
*E*
E Forward to the end of WORD [count] (inclusive).
<S-Left> or *<S-Left>* *b*
b [count] words backward (exclusive).
<C-Left> or *<C-Left>* *B*
B [count] WORDS backward (exclusive).
*ge*
ge Backward to the end of word [count] (inclusive).
*gE*
gE Backward to the end of WORD [count] (inclusive).
These commands move over words or WORDS.
*word*
A word consists of a sequence of letters, digits and underscores, or a
sequence of other non-blank characters, separated with white space (spaces,
tabs, <EOL>). This can be changed with the 'iskeyword' option.
*WORD*
A WORD consists of a sequence of non-blank characters, separated with white
space. An empty line is also considered to be a word and a WORD.
Special case: "cw" and "cW" are treated like "ce" and "cE" if the cursor is
on a non-blank. This is because "cw" is interpreted as change-word, and a
word does not include the following white space. {Vi: "cw" when on a blank
followed by other blanks changes only the first blank; this is probably a
bug, because "dw" deletes all the blanks}
Another special case: When using the "w" motion in combination with an
operator and the last word moved over is at the end of a line, the end of
that word becomes the end of the operated text, not the first word in the
next line.
The original Vi implementation of "e" is buggy. For example, the "e" command
will stop on the first character of a line if the previous line was empty.
But when you use "2e" this does not happen. In Vim "ee" and "2e" are the
same, which is more logical. However, this causes a small incompatibility
between Vi and Vim.
5. Text object motions *object-motions*
*(*
( [count] sentences backward (exclusive).
*)*
) [count] sentences forward (exclusive).
*{*
{ [count] paragraphs backward (exclusive).
*}*
} [count] paragraphs forward (exclusive).
*]]*
]] [count] sections forward or to the next '{' in the
first column. When used after an operator, then the
'}' in the first column. (linewise).
*][*
][ [count] sections forward or to the next '}' in the
first column (linewise).
*[[*
[[ [count] sections backward or to the previous '{' in
the first column (linewise).
*[]*
[] [count] sections backward or to the previous '}' in
the first column (linewise).
These commands move over three kinds of text objects.
*sentence*
A sentence is defined as ending at a '.', '!' or '?' followed by either the
end of a line, or by a space. {Vi: two spaces} Any number of closing ')',
']', '"'' and ''' characters my appear after the '.', '!' or '?' before the
spaces or end of line. A paragraph and section boundary is also a sentence
boundary. The definition of a sentence cannot be changed.
*paragraph*
A paragraph begins after each empty line, and also at each of a set of
paragraph macros, specified by the pairs of characters in the 'paragraphs'
option. The default is "IPLPPPQPP LIpplpipbp", which corresponds to the
macros ".IP", ".LP", etc. (These are nroff macros, so the dot must be in the
first column). A section boundary is also a paragraph boundary. Note that
this does not include a '{' or '}' in the first column.
*section*
A section begins after a form-feed (<C-L>) in the first column and at each of
a set of section macros, specified by the pairs of characters in the
'sections' option. The default is "SHNHH HUnhsh", which defines a section to
start at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh".
The "]" and "[" commands stop at the '{' or '}' in the first column. This is
useful to find the start or end of a function in a C program. Note that the
first character of the command determines the search direction and the
second character the type of brace found.
If your '{' or '}' are not in the first column, and you would like to use "[["
and "]]" anyway, try these mappings:
:map [[ ?{<CR>w99[{
:map ][ /}<CR>b99]}
:map ]] j0[[%/{<CR>
:map [] k$][%?}<CR>
[type these literally, see |<>|]
6. Text object selection *object-select* *text-objects*
This is a series of commands that can only be used while in Visual mode or
after an operator. The commands that start with "a" select "a"n object
including white space, the commands starting with "i" select an "inner" object
without white space, or just the white space. Thus the "inner" commands
always select less text than the "a" commands.
These commands are {not in Vi}.
These commands are not available when the |+textobjects| feature has been
disabled at compile time.
*v_aw*
aw "a word", select [count] words (see |word|).
Leading or trailing white space is included, but not
counted.
*v_iw*
iw "inner word", select [count] words (see |word|).
White space between words is counted too.
*v_aW*
aW "a WORD", select [count] WORDs (see |WORD|).
Leading or trailing white space is included, but not
counted.
*v_iW*
iW "inner WORD", select [count] WORDs (see |WORD|).
White space between words is counted too.
*v_as*
as "a sentence", select [count] sentences (see
|sentence|).
*v_is*
is "inner sentence", select [count] sentences (see
|sentence|).
*v_ap*
ap "a paragraph", select [count] paragraphs (see
|paragraph|).
*v_ip*
ip "inner paragraph", select [count] paragraphs (see
|paragraph|).
a] *v_a]* *v_a[*
a[ "a [] block", select [count] '[' ']' blocks. This
goes backwards to the [count] unclosed '[', and finds
the matching ']'. The enclosed text is selected,
including the '[' and ']'.
i] *v_i]* *v_i[*
i[ "inner [] block", select [count] '[' ']' blocks. This
goes backwards to the [count] unclosed '[', and finds
the matching ']'. The enclosed text is selected,
excluding the '[' and ']'.
a) *v_a)*
a( *v_ab* *v_a(*
ab "a block", select [count] blocks, from "[count] [(" to
the matching ')', including the '(' and ')' (see
|[(|).
i) *v_i)*
i( *v_ib* *v_i(*
ib "inner block", select [count] blocks, from "[count] [("
to the matching ')', excluding the '(' and ')' (see
|[(|).
a> *v_a>* *v_a<*
a< "a <> block", select [count] <> blocks, from the
[count]'th unmatched '<' backwards to the matching
'>', including the '<' and '>'.
i> *v_i>* *v_i<*
i< "inner <> block", select [count] <> blocks, from
the [count]'th unmatched '<' backwards to the matching
'>', excluding the '<' and '>'.
a} *v_a}*
a{ *v_aB* *v_a{*
aB "a Block", select [count] Blocks, from "[count] [{" to
the matching '}', including the '{' and '}' (see
|[{|).
i} *v_i}*
i{ *v_iB* *v_i{*
iB "inner Block", select [count] Blocks, from "[count] [{"
to the matching '}', excluding the '{' and '}' (see
|[{|).
When used after an operator:
For non-block objects:
For the "a" commands: The operator applies to the object and the white
space after the object. If there is no white space after the object
or when the cursor was in the white space before the object, the white
space before the object is included.
For the "inner" commands: If the cursor was on the object, the
operator applies to the object. If the cursor was on white space, the
operator applies to the white space.
For a block object:
The operator applies to the block where the cursor is in, or the block
on which the cursor is on one of the braces. For the "inner" commands
the surrounding braces are excluded. For the "a" commands, the braces
are included.
When used in Visual mode:
When start and end of the Visual area are the same (just after typing "v"):
One object is selected, the same as for using an operator.
When start and end of the Visual area are not the same:
For non-block objects the area is extended by one object or the white
space up to the next object, or both for the "a" objects. The
direction in which this happens depends on which side of the Visual
area the cursor is. For the block objects the block is extended one
level outwards.
For illustration, here is a list of delete commands, grouped from small to big
objects. Note that for a single character and a whole line the existing vi
movement commands are used.
"dl" delete character (alias: "x") |dl|
"diw" delete inner word *diw*
"daw" delete a word *daw*
"diW" delete inner WORD (see |WORD|) *diW*
"daW" delete a WORD (see |WORD|) *daW*
"dd" delete one line |dd|
"dis" delete inner sentence *dis*
"das" delete a sentence *das*
"dib" delete inner '(' ')' block *dib*
"dab" delete a '(' ')' block *dab*
"dip" delete inner paragraph *dip*
"dap" delete a paragraph *dap*
"diB" delete inner '{' '}' block *diB*
"daB" delete a '{' '}' block *daB*
Note the difference between using a movement command and an object. The
movement command operates from here (cursor position) to where the movement
takes us. When using an object the whole object is operated upon, no matter
where on the object the cursor is. For example, compare "dw" and "da": "dw"
deletes from the cursor position to the start of the next word, "da" deletes
the word under the cursor and the space after or before it.
7. Various motions *various-motions*
*m*
m<a-zA-Z> Set mark <a-zA-Z> at cursor position (does not move
the cursor, this is not a motion command).
m' or m` Set the previous context mark. This can be jumped to
with the "''"' or "``" command (does not move the
cursor, this is not a motion command).
*:ma* *:mark*
:[range]ma[rk] <a-zA-Z> Set mark <a-zA-Z> at last line number in [range],
column 0. Default is cursor line.
*:k*
:[range]k<a-zA-Z> Same as :mark, but the space before the mark name can
be omitted.
*'* *'a*
'<a-z> To the first non-blank character on the line with
mark <a-z> (linewise).
*'A* *'0*
'<A-Z0-9> To the first non-blank character on the line with
mark <A-Z0-9> in the correct file (linewise when in
same file, not a motion command when in other file).
{not in Vi}
*`* *`a*
`<a-z> To the mark <a-z> (exclusive).
*`A* *`0*
`<A-Z0-9> To the mark <A-Z0-9> in the correct file (exclusive
when in same file, not a motion command when in
other file). {not in Vi}
*:marks*
:marks List all the current marks (not a motion command).
{not in Vi}
:marks {arg} List the marks that are mentioned in {arg} (not a
motion command). For example:
:marks aB
to list marks 'a' and 'B'. {not in Vi}
A mark is not visible in any way. It is just a position in the file that is
remembered. Do not confuse marks with named registers, they are totally
unrelated.
'a - 'z lowercase marks, valid within one file
'A - 'Z uppercase marks, also called file marks, valid between files
'0 - '9 numbered marks, set from .viminfo file
Lowercase marks 'a to 'z are remembered as long as the file remains in the
buffer list. If you remove the file from the buffer list, all its marks are
lost. If you delete a line that contains a mark, that mark is erased.
Lowercase marks can be used in combination with operators. For example: "d't"
deletes the lines from the cursor position to mark 't'. Hint: Use mark 't' for
Top, 'b' for Bottom, etc.. Lowercase marks are restored when using undo and
redo.
Uppercase marks 'A to 'Z include the file name. {Vi: no uppercase marks} You
can use them to jump from file to file. You can only use an uppercase mark
with an operator if the mark is in the current file. The line number of the
mark remains correct, even if you insert/delete lines or edit another file for
a moment. When the 'viminfo' option is not empty, uppercase marks are kept in
the .viminfo file. See |viminfo-file-marks|.
Numbered marks '0 to '9 are quite different. They can not be set directly.
They are only present when using a viminfo file |viminfo-file|. Basically '0
is the location of the cursor when you last exited Vim, '1 the last but one
time, etc. See |viminfo-file-marks|.
*'[*
'[ To the first non-blank character on the first line
of the previously operated, inserted or putted text.
{not in Vi}
*`[*
`[ To the first character of the previously operated,
inserted or putted text. {not in Vi}
*']*
'] To the first non-blank character on the last line of
the previously operated, inserted or putted text.
{not in Vi}
*`]*
`] To the last character of the previously operated,
inserted or putted text. {not in Vi}
After executing an operator the Cursor is put at the beginning of the text
that was operated upon. After a put command ("p" or "P") the cursor is
sometimes placed at the first inserted line and sometimes on the last inserted
character. The four commands above put the cursor at either end. Example:
After yanking 10 lines you want to go to the last one of them: "10Y']". After
inserting several lines with the "p" command you want to jump to the lowest
inserted line: "p']". This also works for text that has been inserted.
Note: After deleting text, the start and end positions are the same, except
when using blockwise Visual mode. These commands do not work when no
operator, file-read or put command has been used yet in the current file.
*'<*
'< To the first non-blank character on the first line
of the last selected Visual area in the current
buffer. {not in Vi}.
*`<*
`< To the first character of the last selected Visual
area in the current buffer. {not in Vi}.
*'>*
'> To the first non-blank character on the last line
of the last selected Visual area in the current
buffer. {not in Vi}.
*`>*
`> To the last character of the last selected Visual
area in the current buffer. {not in Vi}.
*''*
'' To the first non-blank character of the line where
the cursor was before the latest jump, or where the
last "m'"' or "m`" command was given (linewise).
*``*
`` To the position before latest jump, or where the last
"m'"' or "m`" command was given (exclusive).
*'quote*
'"' To the first non-blank character of the line where
the cursor was the last time the current buffer was
exited (linewise). Defaults to the first line. {not
in Vi}.
*`quote*
`" To the cursor position when last exiting the current
buffer (exclusive). Defaults to the first character
of the first line. {not in Vi}.
A "jump" is one of the following commands: "'"', "`", "G", "/", "?", "n",
"N", "%", "(", ")", "[[", "]]", "{", "}", ":s", ":tag", "L", "M", "H" and
the commands that start editing a new file. If you make the cursor "jump"
with one of these commands, the position of the cursor before the jump is
remembered. You can return to that position with the "''"' and "``" command,
unless the line containing that position was changed or deleted.
*CTRL-O*
CTRL-O Go to [count] Older cursor position in jump list
(not a motion command). {not in Vi}
<Tab> or *CTRL-I* *<Tab>*
CTRL-I Go to [count] newer cursor position in jump list
(not a motion command). {not in Vi}
*:ju* *:jumps*
:ju[mps] Print the jump list (not a motion command). {not in
Vi}
*jumplist*
Jumps are remembered in a jump list. With the CTRL-O and CTRL-I command you
can go to cursor positions before older jumps, and back again. Thus you can
move up and down the list. There is a separate jump list for each window.
The maximum number of entries is fixed at 50.
For example, after three jump commands you have this jump list:
jump line file
3 1 -current-
2 70 -current-
1 1154 -current-
>
You are currently in line 1167. If you then use the CTRL-O command, the
cursor is put in line 1154. This results in:
jump line file
2 1 -current-
1 70 -current-
> 0 1154 -current-
1 1167 -current-
The pointer will be set at the last used jump position. The next CTRL-O
command will use the entry above it, the next CTRL-I command will use the
entry below it. If the pointer is below the last entry, this indicates that
you did not use a CTRL-I or CTRL-O before. In this case the CTRL-O command
will cause the cursor position to be added to the jump list, so you can get
back to the position before the CTRL-O. In this case this is line 1167.
With more CTRL-O commands you will go to lines 70 and 1. If you use CTRL-I
you can go back to 1154 and 1167 again. Note that the number in the "jump"
column indicates the count for the CTRL-O or CTRL-I command that takes you to
this position.
If you use a jump command, the current line number is inserted at the end of
the jump list. If the same line was already in the jump list, it is removed.
The result is that when repeating CTRL-O you will get back to old positions
only once.
After the CTRL-O command that got you into line 1154 you could give another
jump command (e.g., "G"). The jump list would then become:
jump line file
4 1 -current-
3 70 -current-
2 1167 -current-
1 1154 -current-
>
The line numbers will be adjusted for deleted and inserted lines. This fails
if you stop editing a file without writing, like with ":n!".
*%*
% Find the next item in this line after or under the
cursor and jump to its match (inclusive). Items can
be:
([{}]) parenthesis or (curly/square) brackets
(this can be changed with the
'matchpairs' option)
/* */ start or end of C-style comment
#if, #ifdef, #else, #elif, #endif
C preprocessor conditionals
Parens and braces preceded with a backslash are
ignored. When the '%' character is not present in
'cpoptions', parens and braces inside double quotes
are ignored, unless the number of parens/braces in a
line is uneven and this line and the previous one does
not end in a backslash. '(', '{', '[', ']', '}' and
')' are also ignored (parens and braces inside single
quotes). Note that this works fine for C, but not for
Perl, where single quotes are used for strings.
No count is allowed ({count}% jumps to a line {count}
percentage down the file). Using '%' on
#if/#else/#endif makes the movement linewise.
*[(*
[( go to [count] previous unmatched '('. {not in Vi}
*[{*
[{ go to [count] previous unmatched '{'. {not in Vi}
*])*
]) go to [count] next unmatched ')'. {not in Vi}
*]}*
]} go to [count] next unmatched '}'. {not in Vi}
The above four commands can be used to go to the start or end of the current
code block. It is like doing "%" on the '(', ')', '{' or '}' at the other
end of the code block, but you can do this from anywhere in the code block.
Very useful for C programs. Example: When standing on "case x:", "[{" will
bring you back to the switch statement.
*[#*
[# go to [count] previous unmatched "#if" or "#else".
{not in Vi}
*]#*
]# go to [count] next unmatched "#else" or "#endif". {not
in Vi}
These two commands work in C programs that contain #if/#else/#endif
constructs. It brings you to the start or end of the #if/#else/#endif where
the current line is included. You can then use "%" to go to the matching line.
*[star* *[/*
[* or [/ go to [count] previous start of a C comment "/*". {not
in Vi}
*]star* *]/*
]* or ]/ go to [count] next end of a C comment "*/". {not
in Vi}
*H*
H To line [count] from top (Home) of screen (default:
first line on the screen) on the first non-blank
character (linewise). See also 'startofline' option.
Cursor is adjusted for 'scrolloff' option.
*M*
M To Middle line of screen, on the first non-blank
character (linewise). See also 'startofline' option.
*L*
L To line [count] from bottom of screen (default: Last
line on the screen) on the first non-blank character
(linewise). See also 'startofline' option.
Cursor is adjusted for 'scrolloff' option.
<LeftMouse> Moves to the position on the screen where the mouse
click is (inclusive). See also |<LeftMouse>|. If the
position is in a status line, that window is made the
active window and the cursor is not moved. {not in Vi}
top - back to help