在 Ruby 中读取文件的常用方法有哪些？
例如，这是一种方法：
fileObj = File.new($fileName, "r")
while (line = fileObj.gets)
puts(line)
end
fileObj.close
我知道 Ruby 非常灵活。每种方法的优缺点是什么？
【问题讨论】：
如果文件不太长，最简单的方法是：
puts File.read(file_name)
确实，IO.read 或File.read 会自动关闭文件，因此无需将File.open 与块一起使用。
【讨论】：
IO.read 或 File.read 也会自动关闭文件，尽管您的措辞听起来好像没有。
File.open("my/file/path", "r") do |f|
f.each_line do |line|
puts line
end
end
# File is closed automatically at end of block
也可以在如上之后显式关闭文件（将块传递给open 为您关闭它）：
f = File.open("my/file/path", "r")
f.each_line do |line|
puts line
end
f.close
【讨论】：
foreach 而不是open 并省去each_line 块。
f.each { |line| ... } 和 f.each_line { |line| ... } 似乎具有相同的行为（至少在 Ruby 2.0.0 中）。
提防“slurping”文件。那是您一次将整个文件读入内存的时候。
问题在于它不能很好地扩展。您可能正在使用大小合理的文件开发代码，然后将其投入生产，突然发现您正在尝试读取以千兆字节为单位的文件，并且您的主机在尝试读取和分配内存时冻结。
逐行 I/O 速度非常快，而且几乎总是和 slurping 一样有效。实际上速度快得惊人。
我喜欢用：
IO.foreach("testfile") {|x| print "GOT ", x }
或
File.foreach('testfile') {|x| print "GOT", x }
文件继承自 IO，foreach 在 IO 中，可以任意使用。
我有一些基准测试显示尝试通过read 与“Why is "slurping" a file not a good practice?”处的逐行 I/O 读取大文件的影响。
【讨论】：
您可以一次读取所有文件：
content = File.readlines 'file.txt'
content.each_with_index{|line, i| puts "#{i+1}: #{line}"}
当文件很大或可能很大时，通常最好逐行处理：
File.foreach( 'file.txt' ) do |line|
puts line
end
有时您希望访问文件句柄或自己控制读取：
File.open( 'file.txt' ) do |f|
loop do
break if not line = f.gets
puts "#{f.lineno}: #{line}"
end
end
如果是二进制文件，您可以指定零分隔符和块大小，如下所示：
File.open('file.bin', 'rb') do |f|
loop do
break if not buf = f.gets(nil, 80)
puts buf.unpack('H*')
end
end
最后，您可以在没有块的情况下执行此操作，例如同时处理多个文件时。在这种情况下，必须明确关闭文件（根据@antinome 的评论进行改进）：
begin
f = File.open 'file.txt'
while line = f.gets
puts line
end
ensure
f.close
end
【讨论】：
for_each。请改用foreach。
while 而不是loop 并使用ensure 来确保即使引发异常也能关闭文件。像这样（用换行符替换分号）：begin; f = File.open('testfile'); while line = f.gets; puts line; end; ensure; f.close; end.
【讨论】：
read 或任何变体一样，这会将整个文件拉入内存，如果文件大于可用内存，则可能会导致严重问题。另外，由于它是一个数组，Ruby 必须创建数组，这也进一步减慢了进程。
file_content = File.read('filename with extension');
puts file_content;
【讨论】：
我通常这样做：
open(path_in_string, &:read)
这会将整个文本作为字符串对象提供给您。它仅适用于 Ruby 1.9。
【讨论】：
从 your_file.log 或 .txt 返回最后 n 行
path = File.join(Rails.root, 'your_folder','your_file.log')
last_100_lines = `tail -n 100 #{path}`
【讨论】：
一种更有效的方式是流式传输，它要求操作系统的内核打开一个文件，然后一点一点地从中读取字节。在 Ruby 中每行读取文件时，一次从文件中获取 512 个字节的数据，然后分成“行”。
通过缓冲文件的内容，减少了 I/O 调用的数量，同时将文件划分为逻辑块。
例子：
将此类作为服务对象添加到您的应用中：
class MyIO
def initialize(filename)
fd = IO.sysopen(filename)
@io = IO.new(fd)
@buffer = ""
end
def each(&block)
@buffer << @io.sysread(512) until @buffer.include?($/)
line, @buffer = @buffer.split($/, 2)
block.call(line)
each(&block)
rescue EOFError
@io.close
end
end
调用它并传递:each 方法一个块：
filename = './somewhere/large-file-4gb.txt'
MyIO.new(filename).each{|x| puts x }
在这篇详细的帖子中阅读它：
【讨论】：
如果文件很小（slurping）：
puts File.read("filename.txt")
如果文件很大（流式传输）：
File.foreach("filename.txt") { |line| puts line }
【讨论】：
content = `cat file`
我认为这种方法是最“不常见”的一种。也许这有点棘手，但如果安装了cat，它就可以工作。
【讨论】：
content = File.read(filename)