GNU trova e maschera il {} per alcune shell - quale?

La pagina man per GNU find afferma:

-exec command ;
    [...] The  string `{}'  is  replaced  by the current 
    file name being processed everywhere it occurs in the 
    arguments to the command, not just in arguments where 
    it is alone, as in some  versions  of  find.
    Both  of  these  constructions might need to be escaped 
    (with a `\') or quoted to protect them from expansion 
    by the shell. 

Questo è dall'uomo a find(GNU findutils) 4.4.2.

Ora ho provato questo con bash e dash, ed entrambi non hanno bisogno di {}essere mascherati. Ecco un semplice test:

find /etc -name "hosts" -exec md5sum {} \; 

Esiste un guscio, per il quale ho davvero bisogno di mascherare le parentesi graffe? Nota che non dipende dal fatto che il file trovato contenga uno spazio vuoto (invocato da bash):

find ~ -maxdepth 1 -type d -name "U*" -exec ls -d {} \; 
/home/stefan/Ubuntu One

Questo cambia se il file trovato viene passato a una subshell:

find ~ -maxdepth 3 -type d -name "U*" -exec bash -c 'ls -d {}' \; 
ls: cannot access /home/stefan/Ubuntu: No such file or directory
ls: cannot access One: No such file or directory

che può essere risolto da:

find ~ -maxdepth 3 -type d -name "U*" -exec bash -c 'ls -d "$0"' {} \;

in contrasto con:

find ~ -maxdepth 3 -type d -name "U*" -exec bash -c 'ls -d "{}"' \; 
/home/stefan/Ubuntu One

ma non è di questo che parla la pagina man, vero? Quindi quale shell tratta {}in modo diverso?

Riepilogo : se c'è mai stata una shell che si è espansa {}, è ormai roba legacy davvero vecchia.

Nella shell Bourne e conchiglie POSIX-compliant, bretelle ( {e }) sono caratteri ordinari (differenza (e )che sono delimitatori di parola come ;e &, e [e ]che sono globbing caratteri). Le seguenti stringhe dovrebbero essere stampate letteralmente:

$ echo { } {} {foo,bar} {1..3}
{ } {} {foo,bar} {1..3}

Una parola composta da una singola parentesi graffa è una parola riservata , che è speciale solo se è la prima parola di un comando.

Ksh implementa l'espansione del controvento come estensione incompatibile della shell Bourne. Questo può essere disattivato con set +B. Bash emula ksh in questo senso. Zsh implementa anche l'espansione del controvento; lì può essere spento con set +Io setopt ignore_braceso emulate sh. Nessuna di queste shell si espande {}in ogni caso, anche quando si tratta di una sottostringa di una parola (ad esempio foo{}bar), a causa dell'uso comune negli argomenti di finde xargs.

Unico Unix v2 lo nota

In alcuni sistemi storici, le parentesi graffe sono trattate come operatori di controllo. Per aiutare nelle future attività di standardizzazione, le applicazioni portatili dovrebbero evitare di usare parentesi graffe non quotate per rappresentare i personaggi stessi. È possibile che una futura versione della norma ISO / IEC 9945-2: 1993 possa richiederlo {ed }essere trattata individualmente come operatori di controllo, sebbene il token {}sarà probabilmente un'esenzione da questo caso speciale a causa del find {}costrutto spesso usato .

Questa nota è stata eliminata nelle versioni successive dello standard; gli esempi perfind hanno usi non quotati di {}, così come gli esempi perxargs . Potrebbero esserci stati gusci di Bourne storici nei quali {}dovevano essere citati, ma ormai sarebbero stati sistemi legacy molto vecchi.

Le implementazioni CSH che ho a portata di mano (OpenBSD 4.7, BSD csh su Debian , tcsh) tutto si espandono {foo}a fooma lasciare {}da solo.

È {}necessario che sia citato nelle versioni della fishshell precedenti alla 3.0.0.

$ fish -c 'echo find -exec {} \;'
find -exec  ;

E nella shell rc (anche akangabasata su rc, ma non es):

$ rc -c "echo find -exec {} ';'"
line 1: syntax error near '{'

Probabilmente non sono queste le shell che gli autori di quella GNU hanno scoperto nella documentazione quando hanno scritto quel testo da quando è fishstato rilasciato per la prima volta nel 2005 (mentre quel testo o simile era già lì nel 1994) e rcnon era originariamente una shell Unix.

Ci sono alcune voci su alcune versioni di csh(la shell che ha introdotto l'espansione del supporto) che lo richiedono. Ma è difficile dare credito a quelli dal momento che la prima versione di csh2BSD non lo ha fatto. Ecco come testato in un emulatore PDP11:

# echo find -exec {} \;
find -exec {} ;

E la pagina man di 2BSD cshafferma chiaramente :

Come caso speciale `{',`}' e `{} 'vengono passati indisturbati.

Quindi troverei molto strano se una versione successiva di csh o tcsh in seguito lo avesse rotto.

Potrebbe essere stato per aggirare alcuni bug in alcune versioni. Sempre con quel 2BSD csh (è lo stesso in 2.79BSD, 2.8BSD, 2.11BSD):

# csh -x
# echo foo {} bar
echo foo {} bar
foo {} bar
# echo `echo foo {} bar`
echo `echo foo {} bar`
echo foo {} bar
foo  bar

La citazione non aiuta però:

# echo `echo foo '{}' bar`
echo `echo foo '{}' bar`
echo foo {} bar
foo  bar

Potresti citare l'intera sostituzione del comando:

# echo "`echo foo {} bar`"
echo `echo foo {} bar`
echo foo {} bar
foo {} bar

Ma questo sta trasmettendo un argomento a quell'eco esterna.

In csho tcsh, dovresti citare il {}quando non da solo come in:

find . -name '*.txt' -type f -exec cp {} '{}.back' \;

(anche se quel tipo di findutilizzo non è portatile in quanto alcuni findsi espandono solo {}da soli).

In una parola, csh. bashe altre shell moderne riconoscono che l'utente probabilmente non sta chiedendo un'espansione di parentesi graffa nulla. (Il moderno cshè in realtà tcshe potrebbe anche gestire in modo {}sano ormai.)