:!<command>se puede usar para ejecutar un comando en el shell. Pero esto "se hace cargo" de mi terminal y lo llena con stdoutese comando en particular.

¿Cómo ejecuto un comando en segundo plano que solo me notifica en un código de salida distinto de cero?

:silent exec "!command"

Tenga en cuenta que su sesión vim seguirá ocupada mientras se ejecuta su comando. Esto se debe a la naturaleza sincrónica de Vim. Todavía puede volver a su shell presionando CTRL + z (para enviar Vim a segundo plano) y luego reanudar vim con el comando fgcomo de costumbre.

Para hacer las cosas de forma asincrónica, eche un vistazo al complemento vim-dispatch de Tim Pope o al proyecto NeoVim, que tiene soporte nativo para la ejecución de comandos asincrónicos, que puede aprovechar fácilmente utilizando el complemento NeoMake. La última versión de Vim también tiene soporte para tareas asincrónicas.

Ver : h: silencioso

Para ejecutar un comando sin activar el mensaje Enter, como:

Presione ENTRAR o escriba comando para continuar

pruebe el siguiente ejemplo simple:

:silent !echo Hello

Luego presione Ctrl+ L(o :redraw!) para actualizar la pantalla cuando regrese a Vim.

Para evitar la necesidad de actualizar, puede definir su propio comando personalizado, como:

:command! -nargs=1 Silent execute ':silent !'.<q-args> | execute ':redraw!'

Ahora, puede usar el nuevo comando Vim para ejecutar un comando de shell (nota: ¡ sin ! Y con S mayúscula ):

:Silent ps

Fuente: Evitar las indicaciones "Hit ENTER para continuar" en el sitio de Vim Wikia

Una solución rápida y sucia (en puro Vimscript)

Esto puede iniciar un proceso en segundo plano:

:!slow_command_here > /tmp/output 2>&1 &

Pero Vim necesita una forma de averiguar cuándo se completó el proceso y cómo, así que usemos un archivo marcador:

:!(rm -f /tmp/finished; slow_command_here > /tmp/output 2>&1; echo "$?" > /tmp/finished) &

Ahora podemos pedirle a Vim que verifique cada cierto tiempo si el proceso se ha completado:

:augroup WaitForCompletion
:autocmd!
:autocmd CursorHold * if filereadable('/tmp/finished') | exec "augroup WaitForCompletion" | exec "au!" | exec "augroup END" | echo "Process completed with exit code ".readfile('/tmp/finished')[0] | end
:augroup END

Oye, no es bonito, ¡pero funciona!

Desventajas

Lamentablemente, el autocmd anterior no se activará hasta que mueva el cursor. Y si desea ejecutar más de un proceso en segundo plano a la vez, necesitará agregar ID únicos a esos archivos y al nombre del grupo autocmd.

Entonces, si puede manejar una dependencia adicional, es mejor que use una solución probada como el complemento vim-dispatch mencionado en otra respuesta.

Mostrar salida

Si desea ver el resultado del proceso, en lugar de solo el código de salida , reemplace el final echoanterior con:

silent botright pedit /tmp/output

Eso abriría la ventana de vista previa. Para utilizar la lista de errores de corrección rápida en su lugar:

silent cget /tmp/output | copen

La lista de soluciones rápidas le permite navegar fácilmente a los errores usando :cnext. Sin embargo, copenmueve el cursor a la ventana de corrección rápida cuando se abre, lo que probablemente será sorprendente / molesto.

(Una solución alternativa para eso sería abrir la ventana QF :copenal iniciar el proceso inicialmente, por lo que no necesitará llamarlo al final).

Ejecutar un comando en segundo plano

Estaba ejecutando un comando que bloqueó por un momento, y realmente no me importaba la salida. Esto se puede solucionar iniciando el proceso adjunto no al terminal / emulador sino al sistema y redirigiendo toda la salida a / dev / null. Por ejemplo:

:silent exec "!(espeak 'speaking in background'&) > /dev/null"

luego lo (...&)ejecuta en segundo plano y > /dev/nullredirige toda la salida a /dev/null(nada).

El paréntesis atrapa la salida en un subshell (o algo así), pero tiene el efecto secundario de no estar conectado al shell actual (no es gran cosa).

Ejecutar un comando silenciosamente en segundo plano con mapeo

