Supongamos que tiene este árbol de directorios:

 $ tree /tmp/test /tmp/test ├── dir_a │  ├── dir a\012file with CR │  ├── dir a file with spaces │  └── sub a directory │  └── with a file in it ├── dir_b │  ├── dir b\012file with CR │  └── dir b file with spaces ├── dir_c │  ├── \012 │  ├── dir c\012file with CR and * │  └── dir c file with space and * ├── file_1 ├── file_2 └── file_3 4 directories, 11 files

( AQUÍ hay un script para producir eso. El \012 es un \n para hacer que el scripting sea más desafiante. También hay un archivo .hidden ).

Parece que hay diferencias sustanciales de implementación para el globbing recursivo entre Bash 5.1, zsh 5.8, Python pathlib 5.10, Python glob module con recursividad habilitada y Ruby 3.0.

Esto también supone shopt -s globstar con Bash y cwd es el directorio de trabajo actual y está configurado en /tmp/test para este ejemplo.

Esto es lo que hace Bash :

1. * Solo los archivos, directorios en cwd . es decir, 3 directorios, 3 archivos
2. ** Todos los archivos y directorios en un árbol rooteados por cwd pero no por cwd -- 4 y 11 archivos
3. **/ Solo directorios en el árbol rooteados por cwd pero sin incluir cwd -- 4 y 0
4. */** Todos los directorios en cwd y todos los archivos EXCEPTO los archivos en cwd -- 4 y 8 archivos ya que la recursividad solo comienza en los subdirectorios
5. **/* Igual que ** -- 4 y 11
6. **/*/ Solo directorios en árbol -- 4 y 0 archivos
7. */**/* Solo directorios por debajo del segundo nivel y archivos por debajo del primero -- 1 y 8

Si ejecuto este script en Bash 5.1 y zsh 5.8, los resultados son diferentes:

 # no shebang - execute with appropriate shell # BTW - this is how you count the result since ls -1 ** | wc -l is incorrect # if the file name has \n in it. cd /tmp/test || exit [ -n "$BASH_VERSION" ] && shopt -s globstar [ -n "$ZSH_VERSION" ] && setopt GLOBSTARSHORT # see table dc=0; fc=0 for f in **; do # the glob there is the only thing being changed [ -d "$f" ] && (( dc++ )) [ -f "$f" ] && (( fc++ )) printf "%d, %d \"%s\"\n" $dc $fc "$f" done printf "%d directories, %d files" $dc $fc

Resultados (expresados como X,Y para directorios X y archivos Y para ese directorio de ejemplo usando el glob al que se hace referencia. Al inspeccionar o al ejecutar estos scripts, puede ver lo que visita el glob):

‡ Número de directorio de 5 significa que también se devuelve el cwd.

† Python pathlib agrega archivos ocultos; los otros no.

Escritura de Python:

 from pathlib import Path import glob tg="**/*" # change this glob for testing fc=dc=0 for fn in Path("/tmp/test").glob(tg): print(fn) if fn.is_file(): fc=fc+1 elif fn.is_dir(): dc=dc+1 print(f"pathlib {dc} directories, {fc} files\n\n") fc=dc=0 for sfn in glob.glob(f"/tmp/test/{tg}", recursive=True): print(sfn) if Path(sfn).is_file(): fc=fc+1 elif Path(sfn).is_dir(): dc=dc+1 print(f"glob.glob {dc} directories, {fc} files")

Guión rubí:

 dc=fc=0 Dir.glob("/tmp/test/**/"). each{ |f| pf; File.directory?(f) ? dc=dc+1 : (fc=fc+1 if File.file?(f)) } puts "#{dc} directories, #{fc} files"

Entonces, los únicos globos en los que todos están de acuerdo (aparte del archivo oculto) son * , **/* y */**/*

Documentación:

1. Bash: dos '*' adyacentes utilizados como un solo patrón coincidirán con todos los archivos y cero o más directorios y subdirectorios.

2. zsh: a) setopt GLOBSTARSHORT establece **.c para que sea equivalente a **/*.c cyb) '**/' es equivalente a '(*/)#'; tenga en cuenta que esto, por lo tanto, coincide con los archivos en el directorio actual, así como con los subdirectorios.

3. pathlib: ** que significa "este directorio y todos los subdirectorios, recursivamente"

4. python glob: si recursivo es verdadero, el patrón ** coincidirá con cualquier archivo y cero o más directorios, subdirectorios y enlaces simbólicos a directorios. Si el patrón va seguido de un os.sep o un os.altsep, los archivos no coincidirán.

5. ruby: ** Coincide con los directorios recursivamente si va seguido de /. Si este segmento de la ruta contiene otros caracteres, es el mismo que el habitual *.

Preguntas:

1. ¿Son correctas mis suposiciones sobre lo que se supone que debe hacer cada globo?

2. ¿Por qué Bash es el único que es recursivo con ** ? (si agrega setopt GLOBSTARSHORT a zsh , el resultado es similar a **

3. ¿Es razonable decirse a sí mismo que **/* funciona para todos