Tutorial zum Erstellen von VIM-Plugins?

Ich möchte ein Skript erstellen, das eine Reihe von Befehlen ausführt (im Grunde nur zwei Zeilen):

: v / \ S / d
: w

Aber ich kann kein Tutorial darüber finden, wie es gemacht wird. Jemand?

Es gibt viele Möglichkeiten, um fortzufahren.

A- Sie können ein einfaches Skript schreiben, das die Zeilen enthält, die Sie ausführen möchten, und es manuell aufrufen. Ex:

" $HOME/.vim/macros/foo.vim
:v/\S/d_
:update
" EOF

" and from vim
:runtime macros/foo.vim
" or
:so ~/.vim/macros/foo.vim

B- Sie können ein Plugin haben, das etwas enthält, das auslöst, was Sie ausführen möchten. Wenn die Aktion etwas komplex ist, ziehen wir es normalerweise vor, eine Funktion für Wartungszwecke zu definieren.

B.1. Wenn die Funktion kurz genug ist und jedes Mal verwendet wird, wenn Sie vim verwenden, können Sie sie in Ihrem Plugin definieren.

B.1.1. Wenn Sie die Funktion lieber direkt aufrufen möchten (normalerweise nie) :call Foo(), müssen Sie sie öffentlich machen, indem Sie ihr einen Namen geben, der mit einem Großbuchstaben beginnt:

" ~/.vim/plugin/foo.vim
function! Foo()
    :v/\S/d_
    :update
endfunction

(Diese Lösung verschmutzt den globalen Namespace , außerdem können andere Plugins ihn überschreiben.)

B.1.2 Normalerweise definieren wir entweder eine Zuordnung oder einen Befehl, der die Funktion aufruft. Auf diese Weise kann die Funktion lokal für das aktuelle Skript erstellt werden - der Name beginnt mit s:.

" ~/.vim/plugin/foo.vim
function! s:Foo()
    :v/\S/d_
    :update
endfunction

Jetzt können Sie entweder einen Befehl definieren:

" ~/.vim/plugin/foo.vim
command! -nargs=0 Foo call s:Foo()

oder eine Zuordnung:

" ~/.vim/plugin/foo.vim
" to call a script-local function from a mapping (defined in the same script!)
" we need to use <sid> instead of s:
nnoremap µ :call <sid>Foo()<cr>

" or the more "professional" way that permits other users to choose another 
" trigger for the mapping
nnoremap <Plug>Foo :call <sid>Foo()<cr>
if !hasmapto('<Plug>Foo', 'n')
    nmap µ <Plug>Foo
endif

" ~/.vimrc
" this way some users may bind the action to anything else in their .vimrc
" while the default mapping on µ is defined for the all the other users
:nmap <f11> <Plug>Foo

B.2. Wenn die Funktion für sich genommen sehr lang ist oder aufgrund der anderen Funktionen, die sie zur Ausführung ihrer Arbeit benötigt, und / oder wenn die Funktion selten verwendet wird, ziehen wir es vor, sie in einem Autoload-Plugin zu definieren:

" ~/.vim/autoload/yourinitials/foo.vim
" NB: I use my initials (lh) to avoid name clashes on common filenames
function! yourinitials#foo#bar()
   ....

und der Aufruf der (öffentlichen) Funktion vom Plugin erfolgt unter Verwendung des ... Funktionsnamens:

" ~/.vim/plugin/foo.vim
command! -nargs=0 Foo call yourinitials#foo#bar()
nnoremap <Plug>Foo :call yourinitials#foo#bar()<cr>

Letzte Anmerkungen:

Wir bieten normalerweise Anti-Inclusion-Schutzfunktionen für Plugins (und ftplugins), jedoch nicht für einfache Skripte oder Autoload-Plugins. Dies liegt daran, dass man möglicherweise verhindern möchte, dass aus der .vimrc-Datei einige Plugins geladen werden. Anmerkung: Das Plugin muTemplate, das ich pflege , enthält Skelette für die verschiedenen Arten von Vim-Skripten.

Möglicherweise möchten wir jedoch irgendwann ein bestimmtes Plugin neu laden, das wir verwalten, um die (neuen) Funktionen, die wir entwickeln, zu verwenden / zu testen / zu optimieren. In diesem Fall ist es wichtig, dass die Definitionen der Funktionen und Befehle mit a !verknüpft werden, damit sie überschrieben werden können.

command! Foo vglobal/\S/delete _|update