Redigerare (Vim)

Att skriva engelska ord och att skriva kod är två väldigt olika aktiviteter. När du programmerar lägger du mer tid på att byta filer, läsa, navigera och redigera kod än på att skriva långa sammanhängande textstycken. Det är rimligt att det finns olika typer av program för att skriva engelska ord respektive kod (t.ex. Microsoft Word jämfört med Visual Studio Code).

Som programmerare tillbringar vi största delen av tiden med att redigera kod, så det är värt att investera tid i att behärska en redigerare som passar dina behov. Så här lär du dig en ny redigerare:

Om du följer metoden ovan och verkligen förbinder dig till att använda det nya programmet för all textredigering brukar inlärningskurvan för en avancerad textredigerare se ut ungefär så här. På en eller två timmar lär du dig grundfunktioner som att öppna och redigera filer, spara/avsluta och navigera mellan buffertar. Efter ungefär 20 timmar bör du vara lika snabb som du var i din gamla redigerare. Efter det kommer vinsterna: du har tillräcklig kunskap och muskelminne för att den nya redigeraren faktiskt sparar tid. Moderna textredigerare är avancerade och kraftfulla verktyg, så lärandet tar aldrig slut: du blir ännu snabbare ju mer du lär dig.

Vilken redigerare ska man lära sig?

Programmerare har starka åsikter om sina textredigerare.

Vilka redigerare är populära i dag? Se den här Stack Overflow- undersökningen (det kan finnas viss snedvridning eftersom Stack Overflow-användare kanske inte är representativa för programmerare i stort). Visual Studio Code är den mest populära redigeraren. Vim är den mest populära kommandoradsbaserade redigeraren.

Vim

Alla lärare i den här kursen använder Vim som redigerare. Vim har en rik historia; den härstammar från redigeraren Vi (1976) och utvecklas fortfarande i dag. Vim bygger på flera riktigt smarta idéer, och därför stöder många verktyg ett Vim-emuleringsläge (till exempel har 1,4 miljoner personer installerat Vim-emulering för VS code). Vim är sannolikt värt att lära sig även om du i slutänden byter till en annan textredigerare.

Det går inte att lära ut all funktionalitet i Vim på 50 minuter, så vi fokuserar på att förklara filosofin bakom Vim, lära ut grunderna, visa mer avancerade funktioner och ge resurser för att bemästra verktyget.

Vims filosofi

När du programmerar lägger du största delen av tiden på att läsa och redigera, inte skriva. Därför är Vim en modal redigerare: den har olika lägen för att skriva in text respektive manipulera text. Vim är programmerbar (med Vimscript och även andra språk som Python), och själva gränssnittet i Vim är ett programmeringsspråk: tangenttryckningar (med minnesvänliga namn) är kommandon, och kommandona är komponerbara. Vim undviker musen eftersom den är för långsam; Vim undviker till och med piltangenterna eftersom de kräver för mycket handrörelse.

Slutresultatet är en redigerare som kan matcha hastigheten i ditt tänkande.

Modal redigering

Vims design bygger på idén att en stor del av programmerartiden går till att läsa, navigera och göra små redigeringar, snarare än att skriva långa textströmmar. Därför har Vim flera arbetslägen.

Tangenttryckningar har olika betydelse i olika lägen. Till exempel kommer bokstaven x i Insert-läge bara att skriva in tecknet “x”, men i Normal-läge tar den bort tecknet under markören, och i Visual-läge tar den bort markeringen.

I standardkonfigurationen visar Vim aktuellt läge nere till vänster. Start-/standardläget är Normal-läge. Du kommer i allmänhet att tillbringa mest tid mellan Normal-läge och Insert-läge.

Du byter läge genom att trycka <ESC> (escape) för att gå från vilket läge som helst tillbaka till Normal-läge. Från Normal-läge går du till Insert med i, Replace med R, Visual med v, Visual Line med V, Visual Block med <C-v> (Ctrl-V, ibland också skrivet ^V) och Command-line med :.

Du använder tangenten <ESC> mycket när du använder Vim: överväg att mappa om Caps Lock till Escape (macOS- instruktioner) eller skapa en alternativ mappning för <ESC> med en enkel tangentsekvens.

Grunder

