Vim: exécuter le script sur lequel je travaille sur un écran partagé

Je travaille sur un petit script python, qui nécessite une exécution fréquente afin de déboguer et de se développer davantage.

Puis-je diviser l'écran vim et exécuter mon script sur une partie avec une touche?

Ajoutez cette ligne à votre .vimrc:

command R !./%

Et puis vous pouvez simplement taper ": R" dans Vim pour exécuter le script ( vim-run-current-file )

Vim ne prend pas en charge et ne prendra jamais en charge un shell intégré comme emacs ou kate (si vous le pensez), consultez cette question de stackoverflow .

David Spillet a raison, vous pouvez lancer votre vim dans l'écran gnu:

$ screen vim foo.txt

Mais cela ne vous donnera que quelque chose ressemblant à distance à un gestionnaire de fenêtres dans un terminal - TRÈS utile lorsqu'il est utilisé sur ssh ou sur une boîte sans X, mais localement, vous pouvez tout aussi bien ouvrir un autre xterm et basculer entre eux. *

Quoi qu'il en soit, si vous pouvez vivre avec le fait que vous ne verrez pas le fichier que vous éditez en regardant la sortie qu'il produit, le conseil de Jack M est bon, mais pourrait être plus court:

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

Dans le même but, je l'ai dans mon ~/.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>

Cela exécute tout fichier qui a un shebang ( #!) sur la première ligne. Il utilise l'interpréteur pour exécuter le fichier, il n'a donc pas besoin d'avoir des autorisations d'exécution.

* (l'écran a d'autres fonctionnalités très intéressantes comme le copier-coller de la sortie, la surveillance des fenêtres cachées pour l'activité / la non-activité, la possibilité d'utiliser la session à partir de différents terminaux en même temps, la possibilité de se déconnecter en laissant tous les programmes en cours d'exécution - c'est un outil puissant).

La façon la moins verbeuse (qui nécessite que votre script soit exécutable) est probablement:

 :!%

Ce n'est peut-être pas un écran partagé, mais cela fonctionne plutôt bien pour moi:

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

Cela mappe ;epour écrire le fichier actuel et l'exécute en utilisant python (il suppose que python est sur votre PATH).

Le plugin Bexec vim fait exactement ce que vous voulez. Raccourcis clavier inclus.

Il y a une question StackOverflow similaire .

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

C'est ce que j'ai utilisé avec s'il vous plaît (F5 exécute le script actuel).

Pour transformer vim en un puissant IDE python, je recommande ce tutoriel:

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

Placez ce petit extrait dans votre fichier .vimrc pour exécuter le fichier en cours avec une seule touche (comme F5) et afficher le résultat dans un nouveau tampon de volet divisé.

:! est correct mais vous devez basculer sur votre terminal pour voir le résultat.

Bien que vous puissiez le faire avec ctrl-zet ramener vim avec fgcela, cela signifie que vous devez beaucoup changer de contexte.

Le mode de fonctionnement de cet extrait de code consiste tout d'abord à deviner l'exécutable en fonction de filetypepuis à l'exécuter avec le fichier actuel comme argument.

Ensuite, une méthode utilitaire pratique prend la sortie et la sauvegarde dans un nouveau tampon.

Ce n'est pas parfait, mais vraiment rapide pour les flux de travail courants.

Voici l'extrait copié ci-dessous:

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

Je ne connais pas directement Vim, mais vous pouvez généralement partager l'écran de cette manière avec l' screenutilitaire. ctrl+ a, S(notez qu'il s'agit d'un S majuscule) divisera l'affichage et vous pouvez basculer entre les deux avec ctrl+ a, tab(si la fenêtre est vide, utilisez ctrl+ a, npour passer à une autre fenêtre ouverte ou ctrl+ a, cpour en créer une nouvelle) .

Vous pouvez également diviser l'affichage en plus de deux, et modifier la taille des divisions avec ctrl-a,: redimensionner. J'utilise souvent l'écran de cette façon, et bien que ce ne soit pas la solution à clé unique que vous demandez, cela peut être très pratique.