5 unverzichtbare Vim-Plug-ins, die deinen Workflow auf den Kopf stellen

Lesezeit: 5 Minuten

March 09, 2021
Autor:in:
Sam Agnew
Twilion

5 unverzichtbare Vim-Plug-ins, die deinen Workflow auf den Kopf stellen


Hallo und Danke fürs Lesen! Dieser Blogpost ist eine Übersetzung von 5 Must-Have Vim Plugins That Will Change Your Workflow. Während wir unsere Übersetzungsprozesse verbessern, würden wir uns über Dein Feedback an help@twilio.com freuen, solltest Du etwas bemerken, was falsch übersetzt wurde. Wir bedanken uns für hilfreiche Beiträge mit Twilio Swag :)

Echte Fans des beliebten Texteditors Vim schätzen vor allem, dass er endlos erweiterbar ist. Zusätzlich zu den Funktionen zum Konfigurieren grundlegender Zuordnungen, Einstellungen und Verhaltensweisen in .vimrc gibt es massenweise sensationelle Plug-ins, die die Funktionalität von Vim erweitern. Vim ist bereits seit über 7 Jahren mein favorisierter Editor, daher teile ich im Folgenden das, was meiner Meinung nach jeder Vim-Nutzer wissen sollte.

Installieren und Verwalten von Plug-ins

Bevor wir uns mit den Plug-ins befassen, muss Vim natürlich erst einmal korrekt installiert und verwaltet werden. Hier führen viele Wege nach Rom.

Nativer Paket-Support in Vim 8

Ab der Version Vim 8 bietet Vim einen integrierten Support für Pakete, die wir für die Installation der Pakete verwenden können. In diesem Post verlinke ich ein GitHub-Repository für jedes einzelne von mir vorgestellte Plug-in. Mit Vim 8-Paketen kannst du die meisten dieser Pakete klonen, um sie hinzufügen.

Vim betrachtet jedes Verzeichnis unter ~/.vim/pack als Paket. Diese Pakete können ein start-Verzeichnis haben, in dem Plug-ins beim Start geladen werden, und ein opt-Verzeichnis mit Plug-ins, die über den Befehl :packadd manuell geladen werden müssen.

Bei den meisten Plug-ins können wir mit git clone deren Repository direkt in ~/.vim/pack/start oder ~/.vim/pack/opt klonen, um sie hinzuzufügen. Du kannst auch Sub-Module von Git zur Verwaltung verwenden, wie in diesem Blogpost beschrieben.

Verwenden von Plugin Managern wie Vundle

Es gibt auch automatisierte Plug-in-Manager für Vim, wie Vundle oder vim-plug, die von der Community entwickelt wurden. Wir brauchen diese für ältere Versionen von Vim, aber selbst für Vim 8-Nutzer sind sie hilfreich, da sie zusätzliche Funktionen bereitstellen und uns das Leben erleichtern, wenn wir viele Plug-ins nutzen.

In den letzten Jahren habe ich Vundle oft genutzt, sehen wir uns also an, wie es eingerichtet wird. Betrachte es als Ausgangspunkt in der Reihe genialer Vim-Plug-ins, mit denen wir uns in diesem Post befassen.

Vundle setzt voraus, dass Git auf deinem Rechner installiert und funktionstüchtig ist. Für alle Windows-Nutzer schrieben die Betreiber eine detaillierte Anweisung für die Installation unter Windows. Führe auf Unix-basierten Systemen den folgenden Befehl zur Installation aus:

git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim

Füge dann die folgenden Zeilen zu .vimrc hinzu:

set nocompatible " be iMproved, required
filetype off " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" alternatively, pass a path where Vundle should install plugins
"call vundle#begin('~/some/path/here')

" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'

" All of your Plugins must be added before the following line
call vundle#end()            " required
filetype plugin indent on    " required

Du kannst Plug-ins installieren, indem du Vim startest und :PluginInstall ausführst. Wenn du die Installation von Vundle in .vimrc automatisieren möchtest, z. B. bei der Einrichtung auf einem neuen Rechner, fügst du ein Skript hinzu, das dem in diesem Blogpost ähnelt:

