To letter, then delete until letter, and repeat

user_4451315 0
Viewed 90

From "practical vim", I gather than a good practice is to try to move, act, and then repeat.

Say I have this string:

foo_bar fooo_bar foo abar foo_bar

I would like to move forwards until I find an f, and then delete until I find a b, and repeat.

I would have thought that the following would work:

ff
dtb
;
.
;
.

ff would be the command to move, and then dtb the one to act.

However, when I press ;, it goes forwards until just before the next b, while I would like to repeat my "move" command, i.e. ff.

Is there a way to do this, such that the "act" command doesn't change the behaviour of the "move" one?

vim
4 Answers

; repeats the latest fFtT which, in your case, is tb, not ff. There is no way to make ; repeat something else.

Here are alternative methods…

  • With :help /:

    ff
d/b<CR>    " delete until next b
;
.
;
.

    As mentioned by @mattb, the trick is to use a different motion than any of fFtT for the operation so that your ff is always the latest motion repeatable with ; or ,.

  • With :help recording:

    qq         " start recording in register q
ff
dtb
q          " stop recording
@q         " play it back
@q         " play it back

    The trick is to encapsulate the initial motion and the operation into a single macro that can be repeated over and over without involving ; at all.

user_5468610

You could record a macro into some register and replay it. Using the a register:

qaffdtbq

this breaks down into:

  • qa to begin recording the macro into the a register
  • ffdtb are the commands you wanted to run
  • q to stop the recording

and then, with the cursor on the first character, run the macro 4 times with 4@a to change this:

foo_bar fooo_bar foo abar foo_bar

to this:

foo_bar bar bar bar

or just run the macro once with @a and then hit @@ to repeat it

user_144676070

Maybe it's not what you need, but you could do the same thing using the :s command.

:s/f[^ft]*t//g
user_49766560

You could also search for the f with / and then jump to the next one with n:

Input:

foo_bar fooo_bar foo abar foo_bar

Actions:

/f<CR>
dtb
n
.
n
.

Result:

foo_bar bar bar bar
user_140157370
Related