2.3 — Line Navigation#

Efficient line navigation lets you jump directly to characters within a line. These commands are essential for precise, fast editing.

Line Boundary Commands#

Start and End of Line#

Command	Moves to…
0	Column 0 (absolute start)
^	First non-blank character
$	End of line
g_	Last non-blank character

Example line: return result;

    return result;  
^   ^            ^  ^
0   ^            g_ $

When to Use Each#

• 0 — When you need column 0, even if it’s whitespace
• ^ — When you want the first actual content (most common)
• $ — When you want the absolute end of line
• g_ — When you want the last actual content (ignoring trailing spaces)

Find Commands: f, F, t, T#

These are the most powerful line navigation commands.

Find (f and F)#

Command	Action
f{char}	Find char forward, cursor on the character
F{char}	Find char backward, cursor on the character

Example: function calculate(x, y)

function calculate(x, y)
^cursor

fc → function calculate(x, y)
           ^cursor on 'c'

f( → function calculate(x, y)
                       ^cursor on '('

Till (t and T)#

Command	Action
t{char}	Find char forward, cursor before the character
T{char}	Find char backward, cursor after the character

Example: function calculate(x, y)

function calculate(x, y)
^cursor

tc → function calculate(x, y)
          ^cursor before 'c'

t( → function calculate(x, y)
                      ^cursor before '('

The Difference Matters for Operators#

The choice between f and t matters when combined with operators:

delete_this_function(args)
^cursor

df( → (args)           # Deletes "delete_this_function("
dt( → delete_this_function(args)   # Deletes "delete_this_function"
                       ^cursor ends here

• df( deletes the ( itself
• dt( deletes up to but not including (

Repeating Find Commands#

Command	Action
;	Repeat last f/F/t/T in same direction
,	Repeat last f/F/t/T in opposite direction

Example: Finding all commas in a, b, c, d, e

a, b, c, d, e
^cursor

f,  →  a, b, c, d, e
        ^first comma

;   →  a, b, c, d, e
              ^second comma

;   →  a, b, c, d, e
                 ^third comma

,   →  a, b, c, d, e
              ^back to second comma

This is extremely useful for jumping through repeated characters like commas, parentheses, or quotes.

Counts with Find Commands#

All find commands accept counts:

Command	Action
2f,	Jump to second comma
3fa	Jump to third ‘a’
2T"	Jump back to second-previous quote

Combining with Operators#

Find commands become incredibly powerful with operators:

Deleting#

Command	Action
df,	Delete through comma
dt,	Delete up to comma
dF,	Delete back through comma
dT,	Delete back to comma

Changing#

Command	Action
cf)	Change through closing paren
ct"	Change up to quote
cT:	Change back to colon

Yanking#

Command	Action
yt,	Yank up to comma
yf;	Yank through semicolon

Practical Examples#

Example 1: Changing a Function Argument#

process(oldValue, secondArg, thirdArg)
        ^cursor

To change oldValue to newValue:

• ct, then type newValue

Example 2: Deleting to End of Statement#

let result = calculateSum(a, b);
    ^cursor

To delete everything after result:

• f= then D (delete to end of line)
• OR dt; then x to also remove the semicolon

Example 3: Navigating Quoted Strings#

message = "Hello, World!"
          ^cursor

To get inside the quotes:

• f" to go to first quote
• l to move inside
• OR f"l or better: f" then ci" to change inside

Example 4: Working with Paths#

/home/user/documents/project/file.txt
^cursor

To jump to specific parts:

• f/;; — jump to third / (documents)
• t. — jump to just before the .
• f.l — jump to the extension (txt)

The | Command: Go to Column#

Command	Action
`{n}	`

Example: 42| goes to column 42. Useful for aligning or working with fixed-width data.

Practice Exercises#

Exercise 1: Find Character#

1. Create line: function processData(input, output, flags)
2. Press f( to jump to (
3. Press fo to jump to first o (in “output”)
4. Press ; to find next o
5. Press , to go back

Exercise 2: Till Character#

1. Create line: let value = "Hello, World!";
2. Press t= from start — where does cursor land?
3. Press f= from start — where does cursor land?
4. Note the difference

Exercise 3: Delete with Find#

1. Create: remove, keep, this, text
2. Position at start
3. df, — deletes “remove,”
4. Undo with u
5. dt, — deletes “remove” (keeps comma)

Exercise 4: Multiple Finds#

1. Create: a, b, c, d, e, f, g
2. 3f, — jump to third comma
3. ,, (comma twice) — go back two commas
4. ;; — go forward two commas

Exercise 5: Combined Editing#

1. Create: const name = "old value";
2. Navigate to change “old value” using find commands
3. Try: f"ci" then type new value
4. This finds quote, then changes inside quotes

Tips for Effective Line Navigation#

Choose the Right Command#

Situation	Best Command
Jump to a unique character	f{char}
Delete up to something	dt{char}
Delete through something	df{char}
Navigate repeated characters	f{char} then ;

Think About Delimiters#

Most code has natural delimiters: (, ), ,, ., ", ', :, ;

Learn to jump to these instantly:

• f( — function call
• f" — string start
• f. — method chain
• f, — next argument

Use Count for Speed#

If you see the third comma, don’t do f,;;. Do 3f,.

Summary#

Command	Action
0 / ^ / $	Line start / first char / end
f{char}	Find forward (on char)
F{char}	Find backward (on char)
t{char}	Till forward (before char)
T{char}	Till backward (after char)
; / ,	Repeat find / reverse repeat
`{n}	`

Line navigation commands are the key to surgical precision in Vim. Master f, t, and ;, and you’ll edit at the speed of thought.