Wie speichere und stelle ich mehrere verschiedene Sitzungen in Vim wieder her?

Abhängig von meiner Aufgabe in Vim sind mehrere Registerkarten geöffnet.

Wie kann ich verschiedene Sitzungen für die spätere Verwendung speichern?

Du willst so etwas wie

:mksession ~/mysession.vim

Später können Sie diese VIM-Datei als Quelle verwenden und haben Ihre alte Sitzung wieder:

:source ~/mysession.vim

oder öffnen Sie vim mit der Option -S:

$ vim -S ~/mysession.vim

Möglicherweise möchten Sie diese Sitzungsoptionen in Ihrem vimrc festlegen. Besonders Optionen sind ärgerlich, wenn Sie Ihr vimrc nach dem Speichern der Sitzung geändert haben.

set ssop-=options    " do not store global and local values in a session
set ssop-=folds      " do not store folds

Beachten Sie Folgendes: mksession speichert die Änderungen nicht an den von Ihnen vorgenommenen Dateien. Ich habe diesen Fehler gemacht, vim zu schließen, nachdem ich die Sitzung gespeichert hatte, vorausgesetzt, ich werde von dort aus weitermachen. Aber als ich das nächste Mal die Sitzung öffnete, waren die Änderungen, die ich an den Dateien vorgenommen hatte, weg.

Wenn Sie NERDTree als Datei-Explorer / Dash verwenden, würde ich das xolox / vim-session-Plugin anstelle des integrierten Befehls: mksession empfehlen. Aus irgendeinem Grund: mksession kann NERDTree-Puffer nicht wiederherstellen. Ihr Kilometerstand kann variieren, aber ich dachte, ich würde meine Erfahrungen teilen.

Wenn Sie den Prozess ohne Verwendung von Plugins automatisieren möchten, können Sie Go away verwenden und aus dem Vim Tips Wiki zurückkehren .

Jedes Mal, wenn Sie Vim beenden, wird die aktuelle Sitzung unter ~/.vim/sessionsgespeichert und nach dem Öffnen von Vim wieder geladen. Es basiert auch auf Ihrem aktuellen Pfad. Wenn Sie also Vim aus verschiedenen Verzeichnissen öffnen, haben Sie verschiedene Sitzungen, was sehr nützlich ist, wenn Sie an verschiedenen Projekten arbeiten.

Bearbeiten Sie einfach Ihre ~/.vimrcDatei und fügen Sie Folgendes hinzu:

function! MakeSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  if (filewritable(b:sessiondir) != 2)
    exe 'silent !mkdir -p ' b:sessiondir
    redraw!
  endif
  let b:filename = b:sessiondir . '/session.vim'
  exe "mksession! " . b:filename
endfunction

function! LoadSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  let b:sessionfile = b:sessiondir . "/session.vim"
  if (filereadable(b:sessionfile))
    exe 'source ' b:sessionfile
  else
    echo "No session loaded."
  endif
endfunction

" Adding automatons for when entering or leaving Vim
au VimEnter * nested :call LoadSession()
au VimLeave * :call MakeSession()

Auch für Anfänger ist dieses Skript etwas leicht zu verstehen und anpassen.

Bitte beachten Sie, dass dieses Skript nur für Unix-Systeme (MacOS / Linux) ordnungsgemäß funktioniert. Es muss an Windows angepasst werden.

UPDATE: Wenn Sie den Vorschlag von 0xc0de hinzufügen , können Sie die VimEnterZeile für diese ersetzen , wenn Vim die Sitzung nur laden soll, wenn keine Argumente angegeben sind :

if(argc() == 0)
  au VimEnter * nested :call LoadSession()
endif

Es gibt ein sehr nützliches Plugin für diese Aufgabe vim-startify, das viele andere Dinge wie kürzlich geöffnete Dateien usw. behandelt. Es hat auch eine sehr einfache Oberfläche.

Ich benutze es seit ein paar Tagen und bis jetzt funktioniert es perfekt. Hoffe es hilft dir.

Da dies für mich (und wahrscheinlich auch für andere) der erste Treffer bei Google ist, um mit Sitzungen in Vim zu arbeiten, habe ich beschlossen, @ mathielos Antwort, wie dies automatisch erfolgen soll, ein wenig hinzuzufügen.

Ich mag seinen Code, aber die Hinzufügung der Lösung "nur wenn ohne Argumente" schien etwas zu fehlen. Dies ist meine modifizierte Version:

function! MakeSession(overwrite)
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  if (filewritable(b:sessiondir) != 2)
    exe 'silent !mkdir -p ' b:sessiondir
    redraw!
  endif
  let b:filename = b:sessiondir . '/session.vim'
  if a:overwrite == 0 && !empty(glob(b:filename))
    return
  endif
  exe "mksession! " . b:filename
endfunction

function! LoadSession()
  let b:sessiondir = $HOME . "/.vim/sessions" . getcwd()
  let b:sessionfile = b:sessiondir . "/session.vim"
  if (filereadable(b:sessionfile))
    exe 'source ' b:sessionfile
  else
    echo "No session loaded."
  endif
endfunction

" Adding automatons for when entering or leaving Vim
if(argc() == 0)
  au VimEnter * nested :call LoadSession()
  au VimLeave * :call MakeSession(1)
else
  au VimLeave * :call MakeSession(0)
endif

