Recuento recursivo de archivos en un directorio de Linux

¿Cómo puedo contar recursivamente archivos en un directorio de Linux?

Encontré esto:

find DIR_NAME -type f ¦ wc -l

Pero cuando ejecuto esto, devuelve el siguiente error.

find: las rutas deben preceder a la expresión: ¦

Esto debería funcionar:

find DIR_NAME -type f | wc -l

Explicación:

• -type f para incluir solo archivos.
• |( y no¦ ) redirige findla salida estándar del wccomando a la entrada estándar del comando.
• wc(abreviatura de recuento de palabras) cuenta líneas nuevas, palabras y bytes en su entrada ( documentos ).
• -l para contar solo nuevas líneas.

Notas:

• Reemplace DIR_NAMEcon .para ejecutar el comando en la carpeta actual.
• También puede eliminar los -type fdirectorios para incluir (y enlaces simbólicos) en el recuento.
• Es posible que este comando cuente en exceso si los nombres de archivo pueden contener caracteres de nueva línea.

Explicación de por qué su ejemplo no funciona:

En el comando que mostró, no utiliza el "Pipe" ( |) para conectar dos comandos, sino la barra rota ( ¦) que el shell no reconoce como un comando o algo similar. Es por eso que recibes ese mensaje de error.

Para el directorio actual:

find -type f | wc -l

Si desea un desglose de cuántos archivos hay en cada directorio bajo su directorio actual:

for i in */ .*/ ; do 
    echo -n $i": " ; 
    (find "$i" -type f | wc -l) ; 
done

Eso puede ir todo en una línea, por supuesto. El paréntesis aclara qué salida wc -lse supone que está mirando ( find $i -type fen este caso).

Puedes usar

$ tree

después de instalar el paquete del árbol con

$ sudo apt-get install tree

(en una máquina Debian / Mint / Ubuntu Linux).

El comando muestra no solo la cuenta de los archivos, sino también la cuenta de los directorios, por separado. La opción -L se puede usar para especificar el nivel máximo de visualización (que, por defecto, es la profundidad máxima del árbol de directorios).

Los archivos ocultos también se pueden incluir al proporcionar la -aopción.

En mi computadora, rsynces un poco más rápido que find | wc -len la respuesta aceptada:

$ rsync --stats --dry-run -ax /path/to/dir /tmp

Number of files: 173076
Number of files transferred: 150481
Total file size: 8414946241 bytes
Total transferred file size: 8414932602 bytes

La segunda línea tiene el número de archivos, 150,481 en el ejemplo anterior. Como beneficio adicional, también obtiene el tamaño total (en bytes).

Observaciones:

• la primera línea es un recuento de archivos, directorios, enlaces simbólicos, etc., todos juntos, por eso es más grande que la segunda línea.
• ¡La opción --dry-run(o -npara abreviar) es importante para no transferir realmente los archivos!
• Utilicé la -xopción para "no cruzar los límites del sistema de archivos", lo que significa que si lo ejecuta /y tiene discos duros externos conectados, solo contará los archivos en la partición raíz.

Dado que los nombres de archivo en UNIX pueden contener nuevas líneas (sí, nuevas líneas), wc -lpodría contar demasiados archivos. Imprimiría un punto para cada archivo y luego contaría los puntos:

find DIR_NAME -type f -printf "." | wc -c

Combinando varias de las respuestas aquí juntas, la solución más útil parece ser:

find . -maxdepth 1 -type d -print0 |
xargs -0 -I {} sh -c 'echo -e $(find "{}" -printf "\n" | wc -l) "{}"' |
sort -n

Puede manejar cosas extrañas como nombres de archivos que incluyen espacios entre paréntesis e incluso nuevas líneas. También ordena la salida por el número de archivos.

También puede aumentar el número -maxdepthpara que también se cuenten los subdirectorios. Tenga en cuenta que esto puede llevar mucho tiempo, especialmente si tiene una estructura de directorio altamente anidada en combinación con un -maxdepthnúmero alto .

Si desea saber cuántos archivos y subdirectorios existen desde el directorio de trabajo actual, puede usar este one-liner

find . -maxdepth 1 -type d -print0 | xargs -0 -I {} sh -c 'echo -e $(find {} | wc -l) {}' | sort -n

Esto funcionará en sabor GNU, y solo omite el -e del comando echo para BSD Linux (por ejemplo, OSX).

Si desea evitar casos de error, no permita wc -lver archivos con líneas nuevas (que contará como 2+ archivos)

Por ejemplo, considere un caso en el que tenemos un solo archivo con un solo carácter EOL

> mkdir emptydir && cd emptydir
> touch $'file with EOL(\n) character in it'
> find -type f
./file with EOL(?) character in it
> find -type f | wc -l
2