Me he dado cuenta de que si está , de hecho, la cartografía de ella, puede hacer algo como

nnoremap <silent> <leader>e :!$(espeak 'speaking in the background'&) > /dev/null

Lo anterior no mostrará nada en la barra de comandos y, además, no mostrará nada en el terminal fuera de vim. Se asignará a <leader> e, que es \ epor defecto.

Ejecutando un comando, capturando su salida, mostrando su contenido

(Otra edición, y tal vez la más bonita). Este mostrará el resultado de un comando si así lo elige:

DENTRO DE UNA NUEVA PESTAÑA:

silent exec "!(echo 'hello. I'm a process! :)') > /tmp/vim_process" | :tabedit /tmp/vim_process

DENTRO DE UN SPLIT VERTICAL:

silent exec "!(echo 'hello. I'm a process :)') > /tmp/vim_process" | :vs /tmp/vim_process

DENTRO DE UN SPLIT HORIZONTAL:

silent exec "!(echo 'hello. I'm a process :)') > /tmp/vim_process" | :sp /tmp/vim_process

... Haz lo que quieras

Si no le importa el código de salida, puede ir con esto:

:call system('/usr/bin/zathura using-docker.pdf &')

No estoy seguro de si esto se adapta a sus necesidades (no maneja los procesos en segundo plano como en foo & - no estoy seguro si eso es lo que quiere decir con “en segundo plano” ), pero se podría usar un comando personalizado como en:

fun! s:PraeceptumTacet(cmd)
    silent let f = systemlist(a:cmd)
    if v:shell_error
        echohl Error
        echom "ERROR #" . v:shell_error
        echohl WarningMsg
        for e in f
            echom e
        endfor
        echohl None
    endif
endfun

command! -nargs=+ PT call s:PraeceptumTacet(<q-args>)

Luego use como por ejemplo:

:PT ls -l
:PT foobar
ERROR #127
/bin/bash: foobar: command not found

Si no necesita / desea el mensaje de error, un simple system()podría ser suficiente, entonces verifique v:shell_errore informe por ej echo Error!.

De la ayuda v: shell_error :

                                        v:shell_error shell_error-variable
v:shell_error   Result of the last shell command.  When non-zero, the last
                shell command had an error.  When zero, there was no problem.
                This only works when the shell returns the error code to Vim.
                The value -1 is often used when the command could not be
                executed.  Read-only.
                Example: >
    :!mv foo bar
    :if v:shell_error
    :  echo 'could not rename "foo" to "bar"!'
    :endif
                "shell_error" also works, for backwards compatibility.

Vim 8 introdujo el soporte de trabajos. Uno puede ejecutar comandos externos en segundo plano sin depender de complementos. Por ejemplo, para ejecutar un servidor de rebajas ( markserv ) en la ubicación actual y no bloquear la sesión vim:

:call job_start('markserv .')

Esto inicia el proceso markserv como un subproceso del proceso vim actual. Puedes verificar esto con pstree.

Ver inicio de trabajo

Yo uso el siguiente código:

command! -nargs=1 Silent call SilentExec(<q-args>)

function! SilentExec(cmd)
  let cmd = substitute(a:cmd, '^!', '', '')
  let cmd = substitute(cmd, '%', shellescape(expand('%')), '')
  call system(cmd)
endfunction

Ahora puede escribir lo siguiente

:Silent !your_command

Esto se parece casi al silent !comando incorporado de Vim , a excepción de la capital S. Incluso permite un opcional !para que se vea aún más similar. La llamada a system()hace que el comando de shell sea realmente silencioso: no parpadea la pantalla ni se vuelven a dibujar.

(y si alguna vez necesita un código de estado, puede verificar la v:shell_errorvariable, consulte la ayuda para obtener más información)

El complemento AsyncRun, si está diseñado para esto, le permite ejecutar comandos de shell en segundo plano en Vim8 / NeoVim y mostrar la salida en la ventana de revisión rápida.

Solo como reemplazo del !comando:

:AsyncRun ls -la /

También puede ocultar completamente la salida en la ventana de revisión rápida:

:AsyncRun -mode=3 ls -la /

Cuando finalice el trabajo, AsyncRun le notificará pasando una opción -post:

:AsyncRun -post=some_vim_script   ls -la /

El script vim definido por -postse ejecutará una vez que finalice el trabajo.