Die bemerkenswerte Änderung hier ist die optionale Überschreibung. Wenn Sie Vim ohne Optionen öffnen, werden alle vorhandenen Sitzungen geöffnet und die beim Verlassen vorgenommenen Änderungen überschrieben. Wenn Vim mit Optionen geöffnet wird, wird nur dann eine neue Sitzung erstellt, wenn keine vorhanden ist. Dies bedeutet, dass Sie einzelne Dateien in einem Verzeichnis mit einer Sitzung öffnen können, ohne sie zu überschreiben. Anschließend können Sie Vim ohne Optionen öffnen, um stattdessen die Sitzung auszuführen. Wenn keine Sitzung vorhanden ist, wird eine neue erstellt.

Es gibt diese wunderbare Plugin Call Vim-Session . Es ist sehr mächtig. So installieren Sie es:

cd ~/.vim/bundle
git clone https://github.com/xolox/vim-session.git

Ich habe seine Funktionalität in meiner .vimrcDatei folgendermaßen zugeordnet:

nnoremap <leader>so :OpenSession 
nnoremap <leader>ss :SaveSession 
nnoremap <leader>sd :DeleteSession<CR>
nnoremap <leader>sc :CloseSession<CR>

Geben <leader>ssSie jetzt im normalen Modus einfach ein und Sie sehen einen Befehl wie diesen

:SaveSession 

Fügen Sie nun den Namen Ihrer Sitzung hinzu

 :SaveSession namesession

und das ist alles.

Wenn Sie Vim schließen und erneut öffnen, tun Sie es einfach

 :OpenSession

und Sie werden sehen, dass Ihre Sitzung geöffnet ist.

Es gibt viele andere Konfigurationen, die Sie in Ihre .vimrcDatei einfügen können. Beispiele finden Sie in der Dokumentation:

let g:session_directory = "~/.vim/tmp/session"  // the directory must be created before the sessions will be saved there
let g:session_autoload = "no"                   // automatic reload sessions
let g:session_autosave = "no"                   // autosave
let g:session_command_aliases = 1

Auf YouTube gibt es ein gutes Tutorial .

Persönlich wickle ich einfach das Obsession- Plugin von Tim Pope ein, um die Definition eines sessiondirPfads zu ermöglichen und die Eingabe des Pfads zu vermeiden:

let g:sessiondir = $HOME . ".vim/sessions"

command! -nargs=1 MkSession call MkSession(<f-args>)
function! MkSession(sessionfile)
  if !isdirectory(g:sessiondir)
    call mkdir(g:sessiondir, "p")
  endif
  exe 'Obsession' g:sessiondir . '/' . a:sessionfile
endfunction

command! -nargs=1 LoadSession call LoadSession(<f-args>)
function! LoadSession(sessionfile)

  let a:sessionpath = g:sessiondir . a:sessionfile
  if (filereadable(a:sessionpath))
    exe 'source ' a:sessionpath
  else
    echo "No session loaded."
  endif
endfunction

Danke @mathielo Nach dem Beispiel von @mathielo habe ich die folgende Zeile zu .vimrc hinzugefügt, um die aktive Sitzung (falls vorhanden) zu speichern:

au VimLeave * if this_session != "" | exe "mksession! ".this_session

Wenn Sie mehr Zeilen einfügen möchten, müssen Sie endif verwenden:

au VimLeave * if v:this_session != ""
au VimLeave *   exe "mksession! ".this_session
au VimLeave * endif

Sie müssen nur eine neue Sitzung in vim mit speichern

:mks [Session filename]

und nach dem Start mit

$ vim -S [Session filename]

vim startet die Sitzung und Sie müssen sich keine Sorgen machen, um die Sitzung jedes Mal zu speichern, wenn Sie vim schließen.

Wenn Sie keine aktive Sitzung haben, führt .vimrc nichts aus. Wie vorher.

Das habe ich gesucht! Nochmals vielen Dank @mathielo!

Wenn Sie nur eine Sitzung für das Projekt planen, tun Sie dies einfach

:mks

Dadurch wird eine Session.vimDatei im aktuellen Verzeichnis erstellt und anschließend die Sitzung (aus demselben Verzeichnis) geöffnet:

vim -S

Wenn Sie die Sitzung ändern und speichern möchten:

:mks!

Dies speichert die Sitzung, nicht die Dateien selbst!

Wenn Sie mehrere Sitzungen planen, möchte ich diese lieber in versteckten Dateien im Projektverzeichnis speichern:

:mks .session-name.vim

So öffnen Sie es (aus demselben Verzeichnis):

vim -S .session-name.vim

Sitzung speichern:

:mks! .session-name.vim

Da die Sitzungen in versteckten Dateien gespeichert sind, vergessen Sie nicht, sie anzuzeigen -a

ls -a

Sie können die Sitzung speichern, wo immer Sie möchten.

Ex:

:mksession! D:/session.ses

Dadurch wird die Sitzung im Laufwerk D gespeichert.

Dies kann durch Eingabe geöffnet werden

:so D:/session.ses

in einer der vim-Dateien.

Unten ist die einzige conf. das hat bei mir wirklich geklappt. Ich habe es von hier genommen , wo Sie auch eine vollständigere / komplexere Version nehmen können.

set viewoptions+=cursor,folds,slash,unix
set viewoptions-=options

augroup vimrc
    autocmd BufWritePost *
    \   if expand('%') != '' && &buftype !~ 'nofile'
    \|      mkview
    \|  endif
    autocmd BufRead *
    \   if expand('%') != '' && &buftype !~ 'nofile'
    \|      silent loadview
    \|  endif
augroup END

Für die Verwaltung mehrerer Sitzungen (pro Verzeichnis / Repo-Basis) habe ich kürzlich vom vim-session-Plugin zum vim-workspace gewechselt . Das Sitzungsmanagement ist relativ einfach und funktioniert ziemlich gut.