Skriva in text

Från Normal-läge trycker du i för att gå till Insert-läge. Nu beter sig Vim som vilken annan textredigerare som helst tills du trycker <ESC> för att återgå till Normal-läge. Detta, tillsammans med grunderna ovan, är allt du behöver för att börja redigera filer i Vim (dock inte särskilt effektivt om du gör all redigering från Insert-läge).

Buffertar, flikar och fönster

Vim håller en uppsättning öppna filer som kallas “buffertar”. En Vim-session har ett antal flikar, där varje flik har ett antal fönster (delade paneler). Varje fönster visar en enda buffert. Till skillnad från andra program du känner till, som webbläsare, finns ingen 1-till-1-koppling mellan buffertar och fönster; fönster är bara vyer. En given buffert kan vara öppen i flera fönster, även inom samma flik. Det kan vara mycket praktiskt, till exempel för att se två olika delar av samma fil samtidigt.

Som standard öppnar Vim med en enda flik som innehåller ett enda fönster.

Kommandorad

Kommandoläget nås genom att skriva : i Normal-läge. Markören hoppar då till kommandoraden längst ned på skärmen. Detta läge har många funktioner, bland annat att öppna, spara och stänga filer samt avsluta Vim.

Vims gränssnitt är ett programmeringsspråk

Den viktigaste idén i Vim är att Vims gränssnitt i sig är ett programmeringsspråk. Tangenttryckningar (med minnesvänliga namn) är kommandon, och kommandona komponeras. Detta möjliggör effektiv navigering och redigering, särskilt när kommandona sitter i muskelminnet.

Rörelse

Du bör tillbringa största delen av tiden i Normal-läge och använda rörelsekommandon för att navigera i bufferten. Rörelser i Vim kallas också “substantiv”, eftersom de syftar på textenheter.

Markering

Visual-lägen:

Du kan använda rörelsetangenter för att göra markering.

Redigeringar

Allt du tidigare gjorde med musen gör du nu med tangentbordet, med redigeringskommandon som kan kombineras med rörelsekommandon. Det är här Vims gränssnitt börjar likna ett programmeringsspråk. Vims redigeringskommandon kallas också “verb”, eftersom verb agerar på substantiv.

Antal

Du kan kombinera substantiv och verb med ett antal, vilket gör att en åtgärd utförs flera gånger.

Modifierare

Du kan använda modifierare för att ändra innebörden av ett substantiv. Några modifierare är i, som betyder “inner” eller “inside”, och a, som betyder “around”.

Demo

Här är en trasig implementation av fizz buzz:

def fizz_buzz(limit):
    for i in range(limit):
        if i % 3 == 0:
            print('fizz')
        if i % 5 == 0:
            print('fizz')
        if i % 3 and i % 5:
            print(i)

def main():
    fizz_buzz(10)

Vi kommer att rätta följande problem:

Se föreläsningsvideon för demonstrationen. Jämför hur ändringarna ovan görs med Vim med hur du hade gjort samma redigeringar i ett annat program. Notera hur få tangenttryckningar som krävs i Vim, vilket låter dig redigera i den hastighet du tänker.

Anpassa Vim

Vim anpassas via en textbaserad konfigurationsfil i ~/.vimrc (som innehåller Vimscript-kommandon). Det finns sannolikt många grundinställningar som du vill slå på.

Vi tillhandahåller en väl dokumenterad grundkonfiguration som du kan använda som startpunkt. Vi rekommenderar att du använder den eftersom den rättar till en del av Vims udda standardbeteende. Ladda ner vår konfiguration här och spara den som ~/.vimrc.

Vim är mycket anpassningsbart, och det är värt att lägga tid på att utforska anpassningsmöjligheter. Du kan titta på andras dotfiles på GitHub för inspiration, till exempel lärarnas Vim-konfigurationer (Anish, Jon (använder neovim), Jose). Det finns också många bra blogginlägg om ämnet. Försök att inte kopiera och klistra in någons fulla konfiguration, utan läs den, förstå den och plocka det du behöver.

Utöka Vim

