Exclua todo o conteúdo dos diretórios com o nome dado deixando o diretório intacto

Observe que o segundo link ("sobre parar pesquisas no primeiro positivo em uma árvore de caminho") não é realmente relevante porque uma solução que o ignora pode esvaziar ./path/to/foo/again/fooe depois esvaziar ./path/to/foo; ou pode esvaziar ./path/to/fooprimeiro e não chegar ./path/to/foo/again/foo(porque esse caminho não existe agora). Em qualquer caso, o objetivo será alcançado.

Qualquer coisa abaixo de (algumas) foocorrespondências -path '*/foo/*', mas o ./path/to/foopróprio não corresponde. findnão adiciona barras finais aos caminhos que cria e examina. Uma exceção seria algo como find /path/to/foo/ …where /path/to/foo/será processado com uma barra final e corresponderá-path '*/foo/*' . Você pode considerar -path '*/foo/?*', mas se você começar com /path/to/foo//( que é um nome de caminho válido ), ele corresponderá.

Então talvez -path e -name ?

find . -path '*/foo/*' ! -name foo

Ele lhe dará uma boa lista de nomes de caminho para excluir? A nota ./path/to/foo/again/foonão estará nele. A lista conterá ./path/to/foo/again, portanto, se você excluir againcorretamente, ./path/to/foo/again/fooserá excluído de qualquer maneira. Nada mal, até você perceber que não haverá entrada na lista que permita excluir ./path/to/foo/foo/foo(se esse caminho existir).

Outro problema -path '*/foo/*'é quando você fornece um ponto de partida na forma de /a/foo/starting/point. Nesse caso, cada caminho considerado por findcorresponderá. Com efeito, você pode inadvertidamente remover o todo point, enquanto sua intenção era esvaziar /a/foo/starting/point/whatever/foo/.

Se você puder cdaté o ponto de partida, isso deve ser seguro:

cd /whatever/the/starting/point
# check if cd succeeded (the check can be automated with cd … && find … )
find . -path '*/foo/?*' -delete

( ?provavelmente não é necessário porque a especificação declara explicitamente que não deve haver uma barra final na parte do nome do caminho em relação ao que fornecemos como o caminho inicial; mas não sei se todas as implementações de findum selvagem obedecem estritamente; então ?é apenas no caso).

Mesmo que fooapareça no caminho para o starting/point, isso não importa. Em findquais -pathtestes o nome do caminho é construído pela ferramenta, não o nome do caminho absoluto real. Quando o find começa a partir de .então, todos os nomes de caminho que ele cria começarão .e -pathos testarão como strings.

Nota -deletenão é portátil . Uma solução portátil pode ser uma destas:

find . -depth -path '*/foo/?*' -exec rm -r {}  +
find .        -path '*/foo/?*' -exec rm -r {} \;

O primeiro funciona como -delete(o que implica -depth): ele processa um diretório somente após todo o seu conteúdo ter sido processado. rmobterá os nomes de caminho um por um na ordem correta e não precisará realmente trabalhar recursivamente porque qualquer diretório que tentar remover já deve estar vazio (ainda -ré necessário para que ele possa remover diretórios). Vários nomes de caminho serão fornecidos a um único rmgraças a +, ainda assim provavelmente haverá mais de um rmporque você não pode executar rmcom muitos argumentos arbitrários . find -exec … +sabe disso e pode executar quantos comandos ( rmprocessos no nosso caso) precisar processar arbitrariamente muitas entradas e não atingir o limite (para comparação: xargstambém sabe disso).

Em muitos casos, a solução portátil mais ideal seria executar um ou poucos rm -rprocessos que removem não-diretórios e diretórios diretamente em ./path/to/foo/, portanto find, nem precisa ir mais fundo. Isso é o que o segundo comando faz. Observe que existe ;(escapado do shell) em vez de +. Não queremos +porque pode acontecer finddecidir que o conteúdo de ./path/to/foo/não é suficiente para rodar rmcom muitos argumentos ainda, vai mais fundo para adicionar mais argumentos, encontra o conteúdo de ./path/to/foo/again/foo/, só então inicia rm. Então rm -robtém ./path/to/foo/againe (possivelmente entre outros) ./path/to/foo/again/foo/whatever, remove o primeiro (recursivamente), então reclama que o último não existe. Portanto, quando sem -depth, é melhor executar umrmpor nome de caminho, então -exec … \;.

Mas, mesmo assim, os arquivos que não estão mais lá provavelmente acionarão avisos; não de rmmas de find. É porque findaprende sobre o conteúdo de um diretório antes de processar o diretório. Ele faz isso mesmo se for processar o diretório primeiro (ou seja, mesmo se não houver -depth). Após a rmremoção ./path/to/foo/again findainda tentará processar ./path/to/foo/again/whatever. Qualquer solução com (explícito ou implícito) -depthestá livre deste problema.

Use o primeiro formulário portátil, aquele com -depth; ou melhor o formulário com -delete, se apenas seus findsuportes -delete.

Nota lateral: se você deseja esvaziar um diretório específicocd , acesse -o e:

# check if in the right directory
find . ! -name . -delete

Com implementações comuns de findvocê nem precisa ! -name .porque elas não excluem .e é por design . O comando simplifica para:

find . -delete