Dado que al menos gnu wcno parece tener una opción para leer / contar una lista terminada en nulo (excepto de un archivo), la solución más sencilla sería no pasarle nombres de archivo, sino una salida estática cada vez que se encuentra un archivo, por ejemplo en el mismo directorio que el anterior

> find -type f -exec printf '\n' \; | wc -l
1

O si tu lo findsoporta

> find -type f -printf '\n' | wc -l
1 

Puedes usar el comando ncdu. Contará recursivamente cuántos archivos contiene un directorio de Linux. Aquí hay un ejemplo de salida:

Tiene una barra de progreso, que es conveniente si tiene muchos archivos:

Para instalarlo en Ubuntu:

sudo apt-get install -y ncdu

Punto de referencia: utilicé https://archive.org/details/cv_corpus_v1.tar (380390 archivos, 11 GB) como la carpeta donde se tiene que contar la cantidad de archivos.

• find . -type f | wc -l: alrededor de 1m20s para completar
• ncdu: alrededor de 1m20s para completar

tree $DIR_PATH | tail -1

Salida de muestra:

5309 directorios, 2122 archivos

Para determinar cuántos archivos hay en el directorio actual, ingrese ls -1 | wc -l. Esto wchace un recuento del número de líneas (-l)en la salida de ls -1. No cuenta con archivos de puntos. Tenga en cuenta que ls -l(que es una "L" en lugar de un "1" como en los ejemplos anteriores) que utilicé en versiones anteriores de este CÓMO realmente le dará un recuento de archivos uno mayor que el recuento real. Gracias a Kam Nejad por este punto.

Si desea contar solo archivos y NO incluir enlaces simbólicos (solo un ejemplo de lo que podría hacer), puede usar ls -l | grep -v ^l | wc -l(esta vez es una "L", no un "1", queremos una lista "larga" aquí) . grepbusca cualquier línea que comience con "l" (que indica un enlace) y descarta esa línea (-v).

Velocidad relativa: "ls -1 / usr / bin / | wc -l" tarda aproximadamente 1,03 segundos en un 486SX25 descargado (/ usr / bin / en esta máquina tiene 355 archivos). " ls -l /usr/bin/ | grep -v ^l | wc -l" toma aproximadamente 1.19 segundos.

Fuente: http://www.tldp.org/HOWTO/Bash-Prompt-HOWTO/x700.html

Si lo que necesita es contar un tipo de archivo específico de forma recursiva , puede hacer:

find YOUR_PATH -name '*.html' -type f | wc -l 

-l es solo para mostrar el número de líneas en la salida.

Con bash:

Cree una matriz de entradas con () y obtenga el recuento con #.