" Setting up Vundle - the vim plugin bundler
    let iCanHazVundle=1
    let vundle_readme=expand('~/.vim/bundle/vundle/README.md')
    if !filereadable(vundle_readme)
        echo "Installing Vundle.."
        echo ""
        silent !mkdir -p ~/.vim/bundle
        silent !git clone https://github.com/VundleVim/Vundle.vim ~/.vim/bundle/vundle
        let iCanHazVundle=0
    endif

    set nocompatible              " be iMproved, required
    filetype off                  " required
    set rtp+=~/.vim/bundle/vundle/

    call vundle#begin()
    Plugin 'VundleVim/Vundle.vim'

    "Add your bundles here

    if iCanHazVundle == 0
        echo "Installing Vundles, please ignore key map error messages"
        echo ""
        :PluginInstall
    endif

    call vundle#end()

    "must be last
    filetype plugin indent on " load filetype plugins/indent settings
    colorscheme solarized
    syntax on                      " enable syntax
 
" Setting up Vundle - the vim plugin bundler end

Damit wird Vundle automatisch installiert und alle Plug-ins werden beim Ausführen von Vim eingerichtet. Aber nun zum guten Zeug!

Syntastic

Syntastic ist ein syntaxüberprüfendes Plug-in für Vim, das Dateien über externe Syntax-Checker ausführt und sich daraus ergebende Fehler anzeigt. Wir können Syntastic mit Vundle installieren, indem wir die folgende Zeile zu .vimrc in den #begin- und #end-Vundle-Aufrufen hinzufügen:

Plugin 'Syntastic'

Syntastic – Anzeigefehler

Hier sehen wir, wie Syntastic auf meinen Tippfehler bei Flask als Flaks reagiert und beim Schreiben der Datei die Fehler markiert. Ein tatsächlicher Syntax-Fehler, zum Beispiel ein fehlender Doppelpunkt bei einer if-Anweisung, wird ebenfalls gekennzeichnet. Eine Unterstreichung am Zeilenende zeigt uns sogar, wo sich das Problem befindet.

Syntastic mit Cursor-Hervorhebung

Du kannst die Einstellungen von Syntastic sogar etwas konfigurieren. Versuche, den Befehl :help syntastic einzugeben, um mehr Infos zu erhalten. Ich empfehle dir einige grundlegende Standardeinstellungen, die du zu .vimrc hinzufügst, damit du loslegen kannst:

set statusline+=%#warningmsg#
set statusline+=%{SyntasticStatuslineFlag()}
set statusline+=%*

let g:syntastic_enable_signs=1
let g:syntastic_auto_loc_list = 1
let g:syntastic_check_on_open = 1
let g:syntastic_check_on_wq = 1

Mit diesen Einstellungen siehst du Folgendes, wenn du eine fehlerhafte Datei öffnest. Es öffnet sich ein weiterer Puffer in horizontaler Aufteilung mit Infos zum Fehler, der sich nach der Fehlerbehebung wieder schließt.

Syntastic – Fehler in ihrem eigenen Puffer

Hier findest du eine Anleitung zu den mit Syntastic kompatiblen Syntax-Checkern, um den für die von dir genutzte Programmiersprache geeigneten zu installieren. Für Python verwende ich flake8 mit eigenem Vim-Plug-in. Wir können flake8 auch installieren, indem wir pip install flake8 mit dem zur verwendeten Version von Python passenden pip ausführen.

Fugitive

Fugitive ist ein Git-Wrapper für Vim, von dem die Entwickler sagen, er sei verboten genial. Installiere Fugitive mit Vundle, indem du die folgende Zeile zu .vimrc in die #begin- und #end-Vundle-Aufrufe hinzufügst:

Plugin 'https://github.com/tpope/vim-fugitive'

