Het belangrijkste wat je moet weten als beginner is dat VI twee hoofdmodes heeft, nl. een edit mode en een command/move mode. Als je VI opstart kom je automatisch in de command mode terecht. Door een tekstbewerkingscommando uit te voeren kom je in de edit mode. Om weer terug in command mode te komen volstaat het indrukken van <esc>. Als je niet meer weet in welke mode je je bevindt, druk je dus gewoon op <esc> en je zit weer in de command mode. De <esc> is hiermee een van de meest gebruikte toetsen in VI. Je kunt overigens ook zeggen dat men na het typen van ':' in de command mode in een aparte, derde mode terechtkomt, nl. in de line-edit mode.
Er bestaan veel varianten van VI, maar die ondersteunen over het algemeen alle commando's die 'standaard' VI heeft. Varianten zijn bijvoorbeeld Elvis en Vim. In deze twee varianten is het bijvoorbeeld ook mogelijk de pijltjes-toetsen te gebruiken, zelfs tijdens het editen, zodat je minder vaak tussen de edit en de command/move mode heen en weer hoeft te schakelen. Pas hier echter mee op; controleer altijd even met ^L in de command mode, of er niet allemaal ANSI-codes door de tekst heen komen te staan. En ook al lijkt hij het goed te doen, deze optie is niet altijd even betrouwbaar. Verder heeft vim de mogelijkheid om macro's op te nemen m.b.v. qq in command mode.
default-waarde : 1Terug naar de Index
<*> : `*' moet niet letterlijk genomen worden
[*] : `*' is optioneel
^X : <ctrl>X
<sp> : spatie
<cr> : carriage return
<lf> : linefeed
<ht> : horizontal tab
<esc> : escape
<erase> : jouw `erase' karakter
<kill> : jouw `kill' karakter
<intr> : jouw `interrupt' karakter
<a-z> : een element in de reeks
N : aantal
`*' = toegestaan
`-' = niet van toepassing
CHAR : char ongelijk <ht>|<sp>
WOORD : woord gevolgd door <ht>|<sp>|<lf>
N | Commando | BetekenisTerug naar de Index
---+------------------+--------------------------------------------------
* | h | ^H | <erase> | <*> chars naar links.
* | j | <lf> | ^N | <*> regels omlaag.
* | l | <sp> | <*> chars naar rechts.
* | k | ^P | <*> regels omhoog.
* | $ | Naar einde regel <*> vanaf de cursor.
- | ^ | Naar eerste CHAR van de regel.
* | _ | Naar eerste CHAR <*> - 1 regels lager.
* | - | Naar eerste CHAR <*> regels hoger.
* | + | <cr> | Naar eerste CHAR <*> regels lager.
- | 0 | Naar eerste char van de regel.
* | | | Naar kolom <*> (<ht>: alleen naar het eindpunt).
* | f<char> | <*> <char>'s naar rechts (`find').
* | t<char> | Tot voor <*> <char>'s naar rechts.
* | F<char> | <*> <char>'s naar links.
* | T<char> | Tot na <*> <char>'s naar links.
* | ; | Herhaal vorige `f'|`t'|`F'|`T' <*> keer.
* | , | Idem in tegenovergestelde richting.
* | w | <*> woorden vooruit.
* | W | <*> WOORDEN vooruit.
* | b | <*> woorden terug (`back').
* | B | <*> WOORDEN terug.
* | e | Naar einde woord <*> vooruit (`end').
* | E | Naar einde WOORD <*> vooruit.
* | G | Naar regel <*> (`goto') (default EOF).
* | H | Naar regel <*> vanaf bovenaan het scherm
| (`home').
* | L | Naar regel <*> vanaf onderaan het scherm
| (`last').
- | M | Naar middelste regel van het scherm.
* | ) | <*> zinnen verder.
* | ( | <*> zinnen terug.
* | } | <*> paragrafen verder.
* | { | <*> paragrafen terug.
- | ]] | Naar de volgende sektie (default EOF).
- | [[ | Naar vorige sektie (default begin van de file).
- | `<a-z> | Naar de markering.
- | '<a-z> | Naar het begin van de regel met de markering.
- | `` | Naar de plaats waar de cursor stond voor
| de laatste absolute sprong (voorbeelden van
| absolute sprongen zijn `/' en `G').
- | '' | Naar het begin van de regel waarop de cursor
| stond voor de laatste absolute sprong.
- | /<string> | Naar volgende <string>.
- | ?<string> | Naar vorige <string>.
- | n | Herhaal vorige `/'|`?' (`next').
- | N | Idem in tegenovergestelde richting.
- | % | Zoek het volgende haakje en ga naar het
| bijbehorende haakje (ook bij `{'|`}' en
| `['|`]').
:ta <naam> | Kijk in de `tags'-file[s] waar <naam> wordt gedefinieerd (file, regel) en ga daarheen.Terug naar de Index
^] | Gebruik de naam onder de cursor in een `:ta'- commando.
^T | Haal de vorige `tag' van de `tagstack' en ga naar de bijbehorende positie.
:[x,y]g/<string>/<cmd> | Zoek globaal [van regel x tot en met y] naar <string> en doe telkens het `ex'-commando <cmd>.
:[x,y]v/<string>/<cmd> | Doe <cmd> op de niet-geselekteerde regels.
u | Maak de laatste verandering ongedaan (`undo').Terug naar de Index
U | Maak alle veranderingen op een regel ongedaan, zolang de cursor nog op die regel staat (helaas).
:q! | Verlaat vi zonder te schrijven.
:e! | Edit de file opnieuw.
* | a | <*> keer na de cursor (`append').Terug naar de Index
* | A | <*> keer aan het einde van de regel.
* | i | <*> keer voor de cursor (`insert').
* | I | <*> keer voor de eerste CHAR van de regel.
* | o | Open een nieuwe regel onder de huidige (de count
| is alleen nuttig op een langzame terminal).
* | O | Open een nieuwe regel boven de huidige (de count
| is alleen nuttig op een langzame terminal).
* | ><move> | Schuif de regels beschreven door <*><move>
| een `shiftwidth' naar rechts.
* | >> | Schuif <*> regels een `shiftwidth' naar rechts.
* | ["<a-zA-Z1-9>]p | Zet de inhoud van de (default undo-) buffer <*>
| keer rechts van de cursor (`put'). Een buffer
| die regels bevat, wordt slechts 1 keer
| uitgeschreven, onder de huidige regel.
* | ["<a-zA-Z1-9>]P | Zet de inhoud van de (default undo-) buffer <*>
| keer links van de cursor. Een buffer die
| regels bevat, wordt slechts 1 keer
| uitgeschreven, boven de huidige regel.
* | . | Herhaal het laatste commando <*> keer. Als het
| laatste commando voor een `.'-commando
| verwijst naar een genummerde buffer, wordt het
| nummer van de buffer eerst verhoogd (en wordt
| <*> genegeerd). Voorbeelden:
|
| "1pu.u.u.u.u - `loop' door buffers 1
| tot en met 5
| "1P.... - haal ze terug
* | x | Verwijder <*> chars onder en na de cursor.Terug naar de Index
* | X | <*> chars voor de cursor.
* | d<move> | Van begin- tot eindpunt van <*><move>.
* | dd | <*> regels.
- | D | De rest van de regel.
* | <<move> | Schuif de regels beschreven door <*><move>
| een `shiftwidth' naar links.
* | << | Schuif <*> regels een `shiftwidth' naar links.
* | . | Herhaal laatste commando <*> keer.
* | r<char> | Vervang <*> chars door <char> (`replace') - geen <esc>.Terug naar de Index
* | R | Overschrijf de rest van de regel, voeg <*> - 1 keer toe.
* | s | Vervang <*> chars (`substitute').
* | S | <*> regels.
* | c<move> | Van begin- tot eindpunt van <*><move> (`change').
* | cc | <*> regels.
* | C | De rest van de regel en <*> - 1 volgende regels.
* | =<move> | Als de optie `lisp' aan staat, herschikt dit
| commando de regels beschreven door <*><move>
| alsof ze waren ingevoerd met gebruikmaking van
| de optie `ai'.
- | ~ | Verander hoofd- in kleine letters en omgekeerd (zou een operator moeten zijn, zoals `c').
* | J | Sluit <*> regels aaneen (`join') (default 2).
* | . | Herhaal laatste commando <*> keer (`J' 1 keer).
- | & | Herhaal laatste `ex'-substitutie-commando, bijv. `:s/fout/goed'.
- | :[x,y]s/<p>/<r>/<f> | Vervang [op regels x tot en met y] het patroon
| <p> (default het vorige patroon) door <r>.
| Nuttige vlaggen <f> zijn `g' voor `globaal'
| (d.w.z. verander alle niet-overlappende
| voorkomens van <p>) en `c' voor `confirm'
| (typ `y' om een bepaalde substitutie te
| bevestigen, anders <cr>). In plaats van `/'
| kun je elke andere interpunktie-CHAR ongelijk
| <lf> gebruiken als scheider.
* | y<move> | Yank van begin- tot eindpunt van <*><move>.Terug naar de Index
* | yy | <*> regels.
* | Y | Idem (zou gelijkwaardig met `y$' moeten zijn).
- | m<a-z> | Markeer de cursor positie met een letter.
^@ | Als eerste karakter van een toevoeging wordt hetTerug naar de Index
| vervangen door de vorige toevoeging (max. 128
| chars), waarna de toevoeging is be-eindigd.
^V | Ontdoe de volgende char van zijn speciale betekenis, bijv. <esc>.
^D | Schuif een `shiftwidth' naar links.
0^D | Haal alle indentatie weg (er mogen nog geen andere chars op de regel zijn gezet).
^^D | Idem, maar de indentatie is terug op de volgende regel.
^T | Schuif een `shiftwidth' naar rechts.
^W | Schuif een woord terug.
^H | <erase> | Schuif een char terug.
<kill> | Ga naar het begin van de verandering op de huidige regel.
<intr> | Als <esc> (maar je krijgt ook een piep).
:q | Verlaat vi, tenzij de buffer veranderd is (`quit').Terug naar de Index
:q! | Verlaat vi zonder schrijven.
^Z | Stop vi tijdelijk.
:w | Schrijf de file (`write').
:w <naam> | Schrijf naar de file <naam>.
:w >> <naam> | Voeg de buffer toe aan de file <naam>.
:w! <naam> | Overschrijf de file <naam>.
:x,y w <naam> | Schrijf regels x tot en met y naar <naam>.
:wq | Schrijf en verlaat vi; sommige versies voeren
| het `q'-commando uit zelfs als de `w' mislukt
| is! Gebruik liever `ZZ'.
ZZ | Schrijf als de buffer veranderd is en verlaat vi.
| Als je vi hebt opgestart met de `-r' optie, kun
| je de file maar beter ekspliciet wegschrijven
| (`w' of `w!'), of de editor ekspliciet verlaten
| (`q!') als je de file niet wilt overschrijven -
| sommige versies van vi handelen de `recover'
| optie niet helemaal goed af.
:x [<file>] | Idem [maar schrijf naar <file>] (`eXit').
:x! [<file>] | `:w![<file>]' en `:q'.
:pre | Preserve - de buffer wordt bewaard alsof het
| systeem zojuist ge-crashed is; voor
| noodgevallen, als een `:w'-commando mislukt is
| en je niet weet hoe je je werk kunt behouden
| (zie `vi -r').
:f <naam> | Zet de huidige filenaam op <naam>.
:cd [<dir>] | Zet de werk-directory op <dir> (default je home directory).
:cd! [<dir>] | Idem, maar schrijf de huidige buffer niet weg.
:e [+<cmd>] <file> | Edit een andere file zonder vi te verlaten -
| doordat de inhoud van de buffers bewaard blijft
| (op de undo-buffer na), kan zo tekst gekopieerd
| worden. [Doe het `ex'-commando <cmd> (default
| `$') zodra de nieuwe file ingelezen is.]
| <cmd> mag geen <sp> of <ht> bevatten.
| Zie `het starten van vi'.
:e! [+<cmd>] <file> | Idem zonder de huidige buffer weg te schrijven.
^^ | Ga naar de alternatieve (gewoonlijk de vorige)
| file.
:rew | Begin opnieuw bij de eerste file
| (bij `vi file1 file2 ...') (`rewind').
:rew! | Idem zonder de huidige te schrijven.
:n [+<cmd>] [<files>] | Ga naar de volgende file of geef een nieuwe lijst
| argumenten (`next').
:n! [+<cmd>] [<files>] | Idem zonder de huidige buffer weg te schrijven.
:args | Geef de argumenten, met de huidige file tussen
| `[' en `]'.
^G | Geef file-naam, status, regelnummer en relatieve positie.Als in de volgende commando's het veld <wi> aanwezig is, verandert de `windowsize' in <wi>. Het `window' wordt altijd onderaan geplaatst.
^L | Herschrijf het scherm (soms `^P' of `^R').
^R | Soms vervangt vi een weggegooide regel door een
| `@', weg te halen door `^R' (zie optie `redraw').
[*]^E | Laat <*> volgende regels zien, de cursor blijft
| op de huidige regel (voor zover mogelijk).
[*]^Y | Laat <*> vorige regels zien, de cursor blijft op
| de huidige regel (voor zover mogelijk).
[*]^D | Scroll <*> regels omlaag (`down')
| (default het aantal regels van de vorige
| scroll; initialisatie: halve pagina).
[*]^U | Scroll <*> regels omhoog (`up')
| (default het aantal regels van de vorige
| scroll; initialisatie: halve pagina).
[*]^F | <*> pagina's vooruit (`forward').
[*]^B | <*> pagina's achteruit (`backward') (in oudere
| versies werkt `^B' alleen zonder count).
[*]z[wi]<cr> | Zet regel <*> bovenaan het windowTerug naar de Index
| (default de huidige regel).
[*]z[wi]+ | Zet regel <*> bovenaan het window (default de
| eerste regel van de volgende pagina).
[*]z[wi]- | Zet regel <*> onderaan het window
| (default de huidige regel).
[*]z[wi]^ | Zet regel <*> onderaan het window (default de
| laatste regel van de vorige pagina).
[*]z[wi]. | Zet regel <*> in het midden van het window
| (default de huidige regel).
:map <string> <seq> | <string> wordt ge-interpreteerd als <seq>, bijv.Terug naar de Index
| `:map ^C :!cc %^V<cr>' om `cc' (de C-kompiler)
| aan te roepen vanuit de editor (vi vervangt `%'
| door de huidige filenaam).
:map | Geef alle mappings.
:unmap <string> | Ontdoe <string> van de mapping. Als vi klaagt
| over `non-mapped macros' (terwijl je geen
| typfout hebt gemaakt), doe dan eerst iets als
| `:map <string> Z' en daarna `:unmap <string>'
| (`Z' moet niet zelf een macro zijn), of ga
| eerst naar `ex'-mode met `Q'.
:map! <string> <seq> | Mapping in append mode, bijv.
| `:map! \be begin^V<cr>end;^V<esc>O<ht>'.
| Als in append mode <string> wordt voorafgegaan
| door `^V', treedt geen mapping op.
:map! | Geef alle append mode mappings.
:unmap! <string> | Ontdoe <string> van de mapping (zie `:unmap').
:ab <string> <seq> | Als <string> in append mode wordt voorafgegaan en
| gevolgd door een breekpunt (bijv. <sp> of `,'),
| wordt hij ge-interpreteerd als <seq>, bijv.
| `:ab ^P procedure'. Een `^V' meteen na
| <string> voorkomt ekspansie.
:ab | Geef alle abbreviations.
:unab <string> | Beschouw <string> niet meer als abbreviation (zie `:unmap').
@<a-z> | Beschouw de inhoud van vermeld register als
| commando, bijv.:
| o0^D:s/fout/goed/<esc>"zdd
| Verklaring:
| o - open een nieuwe regel
| 0^D - haal de indentatie weg
| :s/fout/goed/ - deze inputtekst is een
| `ex'-substitutie-commando
| <esc> - be-eindig de input
| "zdd - haal de zojuist gemaakte
| regel weg en stop hem in
| register `z'
| Nu kun je `@z' typen om `fout' door `goed' te
| vervangen op de huidige regel.
@@ | Herhaal het vorige register-commando.
Q | ^\ | <intr><intr> | Ga vanuit vi naar `ex' (`quit').Terug naar de Index
: | Er kan een `ex'-commando gegeven worden.
:vi | Ga vanuit `ex' naar vi.
:sh | Ga naar een subshell, terug naar vi door `^D'.
:[x,y]!<cmd> | Voer een shell-commando uit [op regel x tot en
| met y; deze regels dienen dan als standaard
| input voor het commando en worden vervangen
| door de standaard output].
:[x,y]!! [<args>] | Herhaal het vorige shell-commando (en voeg
| <args> toe).
:[x,y]!<cmd> ! [<args>] | Gebruik het vorige shell-commando (de tweede `!')
| in een nieuw commando.
[*]!<move><cmd> | De shell voert <cmd> uit, met als standaard input
| de regels beschreven door <*><move>.
| De standaard output vervangt vervolgens die
| regels (denk aan `cb', `sort', `nroff', etc.).
[*]!<move>!<args> | Voeg <args> aan het laatste <cmd> toe en voer het
| nieuwe commando uit, met de regels beschreven
| door de huidige <*><move>.
[*]!!<cmd> | Geef <*> regels als standaard input aan het
| shell-commando; de standaard output vervangt
| vervolgens die regels.
[*]!!! [<args>] | Gebruik het vorige commando (met <args>).
:x,y w !<cmd> | Geef regels x tot en met y als standaard input
| aan <cmd> (let op de <sp> tussen de `w' en de
| `!').
:r!<cmd> | Zet de output van <cmd> op een nieuwe regel.
:r <naam> | Lees de file <naam> in (`read').
vi [<files>] | Edit de files, begin bij de eerst pagina van de eerste file.Verder is het handig de editor te initialiseren m.b.v. de shell-variabele `EXINIT'. Een `EXINIT' ziet er als volgt uit:
EXINIT='<cmd>|<cmd>|...'
<cmd>: set opties
map ...
ab ...
export EXINIT (in de Bourne-shell)
De lijst van initialisaties kun je echter ook in een file zetten. Als deze
file in je home directory staat, de naam `.exrc' heeft EN de variabele
EXINIT NIET aangezet is, wordt de lijst automatisch uitgevoerd bij het
opstarten. Echter, vi voert een `.exrc' in de huidige directory altijd uit,
mits jij de eigenaar van de file bent.
On-line initialisaties zijn mogelijk m.b.v. `vi +<cmd> file', bijv.:
vi +x file | De cursor springt meteen naar regel x (defaultJe kunt op een bepaalde `tag' beginnen met:
| de laatste regel).
vi +/<string> file | Spring naar het eerste voorkomen van <string>.
vi -t <tag> | Zet de cursor meteen in de goede file op de goede plaats.Het is soms mogelijk (bijv. na een systeem-crash terwijl je in vi zat) in vi verloren gegane files terug te krijgen door `vi -r file' (`recover'). Als je `vi -r' intypt zonder verdere argumenten, krijg je te zien welke files terug te krijgen zijn.
ai | autoindent - In append mode komt de cursor na een <cr> direkt onder de eerste CHAR op de vorige regel.
| Echter, als de optie `lisp' aanstaat, schikt de cursor zich naar het eerste argument van de laatste open lijst.
aw | autowrite - Schrijven bij iedere shell-escape (handig bij kompileren vanuit vi).
dir=<string> | directory - Geeft aan waar vi temporele files kan aanmaken (default `/tmp').
eb | errorbells - Belgerinkel bij fouten (niet op elke terminal).
ic | ignorecase - Bij zoeken wordt geen onderscheid gemaakt tussen hoofd- en kleine letters.
lisp | Herdefinieer de volgende commando's:
| `(', `)' - ga terug (vooruit) over
| S-expressies
| `{', `}' - idem, maar stop niet bij atomen
| `[[', `]]' - ga naar de vorige (volgende) regel
| die begint met een `('
| Zie optie `ai'.
list | <lf> wordt als `$' weergegeven, <ht> als `^I'.
magic | Als deze optie aanstaat, hebben de chars `.', `['
| en `*' bij zoek- en `ex'-substitutie-commando's
| een speciale betekenis; om ze daarvan te
| ontdoen moet je ze vooraf laten gaan door een
| `\'. Als de optie uitstaat, is het precies
| andersom. Meta-karakters:
| ^<string> - <string> moet een regel beginnen
| <string>$ - <string> moet een regel eindigen
| . - matcht elke char
| [a-z] - matcht elke char in de reeks
| [^a-z] - elke char niet in de reeks
| [<string>] - matcht elke char in <string>
| [^<string>] - elke char niet in <string>
| <char>* - 0 of meer <char>s
| \<<string> - <string> moet een woord beginnen
| <string>\> - <string> moet een woord eindigen
modeline | Als je een bestaande file in de buffer leest, en
| deze optie aanstaat, worden de eerste en
| laatste 5 regels bekeken of ze commando's
| bevatten van de volgende vorm:
|
| <sp>vi:set opties|map ...|ab ...|!...:
|
| In plaats van <sp> kan ook <ht> gebruikt
| worden, in plaats van `vi' mag `ex' staan.
| Waarschuwing: deze optie kan vervelende
| gevolgen hebben als je een file edit waar
| `rare' modelines instaan.
nu | number - Nummers voor de regels.
para=<string> | paragraphs - Elk paar chars in <string> wordt
| beschouwd als een paragraph delimiter nroff
| macro (voor `{' en `}'). Een <sp> voorafgegaan
| door `\' geeft aan dat de vorige char een
| eenletterige macro is. Met `:set para=P\ bp'
| geef je vi aan dat `.P' en `.bp' paragrafen
| scheiden. Verder fungeren lege regels en
| sektie-grenzen ook als paragraaf-grenzen.
redraw | Het scherm blijft up to date.
remap | Als deze optie aanstaat (default), worden macro's
| net zolang ge-ekspandeerd totdat ze onveranderd
| blijven. Bijv. als `o' ge-mapped is op `A', en
| `A' is ge-mapped op `I', dan wordt `o'
| ge-mapped op `I' wanneer `remap' aanstaat en
| anders op `A'.
report=<*> | Vi meldt wanneer bijv. een delete- of yank- commando <*> of meer regels beslaat.
ro | readonly - De file mag niet veranderd worden. Echter: met `:w!' kun je toch schrijven.
sect=<string> | sections - Geeft de section delimiters (voor `[['
| en `]]'); zie optie `para'. Een `{' als eerste
| char op een regel geeft ook het begin van een
| sektie aan (denk aan C-funkties).
sh=<string> | shell - Het programma voor shell escapes
| (default `$SHELL' (default `/bin/sh')).
sw=<*> | shiftwidth - Stelt de `schuifbreedte' in (default
| 8 posities).
sm | showmatch - Laat in append mode bij een `)' even
| het bijbehorende `(' zien als dit op dezelfde
| pagina staat; evenzo bij `{' en `}'. Als er
| geen `match' is, geeft vi dat aan met een piep.
taglength=<*> | Het aantal signifikante karakters in `tags'
| (0 = onbeperkt).
tags=<string> | De door spaties gescheiden lijst van `tags'- files.
terse | Voor korte foutmeldingen.
to | timeout - Als deze optie aanstaat, worden append-
| mode mappings alleen ge-interpreteerd als ze
| snel genoeg worden ingetypt.
ts=<*> | tabstop - De lengte van een <ht>; waarschuwing:
| dit geldt alleen IN de editor, daarbuiten
| hebben <ht>'s de normale lengte (default 8
| posities).
wa | writeany - Geen checks bij schrijven (gevaarlijk).
warn | Waarschuwing bij weggaan zonder te schrijven.
wi=<*> | window - Het aantal regels dat vi uit zichzelf laat zien.
wm=<*> | wrapmargin - Vi zet in append mode automatisch een <lf> als er binnen <wm> kolommen van de
| rechtermarge een <sp> of <ht> wordt gezet (0 = zet geen <lf> in de file, wel op het scherm).
ws | wrapscan - Bij zoeken lopen begin en eind van de
| file in elkaar over.
:set <optie> | Zet <optie> aan.
:set no<optie> | Zet <optie> uit.
:set <optie>=<waarde> | Zet <optie> op <waarde>.
:set | Laat alle niet-default opties zien en hun waarde.
:set <optie>? | Geef de waarde van <optie>.
:set all | Laat alle opties zien en hun waarde.
Terug naar de Index
[an error occurred while processing the directive]