One-liner per elencare in modo ricorsivo le directory in Ruby?



filesystems recursion (6)

Qual è il modo più veloce, più ottimizzato, one-liner per ottenere un array di directory (esclusi i file) in Ruby?

Che ne dici di includere i file?


Veloce una fodera

Solo directory

`find -type d`.split("\n")

Directory e file normali

`find -type d -or -type f`.split("\n")`

Puro bel rubino

require "pathname"

def rec_path(path, file= false)
  puts path
  path.children.collect do |child|
    if file and child.file?
      child
    elsif child.directory?
      rec_path(child, file) + [child]
    end
  end.select { |x| x }.flatten(1)
end

# only directories
rec_path(Pathname.new(dir), false)
# directories and normal files
rec_path(Pathname.new(dir), true)

Anche se non è una soluzione a una linea, penso che questo sia il modo migliore per farlo usando le chiamate ruby.

Prima cancella tutti i file in modo ricorsivo
Secondo cancellare tutte le directory vuote

Dir.glob("./logs/**/*").each { |file| File.delete(file) if File.file? file }
Dir.glob("./logs/**/*/").each { |directory| Dir.delete(directory) }

Credo che nessuna delle soluzioni qui trattino le directory nascoste (es. '.test'):

require 'find'
Find.find('.') { |e| puts e if File.directory?(e) }

Ecco un esempio che combina la scoperta dinamica di una directory di progetto Rails con Dir.glob:

dir = Dir.glob(Rails.root.join('app', 'assets', 'stylesheets', '*'))

Per l'elenco delle directory prova

Dir['**/']

L'elenco dei file è più difficile, perché nella directory Unix c'è anche un file, quindi è necessario testare il tipo o rimuovere le voci dall'elenco restituito che è padre di altre voci.

Dir['**/*'].reject {|fn| File.directory?(fn) }

E per l'elenco di tutti i file e le directory semplicemente

Dir['**/*']

Dir.glob("**/*/") # for directories
Dir.glob("**/*") # for all files

Invece di Dir.glob(foo) puoi anche scrivere Dir[foo] (tuttavia Dir.glob può anche prendere un blocco, nel qual caso produrrà ogni percorso invece di creare un array).

Ruby Glob Docs





recursion