Díficil. file(1)tem uma --extensionopção, mas nos meus testes (Debian/bullseye) a maioria dos arquivos mostrou pontos de interrogação ( ???).

E a codificação case..esacpara cada tipo de arquivo conhecido provavelmente não funcionará, pois fileparece detectar pelo menos 3000 tipos de arquivo:

❯ file -l | wc -l
3186

Primeiro eu tentaria obter a lista dos tipos de arquivo no diretório fornecido:

Observe, zsh-globbing usado aqui:

❯ file -p -n -b .*(.) *(.) | sort | uniq
ASCII text
ASCII text, with no line terminators
ASCII text, with very long lines
ASCII text, with very long lines, with no line terminators
data
empty
JPEG image data, JFIF standard 1.01, resolution (DPI), density 300x300, segment length 16, Exif Standard: [TIFF image data, big-endian, direntries=0], baseline, precision 8, 96x96, components 3
JSON data
Non-ISO extended-ASCII text, with very long lines, with CRLF, LF line terminators, with escape sequences
Python script, UTF-8 Unicode text executable
UTF-8 Unicode text
UTF-8 Unicode text, with very long lines
very short file (no magic)
X11 Xauthority data

A findlinha a seguir leva à mesma saída:

find -maxdepth 1 -type f -exec file -p -n -b {} \; | sort | uniq

Com esta lista, eu criaria um tipo de arquivo de mapeamento/pesquisa de extensão de tipo de arquivo e o usaria para renomear os arquivos:

ext1;ASCII text
ext2;ASCII text, with no line terminators
ext3;ASCII text, with very long lines
ext4;ASCII text, with very long lines, with no line terminators
ext5;data
ext6;empty
ext7;JPEG image data, JFIF standard 1.01, resolution (DPI), density 300x300, segment length 16, Exif Standard: [TIFF image data, big-endian, direntries=0], baseline, precision 8, 96x96, components 3
ext8;JSON data
ext9;Non-ISO extended-ASCII text, with very long lines, with CRLF, LF line terminators, with escape sequences
ext10;Python script, UTF-8 Unicode text executable
ext11;UTF-8 Unicode text
ext12;UTF-8 Unicode text, with very long lines
ext13;very short file (no magic)
ext14;X11 Xauthority data

HTH

Com perl-based renamee o File::MimeInfo::Magicmódulo perl (no libfile-mimeinfo-perlpacote em sistemas baseados em Debian, geralmente instalado por padrão em instalações de desktop, pois é uma dependência (recomendada) de xdg-utils):

rename -n -- '
  use File::MimeInfo::Magic qw(mimetype extensions);
  my $ext; $_ .= ".$ext" if ! /\./ && ($ext = extensions mimetype$_)' *

(remova o -npara execução a seco, se estiver correto).

Adivinhar o tipo de arquivo de acordo com o número mágico pode ajudar a resolver isso.

Consulte https://en.wikipedia.org/wiki/List_of_file_signatures

Esta página lista a maioria dos tipos de arquivos e seus números mágicos, seu script apenas lê alguns bytes do deslocamento e compara com a assinatura e adiciona o sufixo correspondente.

Esta resposta pressupõe que você tenha uma lista relativamente limpa de nomes de arquivos, todos em um diretório, e que os nomes dos arquivos não contenham espaços, tabulações, novas linhas e outros caracteres mal comportados. Os trechos de código aqui são destinados ao bashshell.

Primeiro, faça um backup

Sempre que você está fazendo uma renomeação automática de milhares de arquivos, sempre há uma chance de haver um problema. Um problema vezes cem mil arquivos equivale a cem mil problemas a serem corrigidos antes que você possa tentar novamente.

Comece fazendo um backup:

$ mkdir ~/my-backup
$ rsync -av ./ ~/my-backup/

Agora, se você errar alguma coisa, você pode restaurar a partir do seu backup:

$ rsync -av --delete ~/my-backup/ ./

filevaria muito

A qualidade de implementação do filecomando varia entre as distribuições. Parece ser uma aposta segura que quanto mais recente o lançamento, melhor, já magicque o arquivo fileusado provavelmente será mais atualizado. Se puder, você pode obter resultados mais completos (ou seja, menos trabalho manual) copiando/ rsync-ing os arquivos para uma máquina executando um sistema operacional com uma versão melhor do file.

Então, quão boa é a fileimplementação do meu sistema?

Vamos definir uma função fextque será executada file -b --extensionem qualquer glob curinga que dermos a ela. Além disso, executaremos a saída de algumas transformações filesimples para padronizar a saída ao nosso gosto:sedfile

fext () {
  file -b --extension "$@" |
  sed -e 's-^jpeg/jpg/jpe/jfif$-jpg-' |
  sed -e 's-^pdf$-PDF-' |
  cat
}

Por favor, perdoe os inúteis cat. Ele está incluído para modularidade, de modo que, se você tiver tipos de arquivo que retornam várias strings de extensão, você pode copiar, colar e editar a sedlinha para traduzir esses múltiplos para a única extensão de sua preferência, ou capitalizar arbitrariamente, se desejar, etc. Neste exemplo, os arquivos identificados filecomo as jpeg/jpg/jpe/jfifreceberão a extensão jpg, enquanto os arquivos identificados como pdfreceberão a extensão PDF. O caté apenas um espaço reservado no-op no final da lista de transformação.

