So führen Sie eine Datei aus, die ich in Vi (m) bearbeite

Wie führe ich eine Datei aus, die ich in Vi (m) bearbeite, und erhalte die Ausgabe im geteilten Fenster (wie in SciTE)?

Natürlich könnte ich es so ausführen:

:!scriptname

Aber ist es möglich, das Schreiben von Skriptnamen zu vermeiden und zu vermeiden, dass die Ausgabe im geteilten Fenster statt nur am unteren Bildschirmrand erfolgt?

Da ist der makeBefehl. Es führt den Befehlssatz in der makeprgOption aus. Verwenden Sie %als Platzhalter für die aktuellen Dateinamen. Wenn Sie beispielsweise ein Python-Skript bearbeitet haben:

:set makeprg=python\ %

Ja, du musst dem Raum entkommen. Danach können Sie einfach ausführen:

:make

Wenn Sie möchten, können Sie die autowriteOption festlegen und sie wird automatisch gespeichert, bevor Folgendes ausgeführt wird makeprg:

:set autowrite

Dies löst den Ausführungsteil. Ich kenne keine Möglichkeit, diese Ausgabe in ein geteiltes Fenster zu bringen, das keine Umleitung in eine Datei beinhaltet.

Verwenden Sie, um auf den Dateinamen des aktuellen Puffers zuzugreifen %. Um es in eine Variable zu bekommen, können Sie die expand()Funktion verwenden. Verwenden Sie :newoder, um ein neues Fenster mit einem neuen Puffer zu öffnen :vnew. Verwenden Sie, um die Ausgabe eines Befehls in den aktuellen Puffer zu leiten :.!. Alles zusammen:

:let f=expand("%")|vnew|execute '.!ruby "' . f . '"'

offensichtlich durch einen rubybeliebigen Befehl ersetzen . Ich habe verwendet, executedamit ich den Dateinamen mit Anführungszeichen umgeben kann. Es funktioniert also, wenn der Dateiname Leerzeichen enthält.

Vim hat den !Befehl ("bang"), der den Shell-Befehl direkt aus dem VIM-Fenster ausführt. Darüber hinaus können Sie eine Folge von Befehlen starten, die mit Pipe verbunden sind, und stdout lesen.

Beispielsweise:

! node %

entspricht dem Öffnen des Eingabeaufforderungsfensters und dem Starten von Befehlen:

cd my_current_directory 
node my_current_file

Weitere Informationen finden Sie unter "Vim-Tipps: Arbeiten mit externen Befehlen" .

Ich habe eine Verknüpfung dafür in meinem vimrc:

nmap <F6> :w<CR>:silent !chmod 755 %<CR>:silent !./% > .tmp.xyz<CR>
     \ :tabnew<CR>:r .tmp.xyz<CR>:silent !rm .tmp.xyz<CR>:redraw!<CR>

Dies schreibt den aktuellen Puffer, macht die aktuelle Datei ausführbar (nur Unix), führt sie aus (nur Unix) und leitet die Ausgabe an .tmp.xyz um, erstellt dann eine neue Registerkarte, liest die Datei und löscht sie dann.

Brechen sie ab:

:w<CR>                             write current buffer
:silent !chmod 755 %<CR>           make file executable
:silent !./% > .tmp.xyz<CR>        execute file, redirect output
:tabnew<CR>                        new tab
:r .tmp.xyz<CR>                    read file in new tab
:silent !rm .tmp.xyz<CR>           remove file
:redraw!<CR>                       in terminal mode, vim get scrambled
                                   this fixes it

Für Shell-Skript habe ich verwendet

:set makeprg=%

:make

In Vim 8 ist ein interaktives Terminal integriert. So führen Sie das aktuelle Bash-Skript in einem geteilten Bereich aus:

:terminal bash %

oder kurz gesagt

:ter bash %

% wird auf den aktuellen Dateinamen erweitert.

Von :help terminal:

The terminal feature is optional, use this to check if your Vim has it:
    echo has('terminal')
If the result is "1" you have it.

Ich benutze einen etwas aufdringlicheren Mechanismus durch Karten:

map ;e :w<CR>:exe ":!python " . getreg("%") . "" <CR>

Macht es einfach so, dass ich nicht sparen muss, dann geh. Geh einfach.

Sie können das Plugin bexec von vim verwenden . Meines Wissens ist die neueste Version 0.5.

