¿Cómo puedo encontrar todas las extensiones de archivo distintas en una jerarquía de carpetas?

En una máquina Linux me gustaría recorrer una jerarquía de carpetas y obtener una lista de todas las extensiones de archivo distintas dentro de ella.

¿Cuál sería la mejor manera de lograr esto desde un shell?

Pruebe esto (no estoy seguro si es la mejor manera, pero funciona):

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

Funciona de la siguiente manera:

• Encuentra todos los archivos de la carpeta actual
• Imprime la extensión de los archivos, si los hay.
• Haga una lista ordenada única

No es necesario que la tubería sortlo haga, awk puede hacerlo todo:

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

Versión recursiva:

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

Si desea totales (cuántas veces se vio la extensión):

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

No recursivo (carpeta única):

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

He basado esto en esta publicación del foro , el crédito debería ir allí.

Potencia Shell:

dir -recurse | select-object extension -unique

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

Mi alternativa compatible con POSIX, awk-less, sed-less, Perl-less, Python-less:

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

El truco es que invierte la línea y corta la extensión al principio.
También convierte las extensiones a minúsculas.

Salida de ejemplo:

   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

Encuentra todo con un punto y muestra solo el sufijo.

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

si sabes que todos los sufijos tienen 3 caracteres, entonces

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

o con sed muestra todos los sufijos con uno a cuatro caracteres. Cambie {1,4} al rango de caracteres que espera en el sufijo.

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

Agregar mi propia variación a la mezcla. Creo que es el más simple de todos y puede ser útil cuando la eficiencia no es una gran preocupación.

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

En Python, use generadores para directorios muy grandes, incluidas extensiones en blanco, y obtenga la cantidad de veces que aparece cada extensión:

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)

Intenté muchas de las respuestas aquí, incluso la "mejor" respuesta. Todos se quedaron cortos de lo que yo buscaba específicamente. Entonces, además de las últimas 12 horas de estar en código regex para múltiples programas y leer y probar estas respuestas, esto es lo que se me ocurrió y funciona EXACTAMENTE como quiero.

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

• Encuentra todos los archivos que pueden tener una extensión.
• Greps solo la extensión
• Greps para extensiones de archivo de entre 2 y 16 caracteres (solo ajuste los números si no se ajustan a sus necesidades). Esto ayuda a evitar los archivos de caché y los archivos del sistema (el bit del archivo del sistema es buscar en la cárcel).
• Awk para imprimir las extensiones en minúsculas.
• Ordenar y aportar solo valores únicos. Originalmente había intentado probar la respuesta awk, pero duplicaría los elementos que varían en mayúsculas y minúsculas.

Si necesita un recuento de las extensiones de archivo, use el siguiente código

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

Si bien estos métodos tardarán un tiempo en completarse y probablemente no sean las mejores formas de solucionar el problema, funcionan.

Actualización: las extensiones de archivo largas @ alpha_989 causarán un problema. Eso se debe a la expresión regular original "[[: alpha:]] {3,6}". He actualizado la respuesta para incluir la expresión regular "[[: alpha:]] {2,16}". Sin embargo, cualquiera que use este código debe tener en cuenta que esos números son el mínimo y el máximo de cuánto tiempo se permite la extensión para la salida final. Cualquier cosa fuera de ese rango se dividirá en varias líneas en la salida.

Nota: La publicación original sí decía "- Greps para extensiones de archivo de entre 3 y 6 caracteres (solo ajuste los números si no se ajustan a sus necesidades). Esto ayuda a evitar archivos de caché y archivos del sistema (el bit del archivo del sistema es buscar en la cárcel). "

Idea: podría usarse para buscar extensiones de archivo de una longitud específica mediante:

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

Donde 4 es la longitud de las extensiones de archivo a incluir y luego también encuentra cualquier extensión más allá de esa longitud.

Como ya hay otra solución que usa Perl:

Si tiene instalado Python, también podría hacer (desde el 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)"

Ninguna de las respuestas hasta el momento trata con nombres de archivo con líneas nuevas correctamente (excepto ChristopheD, que apareció cuando estaba escribiendo esto). Lo siguiente no es una línea única de shell, pero funciona, y es razonablemente 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

No creo que este haya sido mencionado todavía:

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

Creo que la forma más simple y directa es

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

Se modificó en la tercera vía de ChristopheD.

también podrías hacer esto

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

Lo he encontrado simple y 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

La respuesta aceptada usa REGEX y no puede crear un comando de alias con REGEX, debe ponerlo en un script de shell, estoy usando Amazon Linux 2 e hice lo siguiente:

1. Puse el código de respuesta aceptado en un archivo usando:

   sudo vim find.sh

agregue este código:

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

guarde el archivo escribiendo: :wq!

2. sudo vim ~/.bash_profile

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

4. :wq!

5. . ~/.bash_profile