Det finns massor av insticksmoduler för att utöka Vim. I motsats till föråldrade råd du kan hitta på internet behöver du inte använda en hanterare för insticksmoduler i Vim (sedan Vim 8.0). I stället kan du använda det inbyggda pakethanteringssystemet. Skapa helt enkelt katalogen ~/.vim/pack/vendor/start/ och lägg insticksmoduler där (t.ex. via git clone).

Här är några av våra favoritinsticksmoduler:

Vi försöker undvika att ge en överväldigande lång lista med insticksmoduler här. Du kan titta i lärarnas dotfiles (Anish, Jon, Jose) för att se vilka andra insticksmoduler vi använder. Kolla också in Vim Awesome för fler bra Vim-insticksmoduler. Det finns även mängder av blogginlägg om ämnet: sök till exempel på Vim-insticksmoduler.

Vim-läge i andra program

Många verktyg stöder Vim-emulering. Kvaliteten varierar från bra till mycket bra; beroende på verktyg kanske de inte stöder de mer avancerade Vim-funktionerna, men de flesta täcker grunderna väl.

Skal

Om du använder Bash, använd set -o vi. Om du använder Zsh, bindkey -v. För Fish, fish_vi_key_bindings. Dessutom kan du, oavsett skal, sätta export EDITOR=vim. Detta är miljövariabeln som används för att avgöra vilken redigerare som startas när ett program vill öppna en redigerare. Till exempel använder git denna redigerare för incheckningsmeddelanden.

Readline

Många program använder biblioteket GNU Readline för sitt kommandoradsgränssnitt. Readline stöder också (grundläggande) Vim-emulering, som kan aktiveras genom att lägga till följande rad i filen ~/.inputrc:

set editing-mode vi

Med den här inställningen får till exempel Python-REPL stöd för Vim-bindningar.

Övriga

Det finns till och med vim-tangentbindningstillägg för webbläsare browsers - några populära är Vimium för Google Chrome och Tridactyl för Firefox. Du kan till och med få Vim-bindningar i Jupyter notebooks. Här är en lång lista över program med vim-liknande tangentbindningar.

Avancerad Vim

Här är några exempel som visar kraften i redigeraren. Vi kan inte lära ut alla sådana saker, men du lär dig dem längs vägen. En bra tumregel: varje gång du använder redigeraren och tänker “det måste finnas ett bättre sätt att göra det här” så finns det förmodligen det; slå upp det på nätet.

Sök och ersätt

Kommandot :s (substitute) (dokumentation).

Flera fönster

Makron

Resurser

Övningar

  1. Slutför vimtutor. Obs: den ser bäst ut i ett 80x24 (80 kolumner och 24 rader) terminalfönster.
  2. Ladda ner vår grundläggande vimrc och spara den som ~/.vimrc. Läs igenom den välkommenterade filen (med Vim!) och observera hur Vim ser ut och beter sig något annorlunda med den nya konfigurationen.
  3. Installera och konfigurera en insticksmodul: ctrlp.vim.
    1. Skapa katalogen för insticksmoduler med mkdir -p ~/.vim/pack/vendor/start
    2. Ladda ner insticksmodulen: cd ~/.vim/pack/vendor/start; git clone https://github.com/ctrlpvim/ctrlp.vim
    3. Läs dokumentationen för insticksmodulen. Prova att använda CtrlP för att hitta en fil genom att gå till en projektkatalog, öppna Vim och använda Vim-kommandoraden för att starta :CtrlP.
    4. Anpassa CtrlP genom att lägga till konfiguration i din ~/.vimrc så att CtrlP öppnas med Ctrl-P.
  4. För att öva Vim, gör om Demo från föreläsningen på din egen maskin.
  5. Använd Vim för all textredigering under nästa månad. När något känns ineffektivt, eller när du tänker “det måste finnas ett bättre sätt”, prova att googla - det finns förmodligen ett. Om du fastnar, kom till mottagningstid eller e-posta oss.
  6. Konfigurera dina andra verktyg att använda Vim-bindningar (se instruktionerna ovan).
  7. Anpassa din ~/.vimrc vidare och installera fler insticksmoduler.
  8. (Avancerad) Konvertera XML till JSON (exempelfil) med Vim-makron. Försök göra detta själv, men du kan titta i avsnittet makron ovan om du fastnar.

Edit this page.

Licensed under CC BY-NC-SA.