Veelgestelde problemen

Vim 9.1 staat op je server en je hebt net een configbestand geopend, waarna je vastzit in een editor die niet reageert op wat je typt. Dit artikel leert je Vim gebruiken op het niveau dat je nodig hebt voor serverwerk: bestanden openen, bewerken, opslaan en weer wegwezen — zonder dat je een muis nodig hebt.

Vereisten

Je hebt een Unix-achtig systeem nodig met Vim 8.0 of hoger, of Vim 9.x. Op vrijwel elke Linux-distributie staat een bruikbare versie voorgaand, maar de exacte versie verschilt per distributie. Controleer dat eerst.

```bash vim --version ```

De eerste regel toont iets als `VIM - Vi IMproved 9.1`. Staat er `8.2` of hoger, dan werkt alles in dit artikel. Staat er een versie onder 7.4, dan mis je functionaliteit die we hier gebruiken — met name het ingebouwde pakketbeheer uit 8.0.

Je hebt lees- en schrijfrechten nodig op het bestand dat je wilt bewerken. Voor systeemconfiguratie zoals `/etc/hosts` betekent dat `sudo`.

Stappen

1. Open een bestand

```bash vim /etc/hosts ```

Vim start in normal mode. Dat is het punt waar de meeste beginners vastlopen: toetsaanslagen zijn hier commando's, geen tekst. Je typt dus geen letters in het bestand, je geeft opdrachten. Druk je op `i`, dan ga je naar insert mode en kun je typen. Druk je op `Esc`, dan keer je terug naar normal mode.

Dat onderscheid is geen eigenaardigheid. Het is de reden dat een ervaren Vim-gebruiker een bestand kan doorzoeken, herstructureren en opslaan zonder de handen van het toetsenbord te halen. De prijs is een leercurve van een paar dagen waarin je jezelf regelmatig in de war brengt.

2. Beweeg zonder pijltjestoetsen

In normal mode werken `h`, `j`, `k` en `l` voor links, omlaag, omhoog en rechts. De pijltjestoetsen doen het ook, maar ze zijn trager omdat je hand naar een ander blok moet.

```text h links j omlaag k omhoog l rechts w naar het begin van het volgende woord b naar het begin van het vorige woord 0 naar het begin van de regel $ naar het einde van de regel gg naar de eerste regel van het bestand G naar de laatste regel van het bestand ```

Dit is niet bedoeld om je pijltjestoetsen af te pakken. Het is bedoeld om je bewegingen combineerbaar te maken met andere commando's. `dG` wist alles vanaf de cursor tot het einde van het bestand. `d$` wist vanaf de cursor tot het einde van de regel. Die combinaties werken alleen als bewegingen commando's zijn, en dat zijn ze hier.

3. Bewerk tekst

Druk op `i` om in insert mode te komen, typ je wijziging, en druk op `Esc` om terug te keren naar normal mode. Vergeet die `Esc` niet. Wie vergeet dat, typt daarna commando's als tekst in het bestand en snapt niet waarom er ineens `:wq` tussen de regels staat.

Voor het verwijderen en verplaatsen van bestaande tekst blijf je in normal mode.

```text x verwijder het teken onder de cursor dd verwijder de hele regel yy kopieer de hele regel p plak na de cursor (of na de huidige regel bij regelcommando's) u maak de laatste wijziging ongedaan Ctrl-r herstel de ongedaan gemaakte wijziging ```

De `u`-toets is je beste vriend in de eerste weken. Vim heeft een undo-historie die standaard tientallen stappen teruggaat, dus je kunt weinig kapotmaken wat niet terug te draaien is.

4. Zoek en vervang

Zoeken in normal mode met `/`.

```text /127.0.0.1 zoek vooruit naar de tekst ?localhost zoek achteruit n volgende treffer N vorige treffer ```

Voor het vervangen van tekst gebruik je het `:substitute`-commando. Dit is krachtiger dan de zoek-en-vervang in de meeste editors, en ook makkelijker om mee de fout in te gaan.

```vim :%s/oud/nieuw/g ```

Die regel betekent: door het hele bestand (`%`), vervang `oud` door `nieuw`, alle voorkomens per regel (`g`). Zonder de `g` vervangt hij alleen het eerste voorkomen per regel. Zonder de `%` alleen de huidige regel.

Wil je eerst zien wat er vervangen wordt voordat je het doorvoert, voeg dan `c` toe:

```vim :%s/oud/nieuw/gc ```

Vim vraagt dan per treffer om bevestiging. Dat is trager, maar het heeft menig configuratiebestand gered.

5. Werk met meerdere bestanden

Vim opent meerdere bestanden als buffers. Je kunt ze naast elkaar zetten met splits.

