Ruby 的文件操作_不断总结

 

 

一、用文件和目录工作
当我们说"文件"时，我们通常是指一个磁盘文件，尽管不总是这样。在Ruby中我们通常将文件做为一个抽象的概念，就像其它程序语言那样。当我们说"目录"时，我们是指通常的Winows或Unix的目录。
File类与它继承的IO类很接近。Dir类就不这样，但我们将文件和目录放在一起讨论，是因为它们还是在概念上相近的。


1、打开与关闭文件

类方法File.new，它是File对象的一个实例，将它打开文件。第一个参数自然是文件名。
可选的第二个参数被称为模式字符串，它告诉如何打开文件(用于读，写或其它)。模式字符串不做任何事情，它只是个许可。缺省值"r"用于读。这儿是个例子：
file1 = File.new("one")
# Open for reading
file2 = File.new("two", "w")
# Open for writing
new的另一种形式接受三个参数。在这种情况，第二个参数指出文件的原始许可(通常是八进制常量)，第三个参数是一组Ored标志。标志是个常量如File:CREAT(当打开时，如果文件不存在则创建它)和File:RDONLY(以只读方式打开文件)。这种形式很少使用。这儿是个例子：
file = File.new("three", 0755, File::CREAT|File::WRONLY)
出于对操作系统或运行时环境的礼貌，总是要关闭你打开的文件。在用于写而打开文件情况下，更应如此才能避免丢失数据。不出意外，close方法用于做到点：
out = File.new("captains.log", "w")
# 必须的步骤...
out.close
这儿是open方法，它简单形式内，它不过是new的同义字，像这样：
trans = File.open("transactions","w")
但是，open可以接受块；这个形式更有趣。当指定块时，打开的文件会被做为参数传递给块。在块的作用域内文件一直保持打开状态，在退出块时自动关闭。这儿是个例子：
File.open("somefile","w") do |file|
file.puts "Line 1"
file.puts "Line 2"
file.puts "Third and final line"
end
# The file is now closed
当我们结束对文件的操作时，很明显这是关闭文件的优雅方式。此外，管理文件的代码在视觉上是个单元。


2、更新文件

假设我们想打开一个文件用于读和写。当我们打开文件时，只简单地添加个加(+)符号到文件模式内就可以了。这儿是个例子：
f1 = File.new("file1", "r+")
# Read/write, starting at beginning of file.
f2 = File.new("file2", "w+")
# Read/write; truncate existing file or create a new one.
f3 = File.new("file3", "a+")
# Read/write; start at end of existing file or create a
# new one.


3、追加文件

假设我们想追加信息到已存在的文件中。很简单只要我们在打开文件时，使用"a"文件模式就可以了。这儿是个例子：
logfile = File.open("captains_log", "a")
# Add a line at the end, then close.
logfile.puts "Stardate 47824.1: Our show has been canceled."
logfile.close


4、随机访问文件

如果你想随机地而不是顺序地读文件，你可以使用seek方法，它的File从IO继承。通常使用它来搜索指定的字节位置。这个位置与文件的开始位置相关，开始位置的第一个字节是数字0。这儿个例子：
# myfile contains only: abcdefghi
file = File.new("myfile")
file.seek(5)
str = file.gets
# "fghi"
如果你能确定每行的长度固定，你可以搜索指定行，像这样：
# 假设每行有20 bytes。则N 行开始字节是 (N-1)*20
file = File.new("fixedlines")
file.seek(5*20)
# 第六行
# Elegance is left as an exercise.
如果你想做相对查寻，你可以使用第二个参数。常量IO::SEEK_CUR将假设相对于当位置的偏移位置(它可以是负数)。这儿是个例子：
file = File.new("somefile")
file.seek(55)
# Position is 55
file.seek(-22, IO::SEEK_CUR)
# Position is 33
file.seek(47, IO::SEEK_CUR)
# Position is 80
你也可从文件的结尾处开始搜索。只需要个负数的偏移量：
file.seek(-20, IO::SEEK_END)
# twenty bytes from eof
还有第三个常量，IO::SEEK_SET，但它是缺省值(搜索相对于文件的开始位置)。
方法tell将报告文件的位置(pos是别名)：
file.seek(20)
pos1 = file.tell
# 20
file.seek(50, IO::SEEK_CUR)
pos2 = file.pos
# 70
rewind方法也用于重定位文件指针在开始处。这个术语来源于磁带。
如果你想随机访问文件，你可能想使用更新(读和写)打开它。更新文件需要模式字符串中使用+符号。


5、用二进制文件工作