Mit Fugitive führen wir :Git oder einfach nur :G, gefolgt von einem beliebigen Git-Befehl aus, um diesen Befehl direkt in Vim auszuführen und den Output in einem Fluss wiederzugeben. Das funktioniert besonders gut mit Befehlen, die nicht so großen Output haben.

Hier ist beispielsweise eine einfache Funktionalität zum Hinzufügen der Änderungen der Datei, an der du gerade arbeitest, um eine Zusage vorzubereiten.

„git add“ von Vim mit Fugitive

Eine meiner Lieblingsfunktionen ist die, mit der bei Verwendung des :Gblame-Befehls ein Puffer in vertikaler Aufteilung geöffnet wird, in dem alle git blame-Notizen nebeneinander mit den Zeilen der Datei angezeigt werden, an der du gerade arbeitest. Selbst beim Scrollen bleibt die Verbindung erhalten!

Fugitive „Gblame“-Befehl

Der Rest liegt eindeutig nur noch an mir. Wenn du noch mehr erfahren möchtest, ist dieses VimCast ein ausgezeichnetes Demo, das viele coole Aspekte von Fugitive behandelt.

NERDTree

NERDTree ist ein Dateisystem-Explorer für Vim, mit dem wir visuell komplexe Verzeichnishierarchien durchsuchen, zu lesende oder zu bearbeitende Dateien blitzschnell öffnen und grundlegende Dateisystem-Aktionen durchführen können.

NERDTree-Verzeichnisanzeige

Wir können NERDTree mit Vundle installieren, indem wir die folgende Zeile zu .vimrc in den #begin- und #end-Vundle-Aufrufen hinzufügen:

Plugin 'scrooloose/nerdtree'

Führe den :NERDTree-Befehl aus, um einen weiteren Puffer zu öffnen, der vertikal aufgeteilt und an der Seite der aktuellen Datei angezeigt wird. Er zeigt das aktuelle Verzeichnis an, ermöglicht die gängige Navigation im Dateisystem und das Öffnen anderer Dateien.

NERDTree erstellt keine Tastenkombinationen außerhalb seines Fensters, daher kommt es zu keinerlei Behinderungen mit eigenen, bereits genutzten Tastenkombinationen. Dennoch können wir einige Tastenkombinationen zu .vimrc für ein paar NERDTree-Befehle hinzufügen. Beispiel:

nnoremap <leader>n :NERDTreeFocus<CR>
nnoremap <C-n> :NERDTree<CR>
nnoremap <C-t> :NERDTreeToggle<CR>
nnoremap <C-f> :NERDTreeFind<CR>

Hier findest du einige Tastenkombinationen, die zu .vimrc hinzugefügt werden können, um das Funktionsverhalten von NERDTree anzupassen:

" Start NERDTree when Vim is opened and leave the cursor in it.
autocmd VimEnter * NERDTree

" Start NERDTree when Vim is opened and put the cursor back in the other window.
autocmd VimEnter * NERDTree | wincmd p


" Open the existing NERDTree on each new tab.
autocmd BufWinEnter * silent NERDTreeMirror

" Exit Vim if NERDTree is the only window left.
autocmd BufEnter * if tabpagenr('$') == 1 && winnr('$') == 1 && exists('b:NERDTree') && b:NERDTree.isTabTree() |
    \ quit | endif

Es gibt sogar NERDTree-Plug-ins, mit denen Symbole neben den Dateien basierend auf ihrem Dateityp hinzugefügt werden. Bei Vim haben sogar die Plug-ins anpassbare Plug-ins.

Emmet

Emmet ist ein extrem nützliches Plug-in für Web-Entwickler. Es erleichtert das Schreiben und Bearbeiten von HTML sowie allen anderen Programmiersprachen, die Tags nutzen, um ein Vielfaches. Wir können Emmet mit Vundle installieren, indem wir die folgende Zeile zu .vimrc in den #begin- und #end-Vundle-Aufrufen hinzufügen:

Plugin 'mattn/emmet-vim'