```text :e /etc/nginx/nginx.conf open een tweede bestand :bn volgende buffer :bp vorige buffer :ls lijst van open buffers :sp bestand horizontale split :vsp bestand verticale split Ctrl-w Ctrl-w wissel tussen splits ```

Splits zijn nuttig als je een configuratie aanpast en tegelijk de documentatie ernaast wilt hebben. Op een server zonder grafische omgeving is dit vaak de enige manier om twee dingen tegelijk te zien.

6. Sla op en sluit af

```text :w sla op :w nieuw sla op onder een andere naam :q sluit (faalt als er niet-opgeslagen wijzigingen zijn) :q! sluit zonder op te slaan :wq sla op en sluit :x sla op en sluit (alleen als er wijzigingen zijn) ZZ idem, maar sneller te typen ```

`:q!` is het commando dat je zoekt als je per ongeluk iets hebt gewijzigd en er niet meer uitkomt. Het gooit je wijzigingen weg zonder pardon. Voor wie nog niet zeker weet wat hij doet, is dat vaak de juiste keuze.

7. Configureer Vim met een .vimrc

Zonder configuratie werkt Vim, maar niet prettig. Je persoonlijke instellingen staan in `~/.vimrc`. Maak het bestand aan als het nog niet bestaat.

```bash vim ~/.vimrc ```

Een minimale configuratie die het verschil maakt:

```vim set number set relativenumber set tabstop=4 set shiftwidth=4 set expandtab set ignorecase set smartcase set incsearch set hlsearch syntax on ```

Wat dit doet: `number` en `relativenumber` tonen regelnummers, waarbij de relatieve nummers het springen met `10j` mogelijk maken. `expandtab` zet tabs om in spaties — een keuze die je later kunt betreuren als je met een team werkt dat tabs gebruikt, maar de meeste moderne projecten gebruiken spaties. `ignorecase` met `smartcase` maakt zoeken hoofdletterongevoelig, behalve als je zelf een hoofdletter typt.

Deze configuratie is persoonlijk. Kopieer die van iemand anders niet blind. Elke regel die je niet begrijpt, is een regel die je later niet durft aan te passen.

8. Installeer plugins met het ingebouwde pakketbeheer

Sinds Vim 8.0 hoef je geen externe pluginmanager meer te gebruiken. Pakketten leven in `~/.vim/pack/`.

```bash mkdir -p ~/.vim/pack/plugins/start cd ~/.vim/pack/plugins/start git clone https://github.com/tpope/vim-commentary.git git clone https://github.com/tpope/vim-surround.git ```

Na het klonen start Vim deze plugins automatisch bij de volgende keer opstarten. Geen `:PluginInstall`, geen configuratieregels. Het werkt, en het is een van de weinige keren dat een stuk gereedschap in de Unix-wereld precies doet wat je verwacht.

Het nadeel: je hebt geen gecentraliseerd overzicht van wat er geïnstalleerd is, en updaten betekent met de hand `git pull` doen in elke map. Voor een handvol plugins is dat prima. Voor twintig plugins wordt een externe manager zoals `vim-plug` alsnog de moeite waard.

Verificatie

Open een nieuw bestand en doorloop de basis: typ iets, zoek erin, vervang het, sla op.

```bash vim /tmp/vim-test.txt ```

In Vim:

```text i Dit is een test. Esc yy p :%s/test/geslaagd/g :wq ```

Daarna controleer je vanaf de shell:

```bash cat /tmp/vim-test.txt ```

Je zou twee regels moeten zien met daarin `geslaagd` in plaats van `test`. Werkt dat, dan beheers je de basis: insert mode, normal mode, commando's, search-and-replace en opslaan.

Veelgestelde problemen

Vim reageert niet op wat ik typ. Je zit in normal mode en typt commando's in plaats van tekst. Druk op `i` om naar insert mode te gaan. Zie je onderaan het scherm `-- INSERT --`, dan zit je goed.

Ik krijg Vim niet afgesloten. Druk op `Esc`, typ `:q!` en dan Enter. Dat sluit zonder op te slaan. Werk je in een terminal waarin `Ctrl-s` per ongeluk is ingedrukt, dan bevriest het scherm zonder dat Vim iets fout doet. Druk op `Ctrl-q` om dat te herstellen.

Mijn wijzigingen zijn weg na het sluiten. Je hebt `:q!` gebruikt in plaats van `:wq`. Vim waarschuwt bij `:q` als er niet-opgeslagen wijzigingen zijn, maar niet bij `:q!`. Er is geen prullenbak. Wat weg is, is weg.

De terminal is geen vijandige omgeving, maar hij vergeeft minder dan een editor met een muis. Wie een middag investeert in de commando's hierboven, komt nooit meer vast te zitten op een server zonder grafische interface. Wie dat niet doet, blijft `:q!` typen en opnieuw beginnen.