Como encontro quais arquivos estão faltando em uma lista?

Eu tenho uma lista de arquivos que quero verificar se eles existem no meu sistema de arquivos. Eu pensei em fazer isso usando findcomo em:

for f in $(cat file_list); do
find . -name $f > /dev/null || print $f
done

(usando zsh), mas isso não funciona, pois findparece sair 0se ele encontra ou não o arquivo. Eu acho que eu poderia passar por algum outro teste que testa para ver se findproduz alguma saída (bruto, mas eficaz seria substituí-lo > /dev/nullpor |grep ''), mas isso parece usar um troll para pegar uma cabra (outras nacionalidades podem dizer algo sobre marretas e nozes )

Existe uma maneira de coagir finda me dar um valor de saída útil? Ou pelo menos para obter uma lista daqueles arquivos que não foram encontrados? (Eu posso imaginar o último sendo talvez mais fácil por alguma escolha astuta de conectivos lógicos, mas pareço sempre ficar atolado quando tento descobrir isso.)

Antecedentes / Motivação: Eu tenho um backup "principal" e quero verificar se existem alguns arquivos na minha máquina local no meu backup principal antes de excluí-los (para criar um pouco de espaço). Então, fiz uma lista dos arquivos, ssheditei-os na máquina principal e fiquei sem saber por que descobrir a melhor maneira de encontrar os arquivos ausentes.

findconsidera não encontrar nada como um caso especial de sucesso (nenhum erro ocorreu). Uma maneira geral de testar se os arquivos correspondem a alguns findcritérios é testar se a saída de findestá vazia. Para uma melhor eficiência quando houver arquivos correspondentes, use -quitno GNU find para fazê-lo sair na primeira partida ou head( head -c 1se disponível, caso contrário, o head -n 1que é padrão) em outros sistemas para fazê-lo morrer de um cano quebrado ao invés de produzir uma saída longa.

while IFS= read -r name; do
  [ -n "$(find . -name "$name" -print | head -n 1)" ] || printf '%s\n' "$name"
done <file_list

No bash ≥4 ou zsh, você não precisa do findcomando externo para uma correspondência simples de nome: você pode usar **/$name. Versão do Bash:

