O GNU encontra e mascara o {} para algumas conchas - quais?

A página de manual do GNU encontra estados:

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

Isso é do homem para find(GNU findutils) 4.4.2.

Agora eu testei isso com bash e dash, e ambos não precisam ter o {}mascaramento. Aqui está um teste simples:

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

Existe uma concha, para a qual eu realmente preciso mascarar o aparelho? Observe que isso não depende se o arquivo encontrado contém um espaço em branco (chamado a partir do bash):

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

Isso muda se o arquivo encontrado for passado para um 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

que pode ser resolvido por:

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

em contraste com:

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

mas não é disso que a página de manual está falando, é? Então, qual shell trata {}de uma maneira diferente?

Resumo : se já houve um shell que se expandiu {}, é realmente um legado antigo até agora.

No shell Bourne e em shells compatíveis com POSIX, chaves ( {e }) são caracteres comuns (diferentes (e )que são delimitadores de palavras como ;e &, [e ]quais são caracteres brilhantes). As seguintes seqüências de caracteres devem ser impressas literalmente:

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

Uma palavra que consiste em uma única chave é uma palavra reservada , que só é especial se for a primeira palavra de um comando.

O Ksh implementa a expansão de chaves como uma extensão incompatível para o shell Bourne. Isso pode ser desativado com set +B. O Bash emula o ksh a esse respeito. O Zsh também implementa expansão de chaves; lá pode ser desligado com set +Iou setopt ignore_bracesou emulate sh. Nenhum desses shells se expande {}em nenhum caso, mesmo quando é uma substring de uma palavra (por exemplo foo{}bar), devido ao uso comum nos argumentos para finde xargs.

O Unix v2 único observa que

Em alguns sistemas históricos, as chaves são tratadas como operadores de controle. Para ajudar em futuras atividades de padronização, os aplicativos portáteis devem evitar o uso de chaves sem aspas para representar os próprios caracteres. É possível que uma versão futura da norma ISO / IEC 9945-2: 1993 possa exigir isso {e }ser tratada individualmente como operadores de controle, embora o token {}provavelmente seja uma isenção de caso especial disso por causa da find {}construção frequentemente usada .

Esta nota foi descartada nas versões subsequentes do padrão; os exemplos parafind ter usos sem aspas de {}, assim como os exemplos paraxargs . Pode ter havido {}citações históricas de Bourne onde precisavam ser citadas, mas agora seriam sistemas legados realmente antigos.

As implementações do csh que tenho em mãos (OpenBSD 4.7, BSD csh no Debian , tcsh) se expandem {foo}para fooapenas deixar em {}paz.

O {}necessário para ser citado nas versões do fishshell anteriores à 3.0.0.

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

E no shell rc (também akangabaseado em rc, mas não es):

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

Provavelmente, essas não são as conchas que os autores desse GNU acham que a documentação tinha em mente quando escreveram esse texto desde que fishfoi lançado pela primeira vez em 2005 (enquanto esse texto ou similar já existia em 1994) e rcnão era originalmente um shell Unix.

Existem alguns rumores de que algumas versões csh(o shell que introduziu a expansão de chaves) exigiam isso. Mas é difícil dar crédito àqueles desde o primeiro lançamento do csh2BSD não. Aqui, como testado em um emulador PDP11:

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

E a página de manual do 2BSD cshafirma claramente :

Como um caso especial, `{',`}' e `{} 'são passados ​​imperturbáveis.

Então, eu acharia muito estranho se uma versão subseqüente do csh ou do tcsh quebrasse isso posteriormente.

Poderia ter sido contornar alguns erros em algumas versões. Ainda com esse csh 2BSD (isso é o mesmo em 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

A citação não ajuda, porém:

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

Você pode citar toda a substituição do comando:

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

Mas isso está passando um argumento para esse eco externo.

Em cshou tcsh, você precisa citar o {}quando não está sozinho, como em:

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

(embora esse tipo de finduso não seja portátil, pois alguns finds se expandem apenas {}por conta própria).

Em uma palavra csh. bashe outros shells modernos reconhecem que o usuário provavelmente não está solicitando uma expansão de chave nula. (Moderno cshé realmente tcshe também pode lidar com {}sanidade a essa altura.)