Come funziona il trucco vim "write with sudo"?

Molti di voi hanno probabilmente visto il comando che consente di scrivere su un file che necessita dell'autorizzazione di root, anche quando si è dimenticato di aprire vim con sudo:

:w !sudo tee %

Il fatto è che non capisco cosa sta succedendo esattamente qui.

Ho già capito questo: wè per questo

                                                        *:w_c* *:write_c*
:[range]w[rite] [++opt] !{cmd}
                        Execute {cmd} with [range] lines as standard input
                        (note the space in front of the '!').  {cmd} is
                        executed like with ":!{cmd}", any '!' is replaced with
                        the previous command |:!|.

quindi passa tutte le linee come input standard.

La !sudo teeparte chiama teecon privilegi di amministratore.

Perché tutti abbiano un senso, %dovrebbero generare il nome del file (come parametro per tee), ma non riesco a trovare riferimenti sull'aiuto per questo comportamento.

tl; dr Qualcuno potrebbe aiutarmi a dissezionare questo comando?

In :w !sudo tee %...

% significa "il file corrente"

Come ha sottolineato Eugene , %significa davvero "il nome del file corrente", che viene passato in teemodo che sappia quale file sovrascrivere.

(Nei comandi di sostituzione, è leggermente diverso; come :help :%mostra, è equal to 1,$ (the entire file)(grazie a @Orafu per aver sottolineato che questo non valuta il nome del file). Ad esempio, :%s/foo/barsignifica " nel file corrente , sostituire le occorrenze di foocon bar." Se si evidenzia un po 'di testo prima di digitare :s, vedrai che le linee evidenziate prendono il posto di %come intervallo di sostituzione.)

:w non aggiorna il tuo file

Una parte confusa di questo trucco è che potresti pensare di :wmodificare il tuo file, ma non lo è. Se hai aperto e modificato file1.txt, quindi eseguito :w file2.txt, sarebbe un "salva come"; file1.txtnon verrà modificato, ma il contenuto del buffer corrente verrà inviato a file2.txt.

Invece di file2.txt, è possibile sostituire un comando shell per ricevere il contenuto del buffer . Ad esempio, :w !catvisualizzerà solo i contenuti.

Se Vim non è stato eseguito con accesso sudo, :wnon può modificare un file protetto, ma se passa il contenuto del buffer alla shell, un comando nella shell può essere eseguito con sudo . In questo caso, usiamo tee.

Capire tee

Per quanto riguarda tee, immagina il teecomando come un tubo a forma di T in una normale situazione di piping bash: dirige l'output verso i file specificati e lo invia anche all'output standard , che può essere catturato dal comando di piping successivo.

Ad esempio, in ps -ax | tee processes.txt | grep 'foo', l'elenco dei processi verrà scritto in un file di testo e passato a grep.

     +-----------+    tee     +------------+
     |           |  --------  |            |
     | ps -ax    |  --------  | grep 'foo' |
     |           |     ||     |            |
     +-----------+     ||     +------------+
                       ||   
               +---------------+
               |               |
               | processes.txt |
               |               |
               +---------------+

(Diagramma creato con Asciiflow .)

Vedi la teepagina man per maggiori informazioni.

Tee come un trucco

Nella situazione descritta dalla tua domanda, l' utilizzo teeè un hack perché stiamo ignorando la metà di ciò che fa . sudo teescrive nel nostro file e invia anche i contenuti del buffer all'output standard, ma ignoriamo l'output standard . In questo caso non è necessario passare nulla a un altro comando inoltrato; stiamo solo usando teeun modo alternativo di scrivere un file e in modo che possiamo chiamarlo sudo.

Rendere questo trucco facile

Puoi aggiungere questo al tuo .vimrcper rendere questo trucco facile da usare: basta digitare :w!!.

" Allow saving of files as sudo when I forgot to start vim using sudo.
cmap w!! w !sudo tee > /dev/null %

La > /dev/nullparte elimina esplicitamente l'output standard, poiché, come ho detto, non è necessario passare nulla a un altro comando inoltrato.

Nella riga di comando eseguita, %indica il nome del file corrente . Questo è documentato in :help cmdline-special:

In Ex commands, at places where a file name can be used, the following
characters have a special meaning.
        %       Is replaced with the current file name.

Come hai già scoperto, :w !cmdinvia il contenuto del buffer corrente a un altro comando. Ciò che teefa è copiare l'input standard in uno o più file e anche nell'output standard. Pertanto, :w !sudo tee % > /dev/nullscrive efficacemente il contenuto del buffer corrente nel file corrente pur essendo root . Un altro comando che può essere utilizzato per questo è dd:

:w !sudo dd of=% > /dev/null

Come scorciatoia, puoi aggiungere questa mappatura a .vimrc:

" Force saving files that require root permission 
cnoremap w!! w !sudo tee > /dev/null %

Con quanto sopra puoi digitare :w!!<Enter>per salvare il file come root.

Questo funziona anche bene:

:w !sudo sh -c "cat > %"

Questo si ispira al commento di @Nathan Long.

AVVISO :

"deve essere usato anziché 'perché vogliamo %essere espansi prima di passare alla shell.

:w - Scrivi un file.

!sudo - Chiama il comando shell sudo.

tee- L'output del comando write (vim: w) reindirizzato usando tee. % Non è altro che il nome del file corrente, ad esempio /etc/apache2/conf.d/mediawiki.conf. In altre parole, il comando tee viene eseguito come root e accetta input standard e lo scrive in un file rappresentato da%. Tuttavia, questo richiederà di ricaricare nuovamente il file (premi L per caricare le modifiche in vim stesso):

link tutorial

La risposta accettata copre tutto, quindi fornirò solo un altro esempio di una scorciatoia che uso per la cronaca.

Aggiungilo al tuo etc/vim/vimrc(o ~/.vimrc):

• cnoremap w!! execute 'silent! write !sudo tee % >/dev/null' <bar> edit!

Dove:

• cnoremap: dice a Vim che il seguente collegamento deve essere associato nella riga di comando.
• w!!: la scorciatoia stessa.
• execute '...': un comando che esegue la seguente stringa.
• silent!: eseguilo silenziosamente
• write !sudo tee % >/dev/null: la domanda OP, ha aggiunto un reindirizzamento dei messaggi NULLper eseguire un comando pulito
• <bar> edit!: questo trucco è la ciliegina sulla torta: chiama anche il editcomando per ricaricare il buffer e quindi evitare che messaggi come il buffer siano cambiati . <bar>è come scrivere il simbolo della pipe per separare due comandi qui.

Spero che sia d'aiuto. Vedi anche per altri problemi:

• SuperUser: impone a vim di scrivere un file

Vorrei suggerire un altro approccio al problema "Oups che ho dimenticato di scrivere sudodurante l'apertura del mio file" :

Invece di ricevere un permission deniede dover digitare :w!!, trovo più elegante avere un vimcomando condizionale che fa sudo vimse il proprietario del file lo è root.

È altrettanto facile da implementare (potrebbero esserci anche implementazioni più eleganti, chiaramente non sono un guru del bash):

function vim(){
  OWNER=$(stat -c '%U' $1)
  if [[ "$OWNER" == "root" ]]; then
    sudo /usr/bin/vim $*;
  else
    /usr/bin/vim $*;
  fi
}

E funziona davvero bene.

Questo è un bashapproccio più incentrato di vimuno, quindi non a tutti potrebbe piacere.

Ovviamente:

• ci sono casi d'uso in cui fallirà (quando il proprietario del file non lo è rootma richiede sudo, ma la funzione può comunque essere modificata)
• non ha senso quando si utilizza vimper la lettura di un file (per quanto mi riguarda, uso tailo catper file di piccole dimensioni)

Ma trovo che questo porti un'esperienza utente dev molto migliore , che è qualcosa che IMHO tende a essere dimenticato durante l'utilizzo bash. :-)

PER NEOVIM

A causa di problemi con le chiamate interattive ( https://github.com/neovim/neovim/issues/1716 ), lo sto usando per Neovim, sulla base della risposta del dott. Beco:

cnoremap w!! execute 'silent! write !SUDO_ASKPASS=`which ssh-askpass` sudo tee % >/dev/null' <bar> edit!

Questo aprirà una finestra di dialogo usando la ssh-askpassrichiesta della password sudo.