¿Hay un comando bash que cuente la cantidad de archivos que coinciden con un patrón?

Por ejemplo, quiero obtener el recuento de todos los archivos en un directorio que coincida con este patrón: log*

Este simple one-liner debería funcionar en cualquier shell, no solo bash:

ls -1q log* | wc -l

ls -1q le dará una línea por archivo, incluso si contienen espacios en blanco o caracteres especiales como líneas nuevas.

La salida se canaliza a wc -l, que cuenta el número de líneas.

Puede hacer esto de manera segura (es decir, no será molestado por archivos con espacios o \nen su nombre) con bash:

$ shopt -s nullglob
$ logfiles=(*.log)
$ echo ${#logfiles[@]}

Debe habilitar nullglobpara que no obtenga el literal *.logen la $logfiles matriz si no coinciden los archivos. (Consulte Cómo "deshacer" un 'set -x'? Para ver ejemplos de cómo restablecerlo de manera segura).

Muchas respuestas aquí, pero algunas no tienen en cuenta

• nombres de archivo con espacios, líneas nuevas o caracteres de control en ellos
• nombres de archivo que comienzan con guiones (imagine un archivo llamado -l)
• archivos ocultos, que comienzan con un punto (si el globo era en *.loglugar delog*
• directorios que coinciden con el glob (por ejemplo, un directorio llamado logsque coincide log*)
• directorios vacíos (es decir, el resultado es 0)
• directorios extremadamente grandes (enumerarlos todos podría agotar la memoria)

Aquí hay una solución que los maneja a todos:

ls 2>/dev/null -Ubad1 -- log* | wc -l

Explicación:

• -Uhace lsque no se ordenen las entradas, lo que significa que no necesita cargar todo el listado de directorios en la memoria
• -bimprime escapes de estilo C para caracteres no gráficos, lo que hace que las nuevas líneas se impriman como \n.
• -aimprime todos los archivos, incluso los archivos ocultos (no es estrictamente necesario cuando el glob log*implica que no hay archivos ocultos)
• -dimprime directorios sin intentar enumerar el contenido del directorio, que es lo que lsnormalmente haría
• -1 se asegura de que esté en una columna (ls hace esto automáticamente cuando escribe en una tubería, por lo que no es estrictamente necesario)
• 2>/dev/nullredirige stderr para que si hay 0 archivos de registro, ignore el mensaje de error. (Tenga en cuenta que shopt -s nullglob, en su lugar, se lsenumeraría todo el directorio de trabajo).
• wc -lconsume la lista de directorios a medida que se genera, por lo que la salida de lsnunca está en la memoria en ningún momento.
• --Los nombres de archivo se separan del comando utilizando --para no ser entendidos como argumentos para ls(en caso de que log*se elimine)

El shell se expandirá log*a la lista completa de archivos, lo que puede agotar la memoria si se trata de muchos archivos, por lo que es mejor ejecutarlo a través de grep:

ls -Uba1 | grep ^log | wc -l

Este último maneja directorios de archivos extremadamente grandes sin usar mucha memoria (aunque sí usa una subshell). El -dya no es necesario, porque solo enumera el contenido del directorio actual.

Para una búsqueda recursiva:

find . -type f -name '*.log' -printf x | wc -c

wc -ccontará el número de caracteres en la salida de find, mientras que -printf xle indica findque imprima un solo xpara cada resultado.

Para una búsqueda no recursiva, haga esto:

find . -maxdepth 1 -type f -name '*.log' -printf x | wc -c

La respuesta aceptada para esta pregunta es incorrecta, pero tengo poca reputación, así que no puedo agregarle ningún comentario.

La respuesta correcta a esta pregunta la da Mat:

shopt -s nullglob
logfiles=(*.log)
echo ${#logfiles[@]}

El problema con la respuesta aceptada es que wc -l cuenta el número de caracteres de nueva línea y los cuenta incluso si se imprimen en el terminal como '?' en la salida de 'ls -l'. Esto significa que la respuesta aceptada FALLA cuando un nombre de archivo contiene un carácter de nueva línea. He probado el comando sugerido:

ls -l log* | wc -l

e informa erróneamente un valor de 2 incluso si solo hay 1 archivo que coincide con el patrón cuyo nombre contiene un carácter de nueva línea. Por ejemplo:

touch log$'\n'def
ls log* -l | wc -l

Si tiene muchos archivos y no desea usar la shopt -s nullglobsolución de matriz elegante y bash, puede usar find y así sucesivamente siempre que no imprima el nombre del archivo (que puede contener nuevas líneas).

find -maxdepth 1 -name "log*" -not -name ".*" -printf '%i\n' | wc -l

Esto encontrará todos los archivos que coincidan con log * y que no comiencen con .*: "not name. *" Es redundante, pero es importante tener en cuenta que el valor predeterminado para "ls" es no mostrar archivos de puntos, pero el valor predeterminado para encontrar es incluirlos.

Esta es una respuesta correcta y maneja cualquier tipo de nombre de archivo que pueda lanzarle, porque el nombre de archivo nunca se pasa entre los comandos.

Pero, la shopt nullglobrespuesta es la mejor respuesta!

Aquí está mi única línea para esto.

 file_count=$( shopt -s nullglob ; set -- $directory_to_search_inside/* ; echo $#)

Puede usar la opción -R para buscar los archivos junto con los que están dentro de los directorios recursivos

ls -R | wc -l // to find all the files

ls -R | grep log | wc -l // to find the files which contains the word log

puedes usar patrones en grep

Un comentario importante

(no hay suficiente reputación para comentar)

Esto es BUGGY :

ls -1q some_pattern | wc -l

Si shopt -s nullglobse configura, imprime el número de TODOS los archivos regulares, no solo los que tienen el patrón (probado en CentOS-8 y Cygwin). ¿Quién sabe qué otros errores sin sentido lstiene?

Esto es CORRECTO y mucho más rápido:

shopt -s nullglob; files=(some_pattern); echo ${#files[@]};

Hace el trabajo esperado.

Puede definir dicho comando fácilmente, utilizando una función de shell. Este método no requiere ningún programa externo y no genera ningún proceso secundario. No intenta el lsanálisis peligroso y maneja caracteres "especiales" (espacios en blanco, líneas nuevas, barras invertidas, etc.) muy bien. Solo se basa en el mecanismo de expansión de nombre de archivo proporcionado por el shell. Es compatible con al menos sh, bash y zsh.

La siguiente línea define una función llamada countque imprime el número de argumentos con los que se ha llamado.

count() { echo $#; }

Simplemente llámelo con el patrón deseado:

count log*

Para que el resultado sea correcto cuando el patrón global no tiene coincidencia, la opción de shell nullglob(o failglob, que es el comportamiento predeterminado en zsh) debe establecerse en el momento en que ocurre la expansión. Se puede configurar así:

shopt -s nullglob    # for sh / bash
setopt nullglob      # for zsh

Dependiendo de lo que quiera contar, también podría estar interesado en la opción de shell dotglob.

Desafortunadamente, con bash al menos, no es fácil establecer estas opciones localmente. Si no desea configurarlos globalmente, la solución más sencilla es utilizar la función de esta manera más complicada:

( shopt -s nullglob ; shopt -u failglob ; count log* )

Si desea recuperar la sintaxis ligera count log*, o si realmente desea evitar generar una subshell, puede hackear algo en la línea de:

# sh / bash:
# the alias is expanded before the globbing pattern, so we
# can set required options before the globbing gets expanded,
# and restore them afterwards.
count() {
    eval "$_count_saved_shopts"
    unset _count_saved_shopts
    echo $#
}
alias count='
    _count_saved_shopts="$(shopt -p nullglob failglob)"
    shopt -s nullglob
    shopt -u failglob
    count'

Como beneficio adicional, esta función es de uso más general. Por ejemplo:

count a* b*          # count files which match either a* or b*
count $(jobs -ps)    # count stopped jobs (sh / bash)

Al convertir la función en un archivo de script (o un programa C equivalente), invocable desde la RUTA, también se puede componer con programas como findy xargs:

find "$FIND_OPTIONS" -exec count {} \+    # count results of a search

He pensado mucho en esta respuesta, especialmente teniendo en cuenta las cosas de no analizar . Al principio intenté

<¡ADVERTENCIA! NO FUNCIONÓ>

du --inodes --files0-from=<(find . -maxdepth 1 -type f -print0) | awk '{sum+=int($1)}END{print sum}'

</ ¡ADVERTENCIA! NO FUNCIONÓ>

que funcionó si solo hubiera un nombre de archivo como

touch $'w\nlf.aa'

pero falló si hice un nombre de archivo como este

touch $'firstline\n3 and some other\n1\n2\texciting\n86stuff.jpg'

Finalmente se me ocurrió lo que estoy poniendo a continuación. Tenga en cuenta que estaba tratando de obtener un recuento de todos los archivos en el directorio (sin incluir ningún subdirectorio). Creo que, junto con las respuestas de @Mat y @Dan_Yard, además de tener al menos la mayoría de los requisitos establecidos por @mogsie (no estoy seguro de la memoria). Creo que la respuesta de @mogsie es correcta, pero siempre trato de evitar el análisis a lsmenos que sea una situación extremadamente específica.

awk -F"\0" '{print NF-1}' < <(find . -maxdepth 1 -type f -print0) | awk '{sum+=$1}END{print sum}'

Más legible:

awk -F"\0" '{print NF-1}' < \
  <(find . -maxdepth 1 -type f -print0) | \
    awk '{sum+=$1}END{print sum}'

Esto está haciendo una búsqueda específica para archivos, delimitando la salida con un carácter nulo (para evitar problemas con espacios y saltos de línea), luego contando el número de caracteres nulos. El número de archivos será uno menos que el número de caracteres nulos, ya que habrá un carácter nulo al final.

Para responder la pregunta del OP, hay dos casos a considerar

1) Búsqueda no recursiva:

awk -F"\0" '{print NF-1}' < \
  <(find . -maxdepth 1 -type f -name "log*" -print0) | \
    awk '{sum+=$1}END{print sum}'

2) Búsqueda recursiva. Tenga en cuenta que lo que hay dentro del -nameparámetro puede necesitar ser cambiado para un comportamiento ligeramente diferente (archivos ocultos, etc.).

awk -F"\0" '{print NF-1}' < \
  <(find . -type f -name "log*" -print0) | \
    awk '{sum+=$1}END{print sum}'

Si a alguien le gustaría comentar cómo se comparan estas respuestas con las que he mencionado en esta respuesta, por favor hágalo.

Tenga en cuenta que llegué a este proceso de pensamiento al obtener esta respuesta .

Esto es lo que siempre hago:

ls log * | awk 'END {print NR}'

ls -1 log* | wc -l

Lo que significa listar un archivo por línea y luego canalizarlo al comando de recuento de palabras con cambio de parámetro a líneas de recuento.

Para contar todo simplemente canalice ls a la línea de conteo de palabras:

ls | wc -l

Para contar con el patrón, canalice a grep primero:

ls | grep log | wc -l