这就是对我有效的方法：

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

Dir.entries返回字符串数组。然后，我们必须提供文件到File.file?的完整路径，除非dir等于我们当前的工作目录。这就是为什么这个File.join()。

如果您创建的目录带有空格：

mkdir "a b"
touch "a b/c"

您不需要转义目录名，它将自动转义：

p Dir["a b/*"] # => ["a b/c"]

在IRB上下文中，您可以使用以下命令获取当前目录中的文件：

file_names = `ls`.split("n")

您也可以在其他目录上执行此操作：

file_names = `ls ~/Documents`.split("n")

在加载操作目录中的所有文件名时，您可以使用

Dir.glob("*)

这将返回应用程序在其中运行的上下文中的所有文件(注意，对于Rails，这是应用程序的顶级目录)

您可以在https://ruby-doc.org/core-2.7.1/Dir.html#method-c-glob中找到其他匹配和递归搜索

除了本文中的建议之外，我还想指出，如果您还需要返回点文件(.gitignore等)，那么在使用Dir.lobb时，您需要包括一个标志：Dir.glob("/path/to/dir/*", File::FNM_DOTMATCH)默认情况下，Dir.entry包括点文件，以及当前的父目录。

对于任何感兴趣的人，我很好奇这里的答案在执行时间上如何比较，这里是针对深度嵌套层次结构的结果。前三个结果是非递归的：

user     system      total        real
Dir[*]: (34900 files stepped over 100 iterations)
  0.110729   0.139060   0.249789 (  0.249961)
Dir.glob(*): (34900 files stepped over 100 iterations)
  0.112104   0.142498   0.254602 (  0.254902)
Dir.entries(): (35600 files stepped over 100 iterations)
  0.142441   0.149306   0.291747 (  0.291998)
Dir[**/*]: (2211600 files stepped over 100 iterations)
  9.399860  15.802976  25.202836 ( 25.250166)
Dir.glob(**/*): (2211600 files stepped over 100 iterations)
  9.335318  15.657782  24.993100 ( 25.006243)
Dir.entries() recursive walk: (2705500 files stepped over 100 iterations)
 14.653018  18.602017  33.255035 ( 33.268056)
Dir.glob(**/*, File::FNM_DOTMATCH): (2705500 files stepped over 100 iterations)
 12.178823  19.577409  31.756232 ( 31.767093)

这些是使用以下基准测试脚本生成的：

require 'benchmark'
base_dir = "/path/to/dir/"
n = 100
Benchmark.bm do |x|
  x.report("Dir[*]:") do
    i = 0
    n.times do
      i = i + Dir["#{base_dir}*"].select {|f| !File.directory? f}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir.glob(*):") do
    i = 0
    n.times do
      i = i + Dir.glob("#{base_dir}/*").select {|f| !File.directory? f}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir.entries():") do
    i = 0
    n.times do
      i = i + Dir.entries(base_dir).select {|f| !File.directory? File.join(base_dir, f)}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir[**/*]:") do
    i = 0
    n.times do
      i = i + Dir["#{base_dir}**/*"].select {|f| !File.directory? f}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir.glob(**/*):") do
    i = 0
    n.times do
      i = i + Dir.glob("#{base_dir}**/*").select {|f| !File.directory? f}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir.entries() recursive walk:") do
    i = 0
    n.times do
      def walk_dir(dir, result)
        Dir.entries(dir).each do |file|
          next if file == ".." || file == "."

          path = File.join(dir, file)
          if Dir.exist?(path)
            walk_dir(path, result)
          else
            result << file
          end
        end
      end
      result = Array.new
      walk_dir(base_dir, result)
      i = i + result.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
  x.report("Dir.glob(**/*, File::FNM_DOTMATCH):") do
    i = 0
    n.times do
      i = i + Dir.glob("#{base_dir}**/*", File::FNM_DOTMATCH).select {|f| !File.directory? f}.length
    end
    puts " (#{i} files stepped over #{n} iterations)"
  end
end

文件数的差异是由于默认情况下Dir.entries包含隐藏文件。在这种情况下，Dir.entries最终花费的时间稍长，因为需要重新构建文件的绝对路径以确定文件是否为目录，但即使没有绝对路径，Dir.entries花费的时间也始终比递归情况下的其他选项长。这一切都是在OSX上使用Ruby 2.5.1。

如果想要获取文件名数组**，包括符号链接**，请使用

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

甚至是

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

如果您想不使用符号链接，请使用

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

如其他答案所示，如果希望递归获取所有文件，请使用Dir.glob('/path/to/dir/**/*')而不是Dir.new('/path/to/dir')。

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

从目录和所有子目录返回文件的相对路径

一种简单的方法可能是：

dir = './' # desired directory
files = Dir.glob(File.join(dir, '**', '*')).select{|file| File.file?(file)}

files.each do |f|
    puts f
end

您可能还希望使用Rake::FileList(假设您具有rake依赖项)：

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

根据该接口：

文件列表是懒惰的。当给定要包括在文件列表中的可能文件的全局模式的列表时，FileList保存该模式以供以后使用，而不是搜索文件结构来查找文件。

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

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

您还可以使用以下快捷方式选项

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

如果您想要在任何文件夹或子文件夹中查找所有Ruby文件：

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

在获取目录中的所有文件名时，此代码片段可用于拒绝目录[.，..]和以.开头的隐藏文件

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

此代码仅返回带扩展名的文件名(不带全局路径)

Dir.children("/path/to/search/")

=>[文件_1.rb，文件_2.html，文件_3.js]

这是一个在目录中查找文件的解决方案：

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

就我个人而言，我发现这是循环浏览文件夹中的文件最有用的，具有前瞻性的安全性：

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