E quanto a outros tipos de arquivo que possuem várias extensões?

É importante garantir que você enumerou todos os tipos de arquivo possíveis em sua coleção para os quais fileretorna várias extensões. Isso é simples de testar:

$ fext * | grep /

Não deve haver saída. Se houver saída, você precisará adicionar outra sedlinha à sua fextdefinição.

Agora você pode executar fextem toda a sua coleção de arquivos para ver quantos ele acha que reconhece e quantos não reconhece.

Estou usando um grupo de teste de 152 arquivos fracamente escolhidos. Em três sistemas, eu corri:

$ fext * | sort | uniq -c

Ubuntu 18.04.2 LTS:

$ fext * | sort | uniq -c
    137 ???
     15 jpg

FreeBSD 13.1:

$ fext * | sort | uniq -c
  28 ???
  76 PDF
  15 jpg
  32 png
   1 tif,tiff

Ubuntu 22.04 LTS:

$ fext * | sort | uniq -c
     28 ???
     15 jpg
     76 PDF
     32 png
      1 tif,tiff

Observe que encontramos um bug no magicarquivo usado pelo fileutilitário. Felizmente, isso é fácil de corrigir em nossa fextfunção:

$ fext () {
  file -b --extension "$@" |
  sed -e 's-^jpeg/jpg/jpe/jfif$-jpg-' |
  sed -e 's-^pdf$-PDF-' |
  sed -e 's-^tif,tiff$-tiff-' |
  cat
}
$ fext * | sort | uniq -c
     28 ???
     15 jpg
     76 PDF
     32 png
      1 tiff

Excelente. O importante aqui é que NÃO há barras (ou vírgulas!). Criamos uma métrica quantitativa bruta que nos permite ver qual porcentagem de arquivos são identificados por file. Especificamente, filenão identifica 28 dos 152 arquivos, ou um pouco mais de 18%. Podemos refinar ainda mais nossa fextfunção para atribuir uma extensão padrão a arquivos desses tipos que filenão podem ser identificados.

$ fext () {
  file -b --extension "$@" |
  sed -e 's-^jpeg/jpg/jpe/jfif$-jpg-' |
  sed -e 's-^pdf$-PDF-' |
  sed -e 's-^tif,tiff$-tiff-' |
  sed -e 's-^???$-unknown-' |
  cat
}
$ fext * | sort | uniq -c
     15 jpg
     76 PDF
     32 png
      1 tiff
     28 unknown

Se desejarmos, podemos greplistar e ver os nomes de arquivos específicos dos arquivos que file não conseguem identificar:

$ for f in *; do [ -f "$f" ] && printf '%10s %s\n' "$(fext "$f")" "$f"; done | grep -w unknown 

No meu (fraco) conjunto de amostras, os arquivos "desconhecidos" são predominantemente arquivos PostScript. fileos identifica como tal, mas o magicarquivo não tem uma extensão designada para arquivos PostScript.

Então, se usarmos fextpara fornecer a extensão para cada arquivo, os arquivos que filenão conseguirem identificar receberão a extensão unknown.

$ for f in *; do [ -f "$f" ] && mv -vi "$f" "$f.$(fext "$f")"; done

Infelizmente, file -b --extensionnão é muito útil porque retorna ???para muitos formatos com extensões conhecidas. Em vez disso, comece clonando o diretório de interesse em caso de algum contratempo:

# using hard links
cp --link /path/to/originals /path/to/files

# using reflinks on supported file systems
cp --reflink=auto /path/to/originals /path/to/files

Em seguida, crie uma lista de tipos mime no diretório:

find /path/to/files -type f -exec file -b --mime-type {} \; | sort -u

A saída se parece com:

application/epub+zip
application/msword
application/pdf
application/zip
image/gif
image/jpeg
image/png
image/svg+xml
text/html
text/plain
text/rtf
text/xml

Agora crie um bashscript add_ext.shque renomeie os arquivos com a extensão apropriada, de acordo com o tipo mime, se necessário.

#!/usr/bin/env bash

[ $# -lt 1 ] && echo "Usage: $0 <FILE>" && exit 1

mimetype=$(file -b --mime-type "$1")
extension="${1#**.}"
new_ext="unset"

case $mimetype in
   'application/epub+zip')
      new_ext="epub"
      ;;

   'application/msword')
      new_ext="doc"
      ;;

   'application/pdf')
      new_ext="pdf"
      ;;

   'application/zip')
      new_ext="zip"
      ;;

   'image/gif')
      new_ext="gif"
      ;;

   'image/jpeg')
      new_ext="jpeg"
      ;;

   'image/png')
      new_ext="png"
      ;;

   'image/svg+xml')
      new_ext="svg"
      ;;

   'text/html')
      new_ext="html"
      ;;

   'text/plain')
      new_ext="txt"
      ;;

   'text/rtf')
      new_ext="rtf"
      ;;

   'text/xml')
      new_ext="xml"
      ;;
esac

[ "$new_ext" != "unset" ] \
   && [ "$extension" != "$new_ext" ] \
   && [ ! -e "$1.$new_ext" ] \
   && mv "$1" "$1.$new_ext"

Não esqueça chmod +x add_ext.shantes de usar findpara executar o script nos arquivos:

find /path/to/files -type f -exec ./add_ext.sh {} \;