Comment exécuter le fichier que je modifie dans Vi (m)
Comment exécuter le fichier que je modifie dans Vi (m) et obtenir la sortie dans une fenêtre partagée (comme dans SciTE)?
Bien sûr, je pourrais l'exécuter comme ça:
:!scriptname
Mais est-il possible d'éviter d'écrire le nom du script et comment obtenir la sortie dans une fenêtre divisée au lieu juste en bas de l'écran?
Il existe la commande make. Il exécute la commande définie dans l'option makeprg. Utilisation % comme espace réservé pour le nom de fichier actuel. Par exemple, si vous modifiez un script python:
:set makeprg=python\ %
Oui, vous devez vous échapper. Après cela, vous pouvez simplement exécuter:
:make
Si vous le souhaitez, vous pouvez définir l'option autowrite et elle sera enregistrée automatiquement avant d'exécuter makeprg:
:set autowrite
Cela résout la partie d'exécution. Je ne connais aucun moyen d'obtenir cette sortie dans une fenêtre fractionnée qui n'implique pas de redirection vers le fichier.
Pour accéder au nom de fichier du tampon actuel, utilisez %. Pour l'intégrer dans une variable, vous pouvez utiliser la fonction expand(). Pour ouvrir une nouvelle fenêtre avec un nouveau tampon, utilisez :new Ou :vnew. Pour diriger la sortie d'une commande dans le tampon actuel, utilisez :.!. Mettre tous ensemble:
:let f=expand("%")|vnew|execute '.!Ruby "' . f . '"'
évidemment en remplaçant Ruby par la commande que vous voulez. J'ai utilisé execute pour pouvoir entourer le nom de fichier de guillemets, donc cela fonctionnera si le nom de fichier contient des espaces.
Vim a ! ("bang") qui exécute la commande Shell directement depuis la fenêtre VIM. De plus, elle permet de lancer une séquence de commandes connectées à pipe et de lire stdout.
Par exemple:
! node %
équivaut à ouvrir la fenêtre d'invite de commandes et à lancer des commandes:
cd my_current_directory
node my_current_file
Voir "Astuces Vim: Travailler avec des commandes externes" pour plus de détails.
J'ai un raccourci pour cela dans mon 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>
Cela écrit le tampon actuel, rend le fichier actuel exécutable (Unix uniquement), l'exécute (Unix uniquement) et redirige la sortie vers .tmp.xyz, puis crée un nouvel onglet, lit le fichier puis le supprime.
Décomposer:
: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
Pour le script Shell que j'ai utilisé
:set makeprg=%
:make
Vim 8 dispose d'un terminal interactif intégré. Pour exécuter le script bash actuel dans un volet divisé:
:terminal bash %
ou pour faire court
:ter bash %
% se développe jusqu'au nom de fichier actuel.
De :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.
Vous pouvez utiliser le plugin de vim bexec . À ma connaissance, la dernière version est la 0.5.
Ensuite:
$ mkdir -p ~/.vim/plugin
$ mv bexec-0.5.vba ~/.vim/plugin
$ vim ~/.vim/plugin/bexec-0.5.vba
Dans vim lui-même lors de l'édition du fichier .vba, procédez comme suit:
:so %
Certaines sorties s'afficheront pour vous faire savoir que bexec.vim a été écrit ainsi que de la documentation, etc.
Maintenant, vous pouvez le tester en ouvrant votre (quel que soit le script de langue qui a un interpréteur #! Fonctionne correctement) dans vim et exécutez
:Bexec
Remarque: je voulais que le fractionnement soit vertical plutôt qu'horizontal, alors j'ai fait:
$ 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]
et changé la valeur de "hor" en "ver" ..
Je sais que c'est une vieille question, mais j'espère que cela peut aider quelqu'un là-bas. J'ai couru dans le même problème tout en suivant le cours d'ingénierie de démarrage de Coursera où le professeur Palaji utilise Emacs et je n'aime pas Emacs ..
J'utilise un mécanisme légèrement plus intrusif via les cartes:
map ;e :w<CR>:exe ":!python " . getreg("%") . "" <CR>
Fait juste en sorte que je n'ai pas à enregistrer, puis allez-y. Juste aller.
@xorpaul
Je cherchais ce script (python/Windows) depuis un certain temps. Comme il n'y a pas de "tee" dans Windows, je l'ai changé en:
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>
Sur la base des réponses @SethKriticos et @Cyril, j'utilise maintenant les éléments suivants:
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>
Utilisez F9 pour configurer la nouvelle fenêtre et F2 pour exécuter votre script et té vers votre fichier de sortie.
J'ai également ajouté le nom du script au nom du fichier de sortie, afin que vous puissiez l'utiliser pour plusieurs scripts en même temps.
Dans votre .vimrc vous pouvez coller cette fonction
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
Après cela, dans vim exécutez la commande :Shell python ~/p.py comme exemple. Et vous obtiendrez la sortie dans une fenêtre divisée. + Après des changements dans p.py comme exemple, vous exécuterez à nouveau la même commande, cette fonction ne créera pas de nouvelle fenêtre, elle affichera le résultat dans la précédente (même) fenêtre fractionnée.