Dann:

$ mkdir -p ~/.vim/plugin
$ mv bexec-0.5.vba ~/.vim/plugin
$ vim ~/.vim/plugin/bexec-0.5.vba

In vim selbst beim Bearbeiten der .vba-Datei gehen Sie wie folgt vor:

:so %

Einige Ausgaben zeigen an, dass bexec.vim geschrieben wurde, sowie Dokumentation usw.

Jetzt können Sie es testen, indem Sie Ihr (unabhängig von der Sprache funktionierendes Skript, in dem ein #! - Interpreter ordnungsgemäß funktioniert) in vim öffnen und ausführen

:Bexec 

Hinweis: Ich wollte, dass die Aufteilung eher vertikal als horizontal ist, also habe ich Folgendes getan:

$ grep -i -n split ~/.vim/plugin/bexec.vim | grep -i hor
102:    let bexec_splitdir = "hor" " hor|ver
261:        exec {"ver":"vsp", "hor":"sp"}[g:bexec_splitdir]

und änderte den Wert von "hor" in "ver" ..

Ich weiß, dass es eine alte Frage ist, aber ich hoffe, dass dies jemandem da draußen helfen kann. Ich habe in der gleichen Ausgabe gearbeitet, als ich an Courseras Startup Engineering-Kurs teilgenommen habe, in dem Professor Palaji Emacs verwendet und ich Emacs nicht mag.

Basierend auf den Antworten von @SethKriticos und @Cyril verwende ich jetzt Folgendes:

function! Setup_ExecNDisplay()
  execute "w"
  execute "silent !chmod +x %:p"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I prefer vsplit
  "execute "split ~/.vim/output_".n
  execute "vsplit ~/.vim/output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent !%:p 2>&1 | tee ~/.vim/output_".n
  " I use set autoread
  "execute "1 . 'wincmd e'"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

Verwenden Sie F9, um das neue Fenster einzurichten, und F2, um Ihr Skript auszuführen und zu Ihrer Ausgabedatei zu wechseln.

Ich habe auch den Skriptnamen zum Namen der Ausgabedatei hinzugefügt, damit Sie diesen für mehrere Skripte gleichzeitig verwenden können.

In Ihre können .vimrcSie diese Funktion einfügen

function! s:ExecuteInShell(command)
  let command = join(map(split(a:command), 'expand(v:val)'))
  let winnr = bufwinnr('^' . command . '$')
  silent! execute ':w'
  silent! execute  winnr < 0 ? 'vnew ' . fnameescape(command) : winnr . 'wincmd w'
  setlocal buftype=nowrite bufhidden=wipe nobuflisted noswapfile nowrap number
  silent! execute 'silent %!'. command
  silent! redraw
  silent! execute 'au BufUnload <buffer> execute bufwinnr(' . bufnr('#') . ') . ''wincmd w'''
  silent! execute 'nnoremap <silent> <buffer> <LocalLeader>r :call <SID>ExecuteInShell(''' . command . ''')<CR>'
  silent! execute 'wincmd w'
  " echo 'Shell command ' . command . ' executed.'
endfunction
command! -complete=shellcmd -nargs=+ Shell call s:ExecuteInShell(<q-args>)
cabbrev shell Shell

Danach im vimBefehl run :shell python ~/p.pyals Beispiel. Und Sie erhalten die Ausgabe in einem geteilten Fenster. + Nach Änderungen im p.pyBeispiel führen Sie denselben Befehl erneut aus. Diese Funktion erstellt kein neues Fenster, sondern zeigt das Ergebnis im vorherigen (gleichen) geteilten Fenster an.

@xorpaul

Ich habe lange nach diesem Skript (Python / Windows) gesucht. Da es in Windows kein "Tee" gibt, habe ich es geändert in:

function! Setup_ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n ." 2>&1"
  execute "vsplit d:\\temp\\output_".n
  execute "redraw!"
  set autoread
endfunction

function! ExecNDisplay()
  execute "w"
  let n=expand('%:t')
  execute "silent ! python % > d:\\temp\\output_".n . " 2>&1"
endfunction

:nmap <F9> :call Setup_ExecNDisplay()<CR>
:nmap <F2> :call ExecNDisplay()<CR>

Verwenden Sie einfach Doppelpunkt und Ausrufezeichen wie unten gezeigt

:! <Skriptname>