shopt -s nullglob
while IFS= read -r name; do
  set -- **/"$name"
  [ $# -ge 1 ] || printf '%s\n' "$name"
done <file_list

Versão Zsh em um princípio semelhante:

while IFS= read -r name; do
  set -- **/"$name"(N)
  [ $# -ge 1 ] || print -- "$name"
done <file_list

Ou aqui está uma maneira mais curta, porém mais enigmática, de testar a existência de um arquivo que corresponde a um padrão. O qualificador glob Ndeixa a saída vazia se não houver correspondência, [1]retém apenas a primeira correspondência ee:REPLY=true: altera cada correspondência para expandir para em 1vez do nome do arquivo correspondente. Então, **/"$name"(Ne:REPLY=true:[1]) falseexpande para true falsese houver uma correspondência ou apenas falsese não houver uma correspondência.

while IFS= read -r name; do
  **/"$name"(Ne:REPLY=true:[1]) false || print -- "$name"
done <file_list

Seria mais eficiente combinar todos os seus nomes em uma única pesquisa. Se o número de padrões não for muito grande para o limite de comprimento do sistema em uma linha de comando, você poderá juntar todos os nomes com-o , fazer uma única findchamada e pós-processar a saída. Se nenhum dos nomes contiver metacaracteres de shell (para que os nomes também sejam findpadrões), eis uma maneira de pós-processar com o awk (não testado):

set -o noglob; IFS='
'
set -- $(<file_list sed -e '2,$s/^/-o\
/')
set +o noglob; unset IFS
find . \( "$@" \) -print | awk -F/ '
    BEGIN {while (getline <"file_list") {found[$0]=0}}
    wanted[$0]==0 {found[$0]=1}
    END {for (f in found) {if (found[f]==0) {print f}}}
'

Outra abordagem seria usar o Perl e File::Find, o que facilita a execução do código Perl para todos os arquivos em um diretório.

perl -MFile::Find -l -e '
    %missing = map {chomp; $_, 1} <STDIN>;
    find(sub {delete $missing{$_}}, ".");
    print foreach sort keys %missing'

Uma abordagem alternativa é gerar uma lista de nomes de arquivos de ambos os lados e trabalhar em uma comparação de texto. Versão Zsh:

comm -23 <(<file_list sort) <(print -rl -- **/*(:t) | sort)

Você pode usar statpara determinar se existe um arquivo no sistema de arquivos.

Você deve usar as funções internas do shell para testar se existem arquivos.

while read f; do
   test -f "$f" || echo $f
done < file_list

O "teste" é opcional e o script realmente funciona sem ele, mas eu o deixei lá para facilitar a leitura.

Edit: Se você realmente não tem opção, a não ser trabalhar para uma lista de nomes de arquivos sem caminhos, sugiro que você crie uma lista de arquivos uma vez com o find, em seguida, itere-o com grep para descobrir quais arquivos estão lá.

find -type f /dst > $TMPFILE
while read f; do
    grep -q "/$f$" $TIMPFILE || echo $f
done < file_list

Observe que:

• a lista de arquivos inclui apenas arquivos, não diretórios,
• a barra no padrão de correspondência grep é para compararmos nomes de arquivos completos e não parciais,
• e o último '$' no padrão de pesquisa é corresponder ao final da linha para que você não obtenha correspondências de diretório, apenas patches completos de nome de arquivo.

Uma primeira abordagem simplista poderia ser:

a) classifique sua lista de arquivos:

sort file.lst > sorted.lst 
for f in $(< sortd.lst) ; do find -name $f -printf "%f\n"; done > found.lst
diff sorted.lst found.lst

para encontrar missões ou

comm sorted.lst found.lst

encontrar correspondências

• Armadilhas:
  • Novas linhas nos nomes de arquivos são muito difíceis de lidar
  • espaços em branco e coisas semelhantes nos nomes de arquivos também não são bons. Mas como você tem controle sobre os arquivos na lista de arquivos, talvez essa solução já seja suficiente, no entanto ...

• Desvantagens:

  • Quando o find encontra um arquivo, ele continua sendo executado para encontrar outro e outro. Seria bom pular outras pesquisas.

  • O find pode procurar vários arquivos ao mesmo tempo, com alguma preparação:

    localize -name a.file -ou -name -b.file -ou -name c.file ...

Pode localizar ser uma opção? Novamente, uma lista pré-classificada de arquivos assumiu:

 for f in $(< sorted.tmp) ; do locate --regexp "/"$f"$" > /dev/null || echo missing $f ; done

Uma pesquisa por foo.bar não corresponderá ao arquivo foo.ba ou oo.bar com a construção --regexp-(não deve ser confundida com regex sem p).

Você pode especificar um banco de dados específico para localização e precisará atualizá-lo antes de pesquisar, se precisar dos resultados mais recentes.

Eu acho que isso pode ser útil também.

Esta é uma solução de uma linha, caso você opte pela "lista" de arquivos reais que deseja sincronizar com outra pasta:

function FUNCsync() { local fileCheck="$synchronizeTo/$1"; if [[ ! -f "$fileCheck" ]];then echo "$fileCheck";fi; };export -f FUNCsync;find "$synchronizeFrom/" -maxdepth 1 -type f -not -iname "*~" -exec bash -c 'FUNCsync "{}"' \; |sort

para ajudar a ler:

function FUNCsync() {
  local fileCheck="$synchronizeTo/$1";
  if [[ ! -f "$fileCheck" ]];then 
    echo "$fileCheck";
  fi; 
};export -f FUNCsync;
find "$synchronizeFrom/" -maxdepth 1 -type f -not -iname "*~" -exec bash -c 'FUNCsync "{}"' \; |sort

este exemplo exclui arquivos "* ~" de backup e limita ao tipo de arquivo regular "-type f"

FIND_EXP=". -type f \( "
while read f; do
   FIND_EXP="${FIND_EXP} -iname $f -or"
done < file_list
FIND_EXP="${var%-or}"
FIND_EXP="${FIND_EXP} \)"
find ${FIND_EXP}

Talvez?

Por que não simplesmente comparar o comprimento da lista de consultas com o comprimento da lista de resultados?

while read p; do
  find . -name $p 2>/dev/null
done < file_list.txt | wc -l
wc -l file_list.txt