Como posso encontrar todas as extensões de arquivo distintas em uma hierarquia de pastas?

Em uma máquina Linux, eu gostaria de percorrer uma hierarquia de pastas e obter uma lista de todas as extensões de arquivo distintas nela.

Qual seria a melhor maneira de conseguir isso com um shell?

Tente isso (não tenho certeza se é a melhor maneira, mas funciona):

find . -type f | perl -ne 'print $1 if m/\.([^.\/]+)$/' | sort -u

Funciona da seguinte forma:

• Encontre todos os arquivos da pasta atual
• Imprime a extensão dos arquivos, se houver
• Faça uma lista classificada única

Não é necessário o pipe sort, o awk pode fazer tudo:

find . -type f | awk -F. '!a[$NF]++{print $NF}'

Versão recursiva:

find . -type f | sed -e 's/.*\.//' | sed -e 's/.*\///' | sort -u

Se você deseja totais (quantas vezes a extensão foi vista):

find . -type f | sed -e 's/.*\.//' | sed -e 's/.*\///' | sort | uniq -c | sort -rn

Não recursivo (pasta única):

for f in *.*; do printf "%s\n" "${f##*.}"; done | sort -u

Baseei isso nesta postagem do fórum , o crédito deve ir para lá.

Powershell:

dir -recurse | select-object extension -unique

Obrigado a http://kevin-berridge.blogspot.com/2007/11/windows-powershell.html

Minha alternativa compatível com POSIX: awk-less, sed-less, Perl-less e Python-less:

find . -type f | rev | cut -d. -f1 | rev  | tr '[:upper:]' '[:lower:]' | sort | uniq --count | sort -rn

O truque é que ele inverte a linha e corta a extensão no início.
Também converte as extensões em minúsculas.

Exemplo de saída:

   3689 jpg
   1036 png
    610 mp4
     90 webm
     90 mkv
     57 mov
     12 avi
     10 txt
      3 zip
      2 ogv
      1 xcf
      1 trashinfo
      1 sh
      1 m4v
      1 jpeg
      1 ini
      1 gqv
      1 gcs
      1 dv

Encontre tudo com um ponto e mostre apenas o sufixo.

find . -type f -name "*.*" | awk -F. '{print $NF}' | sort -u

se você souber que todo sufixo tem 3 caracteres,

find . -type f -name "*.???" | awk -F. '{print $NF}' | sort -u

ou com sed mostra todos os sufixos com um a quatro caracteres. Altere {1,4} para o intervalo de caracteres que você espera no sufixo.

find . -type f | sed -n 's/.*\.\(.\{1,4\}\)$/\1/p'| sort -u

Adicionando minha própria variação à mistura. Eu acho que é o mais simples do lote e pode ser útil quando a eficiência não é uma grande preocupação.

find . -type f | grep -o -E '\.[^\.]+$' | sort -u

No Python, use geradores para diretórios muito grandes, incluindo extensões em branco, e obtenha o número de vezes que cada extensão aparece:

import json
import collections
import itertools
import os

root = '/home/andres'
files = itertools.chain.from_iterable((
    files for _,_,files in os.walk(root)
    ))
counter = collections.Counter(
    (os.path.splitext(file_)[1] for file_ in files)
)
print json.dumps(counter, indent=2)

Eu tentei um monte de respostas aqui, mesmo a "melhor" resposta. Todos ficaram aquém do que eu estava procurando especificamente. Portanto, além das últimas 12 horas sentado no código regex para vários programas e lendo e testando essas respostas, é isso que eu criei que funciona EXATAMENTE como eu quero.

 find . -type f -name "*.*" | grep -o -E "\.[^\.]+$" | grep -o -E "[[:alpha:]]{2,16}" | awk '{print tolower($0)}' | sort -u

