Obtener nombres de todos los archivos de una carpeta con Ruby

Question

Deseo obtener todos los nombres de archivos de una carpeta usando Ruby.

Answer 1

También tiene la opción de acceso directo de

Dir["/path/to/search/*"] 

y si usted quiere encontrar todos los archivos de Ruby en cualquier carpeta o subcarpeta:

Dir["/path/to/search/**/*.rb"] 

Answer 2

Dir.entries(folder) 

ejemplo:

Dir.entries(".") 

Fuente: http://ruby-doc.org/core/classes/Dir.html#method-c-entries

Answer 3

Los siguientes fragmentos exactamente muestra el nombre de los archivos dentro de un directorio, subdirectorios que saltan y ".", ".." carpetas de puntos:

Dir.entries("your/folder").select {|f| !File.directory? f} 

Answer 4

para obtener todos los archivos (en sentido estricto sólo de archivos) de forma recursiva:

Dir.glob('path/**/*').select{ |e| File.file? e } 

(archivos File.file? rechazaría no regulares)

o cualquier cosa que no es un directorio:

Dir.glob('path/**/*').reject{ |e| File.directory? e } 

Solución Alternativa

Usando Find#find más de un método de búsqueda basado en patrones como Dir.glob es realmente mejor. Ver this answer to "One-liner to Recursively List Directories in Ruby?".

Answer 5

Personalmente, he encontrado este el más útil para recorrer más de los archivos en una carpeta, a futuro la seguridad:

Dir['/etc/path/*'].each do |file_name| 
    next if File.directory? file_name 
end 

Answer 6

Ésta es una solución para encontrar archivos en un directorio:

files = Dir["/work/myfolder/**/*.txt"] 

files.each do |file_name| 
    if !File.directory? file_name 
    puts file_name 
    File.open(file_name) do |file| 
     file.each_line do |line| 
     if line =~ /banco1/ 
      puts "Found: #{line}" 
     end 
     end 
    end 
    end 
end 

Answer 7

Mientras obtener todos los nombres de archivo en un directorio, este fragmento se puede usar para rechazar ambos directorios [., ..] y archivos ocultos que comienzan con .

files = Dir.entries("your/folder").reject {|f| File.directory?(f) || f[0].include?('.')} 

Answer 8

def get_path_content(dir) 
    queue = Queue.new 
    result = [] 
    queue << dir 
    until queue.empty? 
    current = queue.pop 
    Dir.entries(current).each { |file| 
     full_name = File.join(current, file) 
     if not (File.directory? full_name) 
     result << full_name 
     elsif file != '.' and file != '..' 
      queue << full_name 
     end 
    } 
    end 
    result 
end 

vuelve rutas relativas de archivos de directorio y todos los subdirectorios

Answer 9

Esto funciona para mí:

Si no desea que los archivos ocultos [1], utilizan Dir []:

# With a relative path, Dir[] will return relative paths 
# as `[ './myfile', ... ]` 
# 
Dir[ './*' ].select{ |f| File.file? f } 

# Want just the filename? 
# as: [ 'myfile', ... ] 
# 
Dir[ '../*' ].select{ |f| File.file? f }.map{ |f| File.basename f } 

# Turn them into absolute paths? 
# [ '/path/to/myfile', ... ] 
# 
Dir[ '../*' ].select{ |f| File.file? f }.map{ |f| File.absolute_path f } 

# With an absolute path, Dir[] will return absolute paths: 
# as: [ '/home/../home/test/myfile', ... ] 
# 
Dir[ '/home/../home/test/*' ].select{ |f| File.file? f } 

# Need the paths to be canonical? 
# as: [ '/home/test/myfile', ... ] 
# 
Dir[ '/home/../home/test/*' ].select{ |f| File.file? f }.map{ |f| File.expand_path f } 

Ahora, Dir.entries volverá archivos ocultos, y que no es necesario el aster comodín ix (simplemente puede pasar la variable con el nombre del directorio), pero devolverá el nombre base directamente, por lo que las funciones de File.xxx no funcionarán.

# In the current working dir: 
# 
Dir.entries('.').select{ |f| File.file? f } 

# In another directory, relative or otherwise, you need to transform the path 
# so it is either absolute, or relative to the current working dir to call File.xxx functions: 
# 
home = "/home/test" 
Dir.entries(home).select{ |f| File.file? File.join(home, f) } 

[1] .dotfile en UNIX, no sé acerca de Windows

Answer 10

Si desea obtener una serie de nombres de archivo incluyendo enlaces simbólicos, utilice

Dir.new('/path/to/dir').entries.reject { |f| File.directory? f } 

o incluso

Dir.new('/path/to/dir').reject { |f| File.directory? f } 

y si quieres ir sin enlaces simbólicos, utilice

Dir.new('/path/to/dir').select { |f| File.file? f } 

Como se muestra en otras respuestas, utilice Dir.glob('/path/to/dir/**/*') en lugar de Dir.new('/path/to/dir') si desea obtener todos los archivos de forma recursiva.

Answer 11

Dir.new('/home/user/foldername').each { |file| puts file } 

Answer 12

Esto es lo que funciona para mí:

Dir.entries(dir).select { |f| File.file?(File.join(dir, f)) } 

Dir.entries devuelve una matriz de cadenas. Luego, debemos proporcionar una ruta completa del archivo al File.file?, a menos que dir sea igual a nuestro directorio de trabajo actual. Es por eso que este File.join().

Answer 13

También es posible que desee utilizar Rake::FileList (siempre que tenga rake dependencia):

FileList.new('lib/*') do |file| 
    p file 
end 

De acuerdo con la API:

filelists son perezosos. Cuando se le presente una lista de patrones globales para posibles archivos que se incluirán en la lista de archivos, en lugar de buscar en el archivo estructuras para buscar los archivos, una Lista de archivos contiene el patrón para el último uso de .

https://docs.ruby-lang.org/en/2.1.0/Rake/FileList.html