Dir.entries(folder)

Przykład:

Dir.entries(".")

Źródło: http://ruby-doc.org/core/classes/Dir.html#method-c-entries

Poniższe urywki dokładnie pokazują nazwę plików wewnątrz katalogu, pomijając podkatalogi i ".", ".." kropkowane foldery:

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

Aby uzyskać wszystkie pliki (tylko pliki ściśle) rekurencyjnie:

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

Lub cokolwiek, co nie jest katalogiem (File.file? odrzuciłoby pliki niestandardowe):

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

Alternatywne Rozwiązanie

Za pomocą Find#find metoda wyszukiwania oparta na wzorcach, taka jak Dir.glob, jest rzeczywiście lepsza. Zobacz tę odpowiedź na "Jednolinijkowy do rekurencyjnej listy katalogów w Ruby?".

Osobiście uważam, że jest to najbardziej przydatne do zapętlania plików w folderze, patrząc w przyszłość bezpieczeństwa:

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

To działa dla mnie:

Jeśli nie chcesz ukrytych plików[1], Użyj 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 }

Teraz, Reż.wpisy zwrócą ukryte pliki, a ty nie potrzebujesz znacznika Asterix (możesz po prostu przekazać zmienną z nazwą katalogu), ale zwróci nazwę bazową bezpośrednio, więc plik.funkcje xxx nie działają.

# 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 na Unixie, Nie wiem o Windows

Jest to rozwiązanie do znajdowania plików w katalogu:

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

Podczas pobierania wszystkich nazw plików w katalogu, ten fragment może być użyty do odrzucenia obu katalogów [., ..] oraz ukryte pliki zaczynające się od .

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

W Rubim 2.5 możesz teraz używać Dir.children. Pobiera nazwy plików jako tablicę z wyjątkiem""."i ".."

Przykład:

Dir.children("testdir")   #=> ["config.h", "main.rb"]

Http://ruby-doc.org/core-2.5.0/Dir.html#method-c-children

To jest to, co działa dla mnie:

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

Dir.entries zwraca tablicę łańcuchów. Następnie musimy podać pełną ścieżkę pliku do File.file?, chyba że {[3] } jest równe naszemu bieżącemu katalogowi roboczemu. Dlatego to File.join().

Jeśli chcesz uzyskać tablicę nazw plików wraz z dowiązaniami symbolicznymi , użyj

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

Lub nawet

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

I jeśli chcesz przejść bez dowiązań symbolicznych , użyj

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

Jak pokazano w innych odpowiedziach, użyj Dir.glob('/path/to/dir/**/*') zamiast Dir.new('/path/to/dir'), Jeśli chcesz odzyskać wszystkie pliki rekurencyjnie.

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

Zwraca względne ścieżki pliku z katalogu i wszystkich podkatalogów

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

Możesz również użyć Rake::FileList (pod warunkiem, że posiadasz rake zależność):

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

Zgodnie z API:

Fileliści są leniwi. Gdy podano listę szablonów glob dla możliwych pliki, które mają być umieszczone na liście plików, zamiast przeszukiwać plik struktury, aby znaleźć pliki, Lista plików zawiera wzorzec dla tych ostatnich użyj.

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