:!<command>dapat digunakan untuk menjalankan perintah di shell. Tapi ini "mengambil alih" terminal saya dan mengisinya dengan stdoutperintah khusus itu.

Bagaimana cara menjalankan perintah di latar belakang yang hanya memberi tahu saya tentang kode keluar yang tidak nol?

:silent exec "!command"

Perhatikan bahwa sesi vim Anda masih akan ditempati saat perintah Anda dijalankan. Ini karena sifat sinkron Vim. Anda masih dapat kembali ke shell Anda dengan menekan CTRL + z (untuk mengirim Vim ke latar belakang) dan kemudian melanjutkan vim dengan perintah fgseperti biasa.

Untuk melakukan berbagai hal secara tidak sinkron, lihatlah plugin vim-dispatch Tim Pope atau proyek NeoVim yang memiliki dukungan asli untuk eksekusi perintah asinkron, yang dapat Anda manfaatkan dengan mudah menggunakan plugin NeoMake. Versi terbaru Vim juga memiliki dukungan untuk tugas yang tidak sinkron.

Lihat : h: diam

Untuk menjalankan perintah tanpa memicu pesan Enter, seperti:

Tekan ENTER atau ketik perintah untuk melanjutkan

coba contoh sederhana berikut ini:

:silent !echo Hello

Kemudian tekan Ctrl+ L(atau :redraw!) untuk menyegarkan layar saat kembali ke Vim.

Untuk menghindari perlunya penyegaran, Anda dapat menentukan perintah khusus Anda sendiri, seperti:

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

Sekarang, Anda dapat menggunakan perintah Vim baru untuk menjalankan perintah shell (catatan: tanpa ! Dan dengan huruf kapital S ):

:Silent ps

Sumber: Menghindari permintaan "Hit ENTER to continue" di situs Vim Wikia

Solusi cepat dan kotor (dalam Vimscript murni)

Ini dapat memulai proses di latar belakang:

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

Tetapi Vim membutuhkan cara untuk mengetahui kapan prosesnya telah selesai, dan bagaimana, jadi mari kita gunakan file marker:

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

Sekarang kita dapat meminta Vim untuk memeriksa sesering mungkin apakah proses telah selesai:

: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

Hei itu tidak cantik, tapi itu semacam bekerja!

Kekurangan

Sayangnya autocmd di atas tidak akan memicu sampai Anda memindahkan kursor. Dan jika Anda ingin menjalankan lebih dari satu proses latar belakang sekaligus, Anda perlu menambahkan ID unik ke file-file itu, dan ke nama grup autocmd.

Jadi, jika Anda dapat menangani ketergantungan ekstra, Anda mungkin lebih baik menggunakan solusi yang telah dicoba dan diuji seperti plugin vim-dispatch yang disebutkan dalam jawaban lain.

Menampilkan output

Jika Anda ingin melihat output dari proses, bukan hanya kode keluar , ganti final di echoatas dengan:

silent botright pedit /tmp/output

Itu akan membuka jendela pratinjau. Untuk menggunakan daftar kesalahan perbaikan cepat sebagai gantinya:

silent cget /tmp/output | copen

Daftar perbaikan cepat memungkinkan Anda dengan mudah menavigasi ke kesalahan menggunakan :cnext. Namun copenmemindahkan kursor Anda ke jendela perbaikan cepat ketika terbuka, yang mungkin akan mengejutkan / mengganggu.

(Solusi untuk itu adalah dengan membuka jendela QF dengan :copenketika awalnya memulai proses, jadi Anda tidak perlu menyebutnya di akhir.)

Menjalankan perintah di latar belakang

Saya menjalankan perintah yang sedikit diblokir, dan saya tidak terlalu peduli dengan hasilnya. Ini dapat diatasi dengan memulai proses yang dilampirkan bukan ke terminal / emulator melainkan ke sistem dan mengarahkan semua output ke / dev / null. Sebagai contoh:

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

yang (...&)berjalan di latar belakang dan > /dev/nullpengalihan semua output ke /dev/null(tidak).

Tanda kurung menjebak output ke dalam subkulit (atau sesuatu seperti itu), tetapi memiliki efek samping karena tidak melekat pada shell saat ini (bukan masalah besar).

Menjalankan perintah secara diam-diam di latar belakang dengan pemetaan

Aku baru sadar bahwa jika Anda berada , pada kenyataannya, pemetaan itu, Anda dapat melakukan sesuatu seperti

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

Di atas tidak akan menampilkan apa pun di bilah perintah dan juga tidak akan menampilkan apa pun di terminal di luar vim. Ini akan dipetakan ke <leader> e, yang secara \ edefault.

Menjalankan perintah, menangkap outputnya, menampilkan isinya

(Suntingan lain - dan mungkin yang paling rapi). Satu ini akan menampilkan yang keluaran dari perintah jika Anda memilih demikian:

DALAM TAB BARU:

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

DI DALAM LAMARAN VERTIKAL:

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

DI DALAM KECEPATAN HORIZONTAL:

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

... melakukan apapun yang Anda inginkan

Jika Anda tidak peduli dengan kode keluar, Anda bisa menggunakan ini:

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

Tidak yakin apakah ini sesuai dengan kebutuhan Anda, (tidak menangani proses latar belakang seperti dalam foo & - tidak yakin apakah itu yang Anda maksud dengan "di latar belakang" ), tetapi perintah khusus dapat digunakan seperti pada:

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

Kemudian gunakan sebagai contoh:

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

Jika Anda tidak perlu / ingin pesan kesalahan yang cukup sederhana system(), maka periksa v:shell_errordan laporkan dengan misalnya echo Error!.

Dari bantuan 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 memperkenalkan dukungan pekerjaan. Seseorang dapat menjalankan perintah eksternal di latar belakang tanpa bergantung pada plugin. Misalnya, untuk menjalankan server markdown ( markserv ) di lokasi saat ini dan tidak memblokir sesi vim:

:call job_start('markserv .')

Ini memulai proses markserv sebagai sub-proses dari proses vim saat ini. Anda dapat memverifikasi ini dengan pstree.

Lihat job_start

Saya menggunakan kode berikut:

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

Sekarang Anda bisa mengetik yang berikut ini

:Silent !your_command

Ini hampir seperti silent !perintah bawaan Vim , kecuali untuk ibukota S. Bahkan memungkinkan untuk opsional !untuk membuatnya terlihat lebih mirip. Panggilan untuk system()membuat perintah shell benar-benar diam: tidak ada layar berkedip dan tidak ada gambar ulang.

(dan jika Anda memerlukan kode status, Anda dapat memeriksa v:shell_errorvariabel, lihat bantuan untuk info lebih lanjut)

The AsyncRun Plugin jika dirancang untuk ini, memungkinkan Anda untuk menjalankan perintah shell di latar belakang di Vim8 / NeoVim dan menampilkan output di jendela quickfix.

Sama seperti penggantian !perintah:

:AsyncRun ls -la /

Anda juga dapat menyembunyikan output di jendela perbaikan cepat sepenuhnya:

:AsyncRun -mode=3 ls -la /

Saat pekerjaan selesai, AsyncRun akan memberi tahu Anda dengan memberikan opsi -post:

:AsyncRun -post=some_vim_script   ls -la /

Script vim yang ditentukan oleh -postakan dieksekusi setelah pekerjaan selesai.