Sto lavorando a un piccolo script Python, che necessita di frequenti esecuzioni per eseguire il debug e svilupparlo ulteriormente.
Posso dividere la schermata di vim ed eseguire il mio script su una parte con una sequenza di tasti?
Sto lavorando a un piccolo script Python, che necessita di frequenti esecuzioni per eseguire il debug e svilupparlo ulteriormente.
Posso dividere la schermata di vim ed eseguire il mio script su una parte con una sequenza di tasti?
Risposte:
Aggiungi questa linea al tuo .vimrc:
command R !./%
E poi puoi semplicemente digitare ": R" mentre sei in Vim per eseguire lo script ( vim-run-current-file )
Vim non lo supporta e non supporterà mai una shell incorporata come emacs o kate (se lo intendi), consulta questa domanda di StackOverflow .
David Spillet ha ragione, puoi eseguire il tuo video all'interno dello schermo di GNU:
$ screen vim foo.txt
Ma questo ti darà solo qualcosa di simile a un gestore di finestre in un terminale - MOLTO utile se usato su ssh o su una scatola senza X, ma localmente puoi anche aprire un altro xterm e passare da uno all'altro. *
Ad ogni modo, se riesci a convivere con il fatto che non vedrai il file che stai modificando mentre guardi l'output che produce, il consiglio di Jack M è buono, ma potrebbe essere più breve:
:map ;e :w<cr>:!python %<cr>
Per lo stesso scopo, ho questo nel mio ~/.vimrc:
au BufEnter *
\if match( getline(1) , '^\#!') == 0 |
\ execute("let b:interpreter = getline(1)[2:]") |
\endif
fun! CallInterpreter()
if exists("b:interpreter")
exec ("!".b:interpreter." %")
endif
endfun
map <F5> :call CallInterpreter()<CR>
Questo esegue qualsiasi file che ha un shebang ( #!) sulla prima riga. Utilizza l'interprete per eseguire il file, quindi non è necessario disporre delle autorizzazioni di esecuzione.
* (lo schermo ha alcune altre funzioni molto pulite come copia e incolla dall'output, monitoraggio di finestre nascoste per attività / nessuna attività, essere in grado di utilizzare la sessione da diversi terminali contemporaneamente, essere in grado di disconnettersi lasciando tutti i programmi in esecuzione - è uno strumento potente).
:map ;e :w<cr>:!python %<cr>vuole fare eco al mio buffer vim per "confermare" (?) che il comando è stato eseguito. Come ottengo semplicemente l'esecuzione silenziosa del comando? :map <silent> ...non sembra funzionare.
Il modo meno dettagliato (che richiede che lo script sia eseguibile) è probabilmente:
:!%
:!./%modo che lo script fosse trovato nella directory corrente.
!dice a Vim di eseguire tutto ciò che segue come comando bash, quindi puoi farlo !echo "Hello". La %viene espansa per essere il nome del file corrente.
C'è una domanda StackOverflow simile .
map <F5> :w<CR>:exe ":!python " . getreg("%") . "" <CR>
È quello che ho usato per favore (F5 esegue lo script corrente).
Per trasformare vim in un potente IDE python, consiglio questo tutorial:
Inserisci questo piccolo frammento nel tuo .vimrc per eseguire il file corrente con una sequenza di tasti (come F5) e visualizzare il risultato in un nuovo buffer a riquadro diviso.
:! va bene ma è necessario passare al terminale per vedere il risultato.
Mentre puoi farlo con ctrl-ze riportare vim con fgesso significa ancora che devi cambiare molto contesto.
Il modo in cui funziona questo frammento è innanzitutto indovinando l'eseguibile in base al filetypee quindi eseguendolo con il file corrente come argomento.
Successivamente un pratico metodo di utilità prende l'output e lo scarica in un nuovo buffer.
Non è perfetto, ma è molto veloce per i flussi di lavoro comuni.
Ecco lo snippet copiato di seguito:
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"""""""""""""""""""""""""" RUN CURRENT FILE """""""""""""""""""""""""""""
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
" Execute current file
nnoremap <F5> :call ExecuteFile()<CR>
" Will attempt to execute the current file based on the `&filetype`
" You need to manually map the filetypes you use most commonly to the
" correct shell command.
function! ExecuteFile()
let filetype_to_command = {
\ 'javascript': 'node',
\ 'coffee': 'coffee',
\ 'python': 'python',
\ 'html': 'open',
\ 'sh': 'sh'
\ }
let cmd = get(filetype_to_command, &filetype, &filetype)
call RunShellCommand(cmd." %s")
endfunction
" Enter any shell command and have the output appear in a new buffer
" For example, to word count the current file:
"
" :Shell wc %s
"
" Thanks to: http://vim.wikia.com/wiki/Display_output_of_shell_commands_in_new_window
command! -complete=shellcmd -nargs=+ Shell call RunShellCommand(<q-args>)
function! RunShellCommand(cmdline)
echo a:cmdline
let expanded_cmdline = a:cmdline
for part in split(a:cmdline, ' ')
if part[0] =~ '\v[%#<]'
let expanded_part = fnameescape(expand(part))
let expanded_cmdline = substitute(expanded_cmdline, part, expanded_part, '')
endif
endfor
botright new
setlocal buftype=nofile bufhidden=wipe nobuflisted noswapfile nowrap
call setline(1, 'You entered: ' . a:cmdline)
call setline(2, 'Expanded Form: ' .expanded_cmdline)
call setline(3,substitute(getline(2),'.','=','g'))
execute '$read !'. expanded_cmdline
setlocal nomodifiable
1
endfunction
Non conosco Vim direttamente, ma puoi dividere lo schermo in questo modo generalmente con l' screenutilità. ctrl+ a, S(nota, che è una S maiuscola) dividerà il display e puoi passare tra i due con ctrl+ a, tab(se la finestra è vuota, usa ctrl+ a, nper spostarti in un'altra finestra aperta o ctrl+ a, cper crearne una nuova) .
Puoi anche dividere il display in più di due e cambiare la dimensione delle divisioni con ctrl-a,: ridimensiona. Uso lo schermo in questo modo spesso, e sebbene non sia la soluzione a chiave singola che chiedi, può essere molto conveniente.