Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/kaddkaka/vim_examples
Some examples of vim features captured from terminal with asciinema.
https://github.com/kaddkaka/vim_examples
asciinema examples readme-only showcase vim vim-bindings vim-tutorial
Last synced: 3 months ago
JSON representation
Some examples of vim features captured from terminal with asciinema.
- Host: GitHub
- URL: https://github.com/kaddkaka/vim_examples
- Owner: kaddkaka
- Created: 2021-11-20T01:32:35.000Z (almost 3 years ago)
- Default Branch: main
- Last Pushed: 2024-02-11T21:39:10.000Z (9 months ago)
- Last Synced: 2024-06-18T02:33:04.747Z (5 months ago)
- Topics: asciinema, examples, readme-only, showcase, vim, vim-bindings, vim-tutorial
- Homepage:
- Size: 135 KB
- Stars: 38
- Watchers: 3
- Forks: 2
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# Builtins
## Increment numbers (incremental sequence)
[`ctrl-a`](https://vimhelp.org/change.txt.html#CTRL-A) increments the number at or after the cursor, [`ctrl-x`](https://vimhelp.org/change.txt.html#CTRL-X) decrements the number. With visual selection an incremental sequence can be achieved with [`g ctrl-a`](https://vimhelp.org/change.txt.html#v_g_CTRL-A)
before -> after:
-> 
(key sequence in video: `jVG^A..uuugvg^A..uuugv10g^A`)
Tip: This also works with rectangle selection (`ctrl-v`).
## Replay macro on each line in visual selection
[`:norm @q`](https://vimhelp.org/various.txt.html#%3Anorm) in visual mode will perform the normal command `@q` (play macro in register q) on each line in selection. [`qq`](https://vimhelp.org/repeat.txt.html#q) is used to record the macro.
(key sequence in video: `qqIconst ^[A;^[qjVjjj:norm @q`, q register content: `Iconst ^[A;^[`)
## Navigate quickfix list
The [quickfix list](https://vimhelp.org/quickfix.txt.html#quickfix) can be populated with locations in several ways. A key to using it effectively is to have mappings for [`:cnext`](https://vimhelp.org/quickfix.txt.html#%3Acnext) and [`:cprev`](https://vimhelp.org/quickfix.txt.html#%3Acprev).
- [`:vimgrep en *`](https://vimhelp.org/quickfix.txt.html#%3Avimgrep) is used to find all occurences of `en` in all files in cwd (current working directory).
- [`:copen`](https://vimhelp.org/quickfix.txt.html#%3Acopen) is used to open the quickfix window to show the quickfix list.
Mapping suggestions:
```vim
nnoremap cnext
nnoremap cprev
```
- `:vimgrep /def test/ **/*.py` find all matches of "def test" in all pythons files recursively from cwd.
- [`:cdo`](https://vimhelp.org/quickfix.txt.html#%3Acdo) executes a command at each entry in the quickfix list.
## Use `!` to run external command (e.g. sort lines)
[Filters](https://vimhelp.org/change.txt.html#filter) can be run for example by typing
[`!`](https://vimhelp.org/change.txt.html#%21) with a visual selection. All text will be filtered
through an external command. To sort all lines by numeric sort, use `!sort -n`.
(key sequence in video: `vip!sort -n`)
## Use filtering and awk to sum all numbers in a specific column
awk is a powerful tool, here used to sum all the fields of a specific column:
- `:%! awk '{print; s+=$2} END {print s}'` sums the second field (`$2`) of
each line and prints the total at the `END`.
## global: repeat a command for each line matching a pattern
With [`:global`](https://vimhelp.org/repeat.txt.html#%3Aglobal) a command can be repeated for each
line that matches a pattern. Default pattern is last used search pattern.
- `:g//d` deletes all lines matching the last search pattern
- `:g//d E` delete the same lines and appends each delete to register `e` which can be pasted with
`"ep`
key sequence in video: `*:g//d` `u` `:g//d Ep`
- `:g/pattern/norm @q`, play macro on each line matching pattern.
- `:v/;$/ s/$/;`, Add `;` to all lines that does not end in semicolon.
More g power at [https://vim.fandom.com/wiki/Power_of_g](https://vim.fandom.com/wiki/Power_of_g)
## Replace only within selection
The search [pattern atom](https://vimhelp.org/pattern.txt.html#pattern-atoms) [`\%V`](https://vimhelp.org/pattern.txt.html#%2F%5C%25V) can be used to match inside visual area. This can be used to replace only within a (rectangle) selection.
(key sequence in video: `wwww^VG$se/o`)
Mapping suggestion:
```vim
xnoremap s :s/\%V
```
## Delete to search motion
Normal commands like [`d`](https://vimhelp.org/change.txt.html#d) can take any [motions](https://vimhelp.org/intro.txt.html#%7Bmotion%7D) for example a search `/`. When searching and current match is displayed, use [`ctrl-g`](https://vimhelp.org/cmdline.txt.html#%2F_CTRL-G) to move to the next match.
- `d/en` Will delete everything up to the 3rd match of search pattern "en".
- Use a [search-offset](https://vimhelp.org/pattern.txt.html#search-offset) like `/e` in `d/en/e` to delete to the end of the match.
(key sequence in video: `d/en^G^G`)
## Select what was just pasted, reselect last selection
[`` `[ ``](https://vimhelp.org/motion.txt.html#%60%5B) moves to the first character of the previously changed or yanked text, [`` ]` ``](https://vimhelp.org/motion.txt.html#%60%5D) moves to the last. This means that `` `[v`] `` will visually select what was just pasted. [`gv`](https://vimhelp.org/visual.txt.html#gv) will reselect the previous selected area.
(key sequence in video: ``viByPgg`[v`]^[jjjgv``)
Mapping suggestion:
```vim
nnoremap gv `[v`]
```
## Repeat the last command line
[`@:`](https://vimhelp.org/repeat.txt.html#%40%3A) can be used to repeat the last command line command. More convenient when mapped to a single key and I have currently chosen `,` as my repeat-command key. `,` is used to repeat the last `fFtT` motion in reverse direction, but I seldom use it so I have a mapping that shadows this builtin:
```vim
nnoremap , @:
```
Alternative mapping suggestions might be the following, but I know I sometimes want to perform `j` `repeat-command` `j` `repeat-command` in fast succession.
```vim
nnoremap @:
nnoremap . @:
```
## Retrieve the word under cursor
`ctrl-r` can be used in insert mode and the command line to insert contents of registers, but also some other stuff like the word under the cursor!
Using `` will put the current word under cursor where you are at, but if you want to do this in a command you dont want this combination to "expand" immediately but rather when you execute the command. I asked a question about this at [reddit](https://www.reddit.com/r/vim/comments/1183ygn/is_it_possible_to_fetch_the_text_under_cursor/), and got replies from Fantastic_Cow7272 and yegappanl that led me to this kind of command:
- `:!git show `: Run this with the cursor on a commit hash (for example in a git rebase `edit-todo` file) to show git information about that commit.
## Recursive macros
By playing the content of a register at the end of the recording, you can make
a macro recursive. (Make sure it has a stop condition or you will have to break
it with ``!)
If you forgot to do the macro recursive while recording it the first time, you
make it recursive with the sequence `qQ@qq` (assuming your macro is in the `q`
register)
### Recursive within line
A movement within a line such as ``f `` (f followed by space) will stop the
recursive macro at the end of a line. This can be used to modify each word on a
line in some way:
1. `qq` `ciw"-"f l@q` `q`: surround each "word" on the line in quotes
2. `qq` `gUiw2f l@q` `q`: upper-case every 2nd "word" on the line
With both lines below visually selected, replaying macro 1 from above with
`:norm e@q` will turn:
```
Recursive over lines
Recursive over lines
```
Into:
```
"Recursive" "over" "lines"
"Recursive" "over" "lines"
```
Mapping suggestion:
```vim
nnoremap q qqqqq
```
Questions:
- What is actually different between `-` and `"`?
- Why doesn't this mapping seem to work: `nnoremap q qqqqq`?
- Is there a "within line" version of `:g`?
## Repeat last change in all of file ("global repeat", similar to g&)
[`ctrl-r` in insert mode](https://vimhelp.org/insert.txt.html#i_CTRL-R) can be
used to insert the same text as last time with the dot (`.`) register. With this
kind mapping you can easily repeat a modification like `ciw` (change in word) in
all of the document.
Mapping suggestion:
```vim
nnoremap g. :%s//./g
```
# Ideas/TODOs
- appending to registers ([`"Ayy`](https://vimhelp.org/change.txt.html#quotea))
- inserting literal characters ([`ctrl-v`](https://vimhelp.org/insert.txt.html#i_CTRL-V))
- pasting from register in insert mode ([`ctrl-r`](https://vimhelp.org/insert.txt.html#i_CTRL-R))
- batch changes (`:cdo`, [`:bufdo`](https://vimhelp.org/windows.txt.html#%3Abufdo), `:windo`, `:argdo`, `:ldo`)
- changelist: go back to previous edit location ([`g;`](https://vimhelp.org/motion.txt.html#g%3B))
- insert at previous insert location ([`gi`](https://vimhelp.org/insert.txt.html#gi))
- normal commands in insert mode ([`ctrl-o`](https://vimhelp.org/insert.txt.html#i_CTRL-O))