Wir können jeden beliebigen Tag erweitern und sogar integrierte, häufig verwendete Befehle nutzen, z B. html:5,  durch Eingabe von <c-y>, (Ctrl+y+,).

Emmet HTML-Demo

Hier findest du ein kurzes Tutorial zu den vielseitigen Dingen, die wir mit Emmet tun können. Wie bei allen Vim-Plug-ins können wir das Verhalten in .vimrc anpassen. Hier ein paar Beispiele:

let g:user_emmet_mode='n'    "only enable normal mode functions.
let g:user_emmet_mode='inv'  "enable all functions, which is equal to
let g:user_emmet_mode='a'    "enable all function in all mode.

" only enable Emmet for certain file types
let g:user_emmet_install_global = 0
autocmd FileType html,css EmmetInstall

" redefine the trigger key (you still need to enter the trailing ,)
let g:user_emmet_leader_key='<C-Z>'

Airline

Airline ist ein federleichtes Status-/Tabline-Feature nach dem „Quick & Dirty-Prinzip“, das du schon in den Screenshots zu den anderen Beispielen gesehen hast. Hier siehst du, wie sich die Statuszeile ändert, wenn ich verschiedene Modi eingebe, und wie eine Menge kontextuelle Informationen bereitgestellt werden.

Airline-Anzeigedemo

Diese Zeile besteht aus verschiedenen Abschnitten, die jeweils Bruchstücke an Informationen anzeigen. Standardmäßig (ohne Konfiguration) sieht das so aus:

+-----------------------------------------------------------------------------+
| A | B |                     C                            X | Y | Z |  [...] |
+-----------------------------------------------------------------------------+
  • A: zeigt den Modus + zusätzliche Markierungen wie crypt/spell/paste (INSERT) an
  • B: Umgebungsstatus (VCS-Information - Zweig, Hunk-Zusammenfassung (Master), Akkuladestand)
  • C: Dateiname + Schreibschutz-Attribut (~/.vim/vimrc RO)
  • X: Dateityp
  • Y: Dateikodierung[Dateiformat] (utf-8[unix])
  • Z: Aktuelle Position in der Datei
  • [...]: zusätzliche Abschnitte (Warnung/Fehler/Statistiken) von externen Plug-ins (z. B. YCM, syntastic usw.)

Wir können Airline mit Vundle installieren, indem wir die folgende Zeile zu .vimrc in den #begin- und #end-Vundle-Aufrufen hinzufügen:

Plugin 'bling/vim-airline'

:wq!

Ich hoffe, dass du diesem Post viel Interessantes und Hilfreiches entnehmen konntest. Vieles davon ist der Vim-Community bereits bekannt, aber es gibt einige Plug-ins, von denen ich denke, dass sie jeder Vim-Nutzer kennen sollte. Ich werde noch einen weiteren Post zu weniger bekannten Plug-ins schreiben.

Als Vim-Fan freue ich mich natürlich, Neues darüber zu erfahren, was ich alles zu .vimrc hinzufügen kann. Ich halte mich auf keinen Fall für einen Experten und es gibt in Bezug auf Vim immer wieder Neues zu erfahren. Kontaktiert mich und erzählt mir von euren coolen Vim-Tricks, stellt mir Fragen oder kritisiert mich zu meinen Vorschlägen in Grund und Boden:

Verwandte Posts

Ähnliche Ressourcen

A newspaper article

Twilio Docs

Von APIs über SDKs bis hin zu Beispiel-Apps

API-Referenzdokumentation, SDKs, Hilfsbibliotheken, Schnellstarts und Tutorials für Ihre Sprache und Plattform.
An Open book

Ressourcen-Center

Die neuesten E-Books, Branchenberichte und Webinare

Lernen Sie von Customer-Engagement-Experten, um Ihre eigene Kommunikation zu verbessern.
User group reactions

Ahoy

Twilios Entwickler-Community-Hub

Best Practices, Codebeispiele und Inspiration zum Aufbau von Kommunikations- und digitalen Interaktionserlebnissen.