Vim: ejecuta el script en el que estoy trabajando en una pantalla dividida

Estoy trabajando en un pequeño script de Python, que necesita ejecución frecuente para depurar y desarrollar más.

¿Puedo dividir la pantalla vim y ejecutar mi script en una parte con una pulsación de tecla?

Agregue esta línea a su .vimrc:

command R !./%

Y luego puede escribir ": R" mientras está en Vim para ejecutar el script ( vim-run-current-file )

Vim no lo hace, y nunca admitirá un shell incrustado como emacs o kate (si quiere decir eso), vea esta pregunta de stackoverflow .

David Spillet tiene razón, puedes ejecutar tu vim dentro de la pantalla gnu:

$ screen vim foo.txt

Pero eso solo le dará algo remotamente parecido a un administrador de ventanas en una terminal, MUY útil cuando se usa sobre ssh o en una caja sin X, pero localmente puede abrir otro xterm y cambiar entre ellos. *

De todos modos, si puede vivir con el hecho de que no verá el archivo que está editando mientras mira la salida que produce, la sugerencia de Jack M es buena, pero podría ser más corta:

:map ;e :w<cr>:!python %<cr>

Con el mismo propósito, tengo esto en mi ~/.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>

Esto ejecuta cualquier archivo que tenga un shebang ( #!) en la primera línea. Utiliza el intérprete para ejecutar el archivo, por lo que no necesita tener permisos de ejecución.

* (la pantalla tiene algunas otras características muy buenas como copiar y pegar desde la salida, monitorear las ventanas ocultas en busca de actividad / no actividad, poder usar la sesión desde diferentes terminales al mismo tiempo, cerrar sesión dejando todos los programas corriendo - es una herramienta poderosa).

La forma menos detallada (que requiere que su script sea ejecutable) es probablemente:

 :!%

Puede que no sea pantalla dividida, pero esto funciona bastante bien para mí:

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

Esto se asigna ;epara escribir el archivo actual y ejecutarlo usando python (se supone que python está en su PATH).

El complemento Bexec vim hace exactamente lo que quieres. Atajos de teclado incluidos.

Hay una pregunta similar sobre StackOverflow .

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

Es lo que usé con please (F5 ejecuta el script actual).

Para convertir vim en un poderoso IDE de Python, recomiendo este tutorial:

• http://sontek.net/blog/detail/turning-vim-into-a-modern-python-ide

Coloque este pequeño fragmento en su .vimrc para ejecutar el archivo actual con una sola tecla (como F5) y mostrar el resultado en un nuevo búfer de panel dividido.

:! está bien, pero debe cambiar a su terminal para ver el resultado.

Si bien puedes hacer eso ctrl-zy traer vim de regreso fg, aún significa que debes cambiar mucho de contexto.

La forma en que funciona este fragmento es primero adivinando el ejecutable basado en el archivo filetypey luego ejecutándolo con el archivo actual como argumento.

A continuación, un útil método de utilidad toma la salida y la descarga en un nuevo búfer.

No es perfecto, pero sí muy rápido para flujos de trabajo comunes.

Aquí está el fragmento copiado a continuación:

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
"""""""""""""""""""""""""" 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

No sé sobre vim directamente, pero generalmente puede dividir la pantalla de esta manera con la screenutilidad. ctrl+ a, S(tenga en cuenta que es una S mayúscula) dividirá la pantalla y puede cambiar entre los dos con ctrl+ a, tab(si la ventana está vacía, use ctrl+ a, npara moverse a otra ventana abierta o ctrl+ a, cpara crear una nueva) .

También puede dividir la pantalla en más de dos y cambiar el tamaño de las divisiones con ctrl-a,: redimensionar. Utilizo la pantalla de esta manera a menudo, y aunque no es la solución de una sola clave que pides, puede ser muy conveniente.