Cómo ejecutar el archivo Estoy editando en Vi (m)

Question

¿Cómo ejecuto el archivo que estoy editando en Vi (m) y obtengo el resultado en la ventana dividida (como en SciTE)?

Por supuesto que podría ejecutar de esa manera:

:!scriptname 

pero ¿es Posible para evitar escribir el nombre del script y cómo llegar a la salida en la ventana dividida en su lugar sólo parte inferior de la pantalla?

Answer 1

Existe el comando make. Ejecuta el comando establecido en la opción makeprg. Use % como marcador de posición para el nombre del archivo actual. Por ejemplo, si estaba editando un script de Python:

:set makeprg=python\ % 

Sí, necesita escapar del espacio. Después de esto simplemente puede ejecutar:

:make 

Si lo desea, puede establecer la opción autowrite y se guardará automáticamente antes de ejecutar el makeprg:

:set autowrite 

Esto resuelve la parte ejecutar. No se conoce ninguna forma de obtener ese resultado en una ventana dividida que no implique una redirección al archivo.

Answer 2

Para acceder al nombre de archivo del búfer en uso, use %. Para convertirlo en una variable, puede usar la función expand(). Para abrir una nueva ventana con un nuevo buffer, use :new o :vnew. Para canalizar la salida de un comando al búfer actual, use :.!. Poniendo todo junto:

:let f=expand("%")|vnew|execute '.!ruby "' . f . '"' 

, obviamente, la sustitución de ruby con el comando que desee. Usé execute para poder rodear el nombre del archivo entre comillas, así que funcionará si el nombre del archivo tiene espacios.

Answer 3

utilizo un mecanismo ligeramente más intrusivo a través de mapas:

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

sólo lo hace por lo que no tiene que guardar, y luego ir. Solo vamos.

Answer 4

Para Shell script que he usado

:set makeprg=% 

:make 

Answer 5

Vim tiene el mando ! ("bang"), que ejecuta comandos shell directamente desde una ventana de VIM. Además, permite lanzar una secuencia de comandos que están conectados con pipe y read stdout.

Por ejemplo:

! node % 

es equivalente a abrir ventana de símbolo del sistema y lanzar comandos:

cd my_current_directory 
node my_current_file 

Ver "Vim tips: Working with external commands" para más detalles.

Answer 6

que tienen un acceso directo para que en mi 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> 

Esto escribe el búfer en uso, hace que el archivo ejecutable actual (sólo UNIX), lo ejecuta (sólo UNIX) y redirige la salida a .tmp .xyz, luego crea una nueva pestaña, lee el archivo y luego lo elimina.

Descomponiéndola:

: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 

Answer 7

Puede utilizar el plugin de vim bexec. Que yo sepa, la última versión es 0.5.

continuación:

$ mkdir -p ~/.vim/plugin 
$ mv bexec-0.5.vba ~/.vim/plugin 
$ vim ~/.vim/plugin/bexec-0.5.vba 

Dentro del mismo vim mientras se edita el archivo .vba hacer:

:so % 

Algunos de salida se mostrará para hacerle saber que bexec.vim se ha escrito, así como documentación, etc.

Ahora, puede probarlo abriendo su (cualquier script de idioma que tenga un intérprete #! funcionando correctamente) en vim y ejecutar

:Bexec 

Nota: quería la división a ser vertical en lugar de horizontal, de modo que hice:

$ 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] 

y cambiado el valor de "hor" a "ver" ..

Sé que es una vieja pregunta, pero espero que esto pueda ayudar a alguien. He estado corriendo en el mismo número, mientras que tomar el curso de Ingeniería de inicio de Coursera donde el profesor Palaji utiliza Emacs y no me gusta Emacs ..

Answer 8

Basado en @SethKriticos y @Cyril respuestas Ahora uso el siguiente:

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> 

Use F9 para configurar la nueva ventana y F2 para ejecutar su secuencia de comandos y tee a su archivo de salida.

También agregué el nombre del script al nombre del archivo de salida, para que pueda usar esto para múltiples scripts al mismo tiempo.

Answer 9

@xorpaul

que estaba buscando este script (python/Windows) desde hace bastante tiempo. Como no hay una "T" en Windows Me cambié a:

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> 

THX

Answer 10

En su .vimrc puede pegar esta función

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 

Después de eso, al mando :shell python ~/p.pyvim plazo, ya ejemplo. Y obtendrá la salida en una ventana dividida. + Después de los cambios en p.py como ejemplo, volverá a ejecutar el mismo comando, esta función no volverá a crear una nueva ventana, sino que mostrará el resultado en la ventana dividida anterior (misma).