Vim: execute o script em que estou trabalhando em uma tela dividida

Estou trabalhando em um pequeno script python, que precisa de execução frequente para depurar e desenvolver ainda mais.

Posso dividir a tela do vim e executar meu script em uma parte com um pressionamento de tecla?

Adicione esta linha ao seu .vimrc:

command R !./%

E então você pode digitar ": R" enquanto estiver no Vim para executar o script ( vim-run-current-file )

O Vim não suporta e nunca suportará um shell incorporado como o emacs ou kate (se você quer dizer isso), consulte esta pergunta sobre o stackoverflow .

David Spillet está certo, você pode executar seu vim na tela do gnu:

$ screen vim foo.txt

Mas isso só lhe dará algo remotamente parecido com um gerenciador de janelas em um terminal - MUITO útil quando usado sobre ssh ou em uma caixa sem X, mas localmente você também pode abrir outro xterm e alternar entre eles. *

De qualquer forma, se você pode conviver com o fato de não ver o arquivo que está editando enquanto observa a saída que produz, a dica de Jack M é boa, mas pode ser mais curta:

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

Para o mesmo propósito, tenho isso no meu ~/.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>

Isso executa qualquer arquivo que tenha um shebang ( #!) na primeira linha. Ele usa o intérprete para executar o arquivo, portanto, não precisa ter permissões de execução.

* (a tela possui outros recursos muito interessantes, como copiar e colar da saída, monitorar janelas ocultas quanto à atividade / não atividade, ser capaz de usar a sessão de diferentes terminais ao mesmo tempo, ser capaz de sair, deixando todos os programas executando - é uma ferramenta poderosa).

A maneira menos detalhada (que requer que seu script seja executável) é provavelmente:

 :!%

Pode não ser tela dividida, mas isso funciona muito bem para mim:

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

;eEle mapeia para gravar o arquivo atual e executá-lo usando python (pressupõe que python esteja no seu PATH).

O plug- in Bexec vim faz exatamente o que você deseja. Atalhos de teclado incluídos.

Há uma pergunta semelhante ao StackOverflow .

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

É o que eu usei com por favor (F5 executa o script atual).

Para transformar o vim em um poderoso IDE python, recomendo este tutorial:

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

Coloque este pequeno trecho no seu .vimrc para executar o arquivo atual com um toque de tecla (como F5) e exiba o resultado em um novo buffer de painel dividido.

:! está tudo bem, mas você precisa mudar para o seu terminal para ver o resultado.

Embora você possa fazer isso ctrl-ze trazer o vim de volta, fgele ainda significa que você precisa mudar muito de contexto.

A maneira como esse snippet funciona é adivinhando o executável com base no filetypee executando-o com o arquivo atual como argumento.

Em seguida, um método utilitário útil pega a saída e a despeja em um novo buffer.

Não é perfeito, mas é muito rápido para fluxos de trabalho comuns.

Aqui está o trecho copiado abaixo:

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

Não conheço o vim diretamente, mas você pode dividir a tela dessa maneira geralmente com o screenutilitário. ctrl+ a, S(observe que é um S maiúsculo) dividirá a exibição e você poderá alternar entre os dois com ctrl+ a, tab(se a janela estiver vazia, use ctrl+ a, npara mover para outra janela aberta ou ctrl+ a, cpara criar uma nova) .

Você também pode dividir a exibição em mais de duas e alterar o tamanho das divisões com ctrl-a,: redimensionar. Uso a tela dessa maneira com frequência e, embora não seja a solução de chave única solicitada, pode ser muito conveniente.