• Localiza todos os arquivos que podem ter uma extensão.
• Greps apenas a extensão
• Greps para extensões de arquivo entre 2 e 16 caracteres (apenas ajuste os números se eles não atenderem à sua necessidade). Isso ajuda a evitar arquivos de cache e arquivos do sistema (o bit do arquivo do sistema é procurar prisão).
• Awk para imprimir as extensões em minúsculas.
• Classifique e traga apenas valores exclusivos. Originalmente, eu tentara tentar a resposta awk, mas ela duplicaria os itens que variavam na distinção entre maiúsculas e minúsculas.

Se você precisar de uma contagem das extensões de arquivo, use o código abaixo

find . -type f -name "*.*" | grep -o -E "\.[^\.]+$" | grep -o -E "[[:alpha:]]{2,16}" | awk '{print tolower($0)}' | sort | uniq -c | sort -rn

Embora esses métodos levem algum tempo para serem concluídos e provavelmente não sejam as melhores maneiras de solucionar o problema, eles funcionam.

Atualização: as extensões de arquivo longas por @ alpha_989 causarão um problema. Isso se deve ao regex original "[[: alpha:]] {3,6}". Atualizei a resposta para incluir a regex "[[: alpha:]] {2,16}". No entanto, qualquer pessoa que use esse código deve estar ciente de que esses números são o mínimo e o máximo de quanto tempo a extensão é permitida para a saída final. Qualquer coisa fora desse intervalo será dividida em várias linhas na saída.

Nota: A postagem original leu "- Greps para extensões de arquivo entre 3 e 6 caracteres (basta ajustar os números se eles não atenderem às suas necessidades). Isso ajuda a evitar arquivos em cache e arquivos do sistema (o bit do arquivo do sistema é procurar prisão). "

Idéia: pode ser usada para encontrar extensões de arquivos com um comprimento específico via:

 find . -type f -name "*.*" | grep -o -E "\.[^\.]+$" | grep -o -E "[[:alpha:]]{4,}" | awk '{print tolower($0)}' | sort -u

Onde 4 é o comprimento das extensões de arquivo a incluir e, em seguida, encontre também as extensões além desse comprimento.

Como já existe outra solução que usa Perl:

Se você possui o Python instalado, também pode fazer (a partir do shell):

python -c "import os;e=set();[[e.add(os.path.splitext(f)[-1]) for f in fn]for _,_,fn in os.walk('/home')];print '\n'.join(e)"

Até agora, nenhuma das respostas lida com nomes de arquivos com novas linhas corretamente (exceto os de ChristopheD, que chegaram quando eu estava digitando isso). O seguinte não é uma linha de shell, mas funciona e é razoavelmente rápido.

import os, sys

def names(roots):
    for root in roots:
        for a, b, basenames in os.walk(root):
            for basename in basenames:
                yield basename

sufs = set(os.path.splitext(x)[1] for x in names(sys.argv[1:]))
for suf in sufs:
    if suf:
        print suf

Eu não acho que este foi mencionado ainda:

find . -type f -exec sh -c 'echo "${0##*.}"' {} \; | sort | uniq -c

Eu acho que a maneira mais simples e direta é

for f in *.*; do echo "${f##*.}"; done | sort -u

É modificado na 3ª via de ChristopheD.

você também pode fazer isso

find . -type f -name "*.php" -exec PATHTOAPP {} +

Achei simples e rápido ...

   # find . -type f -exec basename {} \; | awk -F"." '{print $NF}' > /tmp/outfile.txt
   # cat /tmp/outfile.txt | sort | uniq -c| sort -n > tmp/outfile_sorted.txt

A resposta aceita usa REGEX e você não pode criar um comando alternativo com REGEX, você deve colocá-lo em um script de shell, estou usando o Amazon Linux 2 e fiz o seguinte:

1. Coloquei o código de resposta aceito em um arquivo usando:

   sudo vim find.sh

adicione este código:

find ./ -type f | perl -ne 'print $1 if m/\.([^.\/]+)$/' | sort -u

salve o arquivo digitando: :wq!

2. sudo vim ~/.bash_profile

3. alias getext=". /path/to/your/find.sh"

4. :wq!

5. . ~/.bash_profile