过去，C程序在模式字符串中附加"b"字符来以二进制方式打开文件。这个字符也被用于多种情况，但现在二进制文件使用容易多了。Ruby的字符串可以很容易地保存二进制数据，而且也不需要任何特殊的方式来读文件。
Windows操作系统是例外。二进制与文本文件在这些平台上的主要区别是二进制模式，结束行不能被转译成单个回车换行，但可以保存回车换行对。
在这种情况下"b"字符需要：
# Input file contains a single line: Line 1.
file = File.open("data")
line = file.readline
# "Line 1.n"
puts "#{ line.size}
characters."
# 8 characters
file.close


file = File.open("data","rb")
line = file.readline
# "Line 1.rn"
puts "#{ line.size}
characters."
# 9 characters
file.close
注意，binmode方法可以切换流为二进制模式 。一旦切换，它就不可以再被切换回来。这儿是个例子：
file = File.open("data")
file.binmode
line = file.readline
# "Line 1.rn"
puts "#{ line.size}
characters."
# 9 characters
file.close
如果你真的想使用低层次的输入/输出，你可能使用sysread和syswrite方法。格式接受一定数量的字节做为参数；后者接受字符串并返回写入的真实字节数。(你不应该在一个流中使用其它方法；因为结果可能是不可预知。)这儿个例子：
input = File.new("infile")
output = File.new("outfile")
instr = input.sysread(10);
ytes = output.syswrite("This is a test.")
注意，sysread方法在文件结束时会引起EOFError 错误。当有错误发生时，这些方法也会引起SystemCallError错误。
注意：Array类的方法pack和String类的unpack对于处理二进制数据非常有用。


6、锁文件

它需要操作系统的支持，File类的flock方法将锁或者解锁文件。第二个参数是这些常量中的一个：File:: LOCK_EX, File:: LOCK_NB, File:: LOCK_SH, File:: LOCK_UN, 此外的逻辑OR用于两个或多个的连接。当然要注意多个结合将可能无意义的；首先是此处没有flag标记。这儿是个例子：
file = File.new("somefile")
file.flock(File:LOCK_EX)
# Lock exclusively; no other process

# may use this file.
file.flock(File:LOCK_UN)
# Now unlock it.
file.flock(File:LOCK_SH)
# Lock file with a shared lock (other

# processes may do the same).
file.flock(File::LOCK_UN)
# Now unlock it.
locked = file.flock(File::LOCK_EX | File::LOCK_NB)
# Try to lock the file, but don't block if we can't; in that case,
# locked will be false.


7、完成简单I/O
在Kernel模块中，你已经熟悉了一些I/O例程；我们已经调用过其中的一些方法。调用了它的gets和puts；其它是print，printf，和p(它调用对象的inspect方法，用可阅读格式显示)。
为了完整这儿们提到一些其它方法。例如，putc方法将输出单个字符。(相应的方法getc由于技术原因没有在Kernel中实现；但是，你还是可以在任何IO对象中找到。)如果给定字符串，字符串中的第一个字符将被提取。这儿是个例子：
putc(?n)
# Output a newline
putc("X")
# Output the letter X
一个合理的问题是，当我使用这些方法而别有指定一个接收者时，它们输出到哪儿？首先，在Ruby环境内有对应于三个标准I/O流的三个常量。它们是STDIN, STDOUT, 和 STDERR。都类型IO的全局常量。
还有一个全局变量称为$defout，它是所有来自于Kernel输出方法的目的地。STDOUT的值已被初始化(间接地),以便像我们希望的那样获取所有到标准输出的写入。变量$defout可以被重新赋值以随时引用其它IO对象。这儿是个例子：
diskfile = File.new("foofile","w")
puts "Hello..."
# prints to stdout
$defout = diskfile
puts "Goodbye!"
# prints to "foofile"
diskfile.close
除了gets外，Kernel也有用于输入的readline和readlines方法。格式相同于gets，除了在文件尾会引起EOFError错误，此时返回一个nil值。后者相当于IO.readlines方法(就是它读整个文件到内存)。
输入来自哪儿？这儿也有个标准输入流#stdin，它的缺省给STDIN。同样，有个标准的错误流($stderr缺省给STDERR)。
另一个趣的全局变量是ARGF，它表示命令行所有文件名字的串联。它不是个真正的File对象，尽管它类似。命令行输入的每个文件的标准输入被连接给这个对象。


8、完成缓冲和未缓冲I/O
一些情况下，Ruby 使用它自己的内部缓冲。考虑这个片断：
print "Hello... "
sleep 10
print "Goodbye!n"
如果你运行它，你将会注意到hello和goodby消息两者在睡眠之后同时出现。第一个输出没有加换行符。
这可通过调用flush来刷新缓冲区。这种情况下，我们使用流$defout(用于所有Kernel方法输出的缺省流)做为接收者。然后它的行为就像我们想像的哪样了，第一个消息的出现早于第二个。
print "Hello... "
$defout.flush
sleep 10
print "Goodbye!n"
这个缓冲器可以由sync

 

prefer：

http://blog.sina.com.cn/s/blog_894de61a0100t4e6.html