如何将UNIX命名管道(FIFO)内容异步读入Vim/Neovim缓冲区？

Great question—your FIFO-based server-client setup is a clean, pipeline-first approach, and we can build an elegant solution that works smoothly across both Vim and Neovim. Let’s break down the options and the optimal implementation:

Why Vimscript (Not Command-Line Mode) #

Command-line mode commands like !cat PIPE_OUT >> % are blocking, one-shot operations—they can’t handle continuous, real-time updates to your buffer without freezing the editor. Vimscript, on the other hand, lets you leverage job control APIs (supported by both editors with minor compatibility tweaks) to manage persistent, non-blocking reads from your FIFO. This is the only way to get seamless, asynchronous updates while keeping your editor responsive.

Step-by-Step Vimscript Implementation #

This solution will:

• Asynchronously stream PIPE_OUT content to a buffer in real time
• Use Vim’s :w command to write buffer content to PIPE_IN
• Work natively with both Vim and Neovim

1. Define FIFO Paths & Compatibility Helpers #

First, set your FIFO paths and create a wrapper to handle job API differences between the two editors:

" Configure your FIFO paths here
let g:pipe_out_path = '/path/to/your/PIPE_OUT'
let g:pipe_in_path = '/path/to/your/PIPE_IN'

" Compatibility layer for job control (works in Vim and Neovim)
function! s:job_start(cmd, opts) abort
    if exists('*jobstart') " Neovim
        return jobstart(a:cmd, a:opts)
    else " Vim
        return job_start(a:cmd, a:opts)
    endif
endfunction

function! s:job_stop(job_id) abort
    if exists('*jobstop') " Neovim
        call jobstop(a:job_id)
    else " Vim
        call job_stop(a:job_id)
    endif
endfunction

2. Async Read from PIPE_OUT to Buffer #

We’ll use tail -f instead of cat because it’s optimized for continuous FIFO monitoring. Create a callback to handle new output, then start a persistent job:

" Callback to append new FIFO content to the buffer
function! s:on_pipe_output(job_id, data, event) abort
    " Filter empty lines and format content
    let l:new_content = join(filter(a:data, 'v:val != ""'), "\n")
    if !empty(l:new_content)
        " Append to the end of the current buffer (or target a specific buffer)
        call append('$', split(l:new_content, "\n"))
        " Auto-scroll to the bottom to show new content
        normal! G
    endif
endfunction

" Start the async FIFO reader job
function! s:start_pipe_reader() abort
    " Avoid duplicate jobs
    if exists('g:pipe_reader_job') && g:pipe_reader_job != 0
        echo "Pipe reader job is already running!"
        return
    endif
    let g:pipe_reader_job = s:job_start(
        \ ['tail', '-f', g:pipe_out_path],
        \ {'on_stdout': function('s:on_pipe_output'), 'stderr_buffered': 1}
    )
    echo "Started async pipe reader for " . g:pipe_out_path
endfunction

" Stop the reader job automatically when exiting Vim
autocmd VimLeavePre * call s:stop_pipe_reader()

function! s:stop_pipe_reader() abort
    if exists('g:pipe_reader_job') && g:pipe_reader_job != 0
        call s:job_stop(g:pipe_reader_job)
        unlet g:pipe_reader_job
        echo "Stopped pipe reader job"
    endif
endfunction

3. Write to PIPE_IN on :w #

Refine your existing write functionality to send the full buffer content to PIPE_IN on save:

" Auto-write buffer content to PIPE_IN when you save
autocmd BufWritePost * call s:write_to_pipe_in()

function! s:write_to_pipe_in() abort
    " Get all lines from the current buffer
    let l:buffer_content = join(getline(1, '$'), "\n")
    " Write to PIPE_IN (use 'a' for append, '' to overwrite)
    call writefile([l:buffer_content], g:pipe_in_path, '')
    echo "Wrote buffer content to " . g:pipe_in_path
endfunction

4. Use the Setup #

• Run :call s:start_pipe_reader() to begin streaming PIPE_OUT to your buffer
• Edit your buffer and save with :w to send content to PIPE_IN

More Elegant Advanced Options #

If you want to polish this further:

• Target a dedicated buffer: Modify s:on_pipe_output to append to a named buffer (e.g., bufnr('pipe_output', 1) to create it if it doesn’t exist) instead of the current one, keeping your work buffer separate from stream output.
• Wrap into a plugin: Turn this logic into a lightweight plugin with commands like :PipeStart and :PipeStop, and add configurable FIFO paths via g:pipe_server_out/g:pipe_server_in.
• Add FIFO initialization: Add a check to create FIFO files if they don’t exist (e.g., call system('mkfifo ' . g:pipe_out_path) wrapped in a guard clause to avoid errors).
• Limit buffer size: For high-volume streams, add logic to trim old lines when the buffer exceeds a set length (e.g., call deletebufline('%', 1, line('$') - 1000) to keep the last 1000 lines).

Key Notes #

• Ensure your FIFO files have proper permissions (e.g., chmod 666 PIPE_OUT PIPE_IN) so Vim/Neovim can read/write to them.
• If you’re working with binary data, adjust the callback to handle raw bytes instead of line-based content.

内容的提问来源于stack exchange，提问作者Soulthym