FILES=(./*); echo ${#FILES[@]}

Ok, eso no cuenta recursivamente los archivos, pero primero quería mostrar la opción simple. Un caso de uso común podría ser crear copias de respaldo de un archivo. Esto creará logfile.1, logfile.2, logfile.3 etc.

CNT=(./logfile*); mv logfile logfile.${#CNT[@]}

Conteo recursivo con bash 4+ globstarhabilitado (como lo menciona @tripleee)

FILES=(**/*); echo ${#FILES[@]}

Para obtener el recuento de archivos de forma recursiva, todavía podemos usar find de la misma manera.

FILES=(`find . -type f`); echo ${#FILES[@]}

He escrito ffcnt para acelerar el recuento recursivo de archivos en circunstancias específicas: discos rotativos y sistemas de archivos que admiten mapeo de extensión.

Puede ser un orden de magnitud más rápido lso findbasado en enfoques, pero YMMV.

Para directorios con espacios en el nombre ... (basado en varias respuestas anteriores): imprima recursivamente el nombre del directorio con el número de archivos dentro de:

find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done

Ejemplo (formateado para facilitar la lectura):

pwd
  /mnt/Vancouver/Programming/scripts/claws/corpus

ls -l
  total 8
  drwxr-xr-x 2 victoria victoria 4096 Mar 28 15:02 'Catabolism - Autophagy; Phagosomes; Mitophagy'
  drwxr-xr-x 3 victoria victoria 4096 Mar 29 16:04 'Catabolism - Lysosomes'

ls 'Catabolism - Autophagy; Phagosomes; Mitophagy'/ | wc -l
  138

## 2 dir (one with 28 files; other with 1 file):
ls 'Catabolism - Lysosomes'/ | wc -l
  29

La estructura del directorio se visualiza mejor usando tree:

tree -L 3 -F .
  .
  ├── Catabolism - Autophagy; Phagosomes; Mitophagy/
  │   ├── 1
  │   ├── 10
  │   ├── [ ... SNIP! (138 files, total) ... ]
  │   ├── 98
  │   └── 99
  └── Catabolism - Lysosomes/
      ├── 1
      ├── 10
      ├── [ ... SNIP! (28 files, total) ... ]
      ├── 8
      ├── 9
      └── aaa/
          └── bbb

  3 directories, 167 files

man find | grep mindep
  -mindepth levels
    Do not apply any tests or actions at levels less than levels
    (a non-negative integer).  -mindepth 1 means process all files
    except the starting-points.

ls -p | grep -v /(utilizado a continuación) es de la respuesta 2 en /unix/48492/list-only-regular-files-but-not-directories-in-current-directory

find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done
./Catabolism - Autophagy; Phagosomes; Mitophagy: 138
./Catabolism - Lysosomes: 28
./Catabolism - Lysosomes/aaa: 1

Aplicación: quiero encontrar el número máximo de archivos entre varios cientos de directorios (todos de profundidad = 1) [salida a continuación nuevamente formateada para facilitar la lectura]:

date; pwd
    Fri Mar 29 20:08:08 PDT 2019
    /home/victoria/Mail/2_RESEARCH - NEWS

time find . -mindepth 1 -type d -print0 | while IFS= read -r -d '' i ; do echo -n $i": " ; ls -p "$i" | grep -v / | wc -l ; done > ../../aaa
    0:00.03

[victoria@victoria 2_RESEARCH - NEWS]$ head -n5 ../../aaa
    ./RNA - Exosomes: 26
    ./Cellular Signaling - Receptors: 213
    ./Catabolism - Autophagy; Phagosomes; Mitophagy: 138
    ./Stress - Physiological, Cellular - General: 261
    ./Ancient DNA; Ancient Protein: 34

[victoria@victoria 2_RESEARCH - NEWS]$ sed -r 's/(^.*): ([0-9]{1,8}$)/\2: \1/g' ../../aaa | sort -V | (head; echo ''; tail)

    0: ./Genomics - Gene Drive
    1: ./Causality; Causal Relationships
    1: ./Cloning
    1: ./GenMAPP 2
    1: ./Pathway Interaction Database
    1: ./Wasps
    2: ./Cellular Signaling - Ras-MAPK Pathway
    2: ./Cell Death - Ferroptosis
    2: ./Diet - Apples
    2: ./Environment - Waste Management

    988: ./Genomics - PPM (Personalized & Precision Medicine)
    1113: ./Microbes - Pathogens, Parasites
    1418: ./Health - Female
    1420: ./Immunity, Inflammation - General
    1522: ./Science, Research - Miscellaneous
    1797: ./Genomics
    1910: ./Neuroscience, Neurobiology
    2740: ./Genomics - Functional
    3943: ./Cancer
    4375: ./Health - Disease 

sort -VEs un tipo natural. ... Entonces, mi número máximo de archivos en cualquiera de esos directorios (Claws Mail) es 4375 archivos. Si dejo el pad ( https://stackoverflow.com/a/55409116/1904943 ) esos nombres de archivo, todos se nombran numéricamente, comenzando con 1, en cada directorio, y se rellenan con 5 dígitos en total, debería estar bien .

Apéndice

Encuentre el número total de archivos, subdirectorios en un directorio.

$ date; pwd
Tue 14 May 2019 04:08:31 PM PDT
/home/victoria/Mail/2_RESEARCH - NEWS

$ ls | head; echo; ls | tail
Acoustics
Ageing
Ageing - Calorie (Dietary) Restriction
Ageing - Senescence
Agriculture, Aquaculture, Fisheries
Ancient DNA; Ancient Protein
Anthropology, Archaeology
Ants
Archaeology
ARO-Relevant Literature, News

Transcriptome - CAGE
Transcriptome - FISSEQ
Transcriptome - RNA-seq
Translational Science, Medicine
Transposons
USACEHR-Relevant Literature
Vaccines
Vision, Eyes, Sight
Wasps
Women in Science, Medicine

$ find . -type f | wc -l
70214    ## files

$ find . -type d | wc -l
417      ## subdirectories

Hay muchas respuestas correctas aquí. ¡Aquí está otro!

find . -type f | sort | uniq -w 10 -c

dónde .está la carpeta para buscar y 10es el número de caracteres para agrupar el directorio.

encontrar -tipo f | wc -l

O (si el directorio es el directorio actual)

encontrar . -tipo f | wc -l

Esto funcionará completamente bien. Corto simple Si desea contar la cantidad de archivos presentes en una carpeta.

ls | wc -l

Este enfoque alternativo con filtrado para formato cuenta todos los módulos de kernel de grub disponibles:

ls -l /boot/grub/*.mod | wc -l

ls -l | grep -e -x -e -dr | wc -l 

1. Larga lista
2. filtrar archivos y directorios
3. contar la línea filtrada sin