mirror of
https://github.com/mawww/kakoune.git
synced 2024-11-27 12:16:22 +03:00
69 lines
2.2 KiB
Plaintext
69 lines
2.2 KiB
Plaintext
Vi(m) to Kakoune:
|
|
=================
|
|
|
|
Kakoune is inspired heavily by Vim, it strives to be as efficient as Vim,
|
|
more consistent and simpler. A big differences is that a lot of special
|
|
features in Vim just become regular interaction of basic features in
|
|
Kakoune.
|
|
|
|
Operations and moves are reversed in Kakoune. First select whatever text
|
|
you want to operate on, and then use an modifying operation. That makes
|
|
things more consistent (Vim needs a separate x and d operation because
|
|
of the operator -> move order, Kakoune only needs the d operation). That
|
|
also allows more complex selections.
|
|
|
|
delete a word:
|
|
* vim: dw
|
|
* kak: wd
|
|
|
|
delete a character:
|
|
* vim: x
|
|
* kak: d or ;d (; reduces the selection to a single char)
|
|
|
|
copy a line:
|
|
* vim: yy
|
|
* kak: xy
|
|
|
|
global replace:
|
|
* vim: :%s/word/replacement<ret>
|
|
* kak: %sword<ret>creplacement<esc>
|
|
|
|
Explanation: '%' selects the entire buffer, 's' opens a prompt for a
|
|
regex, <ret> validates the regex and replace the selection with one
|
|
per matches (hence, all occurences of word are selected). 'c' deletes
|
|
the selection contents and enter insert mode, replacement is typed
|
|
and <esc> goes back to normal mode.
|
|
|
|
Note that the Kakoune version is one key less, and is not a special
|
|
feature per se, but just a nice way Kakoune features work together.
|
|
|
|
replace in current curly braces block:
|
|
* vim: viB:s/word/replacement<ret>
|
|
* kak: <a-i>Bsword<ret>creplacement<esc>
|
|
|
|
Here again, we need to rely on another Vim special feature, visual
|
|
mode.
|
|
|
|
join line with next:
|
|
* vim: J
|
|
* kak: alt-J
|
|
|
|
delete to line end:
|
|
* vim: d$
|
|
* kak: alt-ld or gld
|
|
|
|
some classic vim moves are not bound to the same key, this is due to Kakoune
|
|
using shifted moves to append to selection, so moves that were bound to non
|
|
alphabetic chars had to change.
|
|
|
|
* % become m (for matching), however m will replace selection with the next
|
|
block, if you want to get a selection from current point to next block end,
|
|
you should use <space>M (<space> clears the selection to one character)
|
|
|
|
* 0 and $ became alt-h and alt-l. Another binding is gh and gl.
|
|
|
|
:[gv]/re/cmd
|
|
to emulate :g or :v, use % to select the whole buffer, alt-s to get
|
|
one selection by line, and then alt-k or alt-K in order to keep only the
|
|
selections matching (or not matching) the entered regex.
|