Ruby学习之文件的写入和读取

你的名字 2022-03-31 11:20 418阅读 0赞

Ruby 提供了一整套 I/O 相关的方法，在内核（Kernel）模块中实现，所有的 I/O 方法派生自 IO 类，类 *IO* 提供了所有基础的方法，比如 *read、 write、 gets、 puts、 readline、 getc* 和 *printf*，我们接下来就来分别看下这些个函数。

首先来看一下输出打印信息的函数。

*puts* 语句指示程序显示存储在变量中的值，这将在每行末尾添加一个新行，来看实例：

#!/usr/bin/ruby
     
    val1 = "1"
    val2 = "2"
    puts val1
    puts val2

*gets* 语句可用于获取来自名为 STDIN 的标准屏幕的用户输入，下面的实例将提示用户输入一个值，该值将被存储在变量 val 中，最后会被打印在 STDOUT 上：

#!/usr/bin/ruby
     
    puts "Enter a value :"
    val = gets
    puts val

与 *puts* 语句不同，*puts* 语句输出整个字符串到屏幕上，而 *putc* 语句可用于依次输出一个字符，来看实例：

#!/usr/bin/ruby
     
    str="Hello Ruby!"
    putc str    #输出H

*print* 语句与 *puts* 语句类似，唯一的不同在于 *puts* 语句在输出内容后会跳到下一行，而使用 *print* 语句时，光标定位在同一行，实例如下：

#!/usr/bin/ruby
     
    print "1"
    print "2"

接下来我们就来尝试操作实际的数据文件。

我们可以使用 *File.new* 方法创建一个 *File* 对象用于读取、写入或者读写，读写权限取决于 mode 参数。最后，我们可以使用 *File.close* 方法来关闭该文件，像下面这样：

aFile = File.new("filename", "mode")
       # ... 处理文件
    aFile.close

可以使用 *File.open* 方法创建一个新的 file 对象，并把该 file 对象赋值给文件。但是，*File.open* 和 *File.new* 方法之间有一点不同。不同点是 *File.open* 方法可与块关联，而 *File.new* 方法不能，如下：

File.open("filename", "mode") do |aFile|
       # ... process the file
    end

来看下打开文件的不同模式：

<table> 
 <tbody> 
  <tr> 
   <th>模式</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>r</td> 
   <td>只读模式。文件指针被放置在文件的开头。这是默认模式。</td> 
  </tr> 
  <tr> 
   <td>r+</td> 
   <td>读写模式。文件指针被放置在文件的开头。</td> 
  </tr> 
  <tr> 
   <td>w</td> 
   <td>只写模式。如果文件存在，则重写文件。如果文件不存在，则创建一个新文件用于写入。</td> 
  </tr> 
  <tr> 
   <td>w+</td> 
   <td>读写模式。如果文件存在，则重写已存在的文件。如果文件不存在，则创建一个新文件用于读写。</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>只写模式。如果文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。如果文件不存在，则创建一个新文件用于写入。</td> 
  </tr> 
  <tr> 
   <td>a+</td> 
   <td>读写模式。如果文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。如果文件不存在，则创建一个新文件用于读写。</td> 
  </tr> 
 </tbody> 
</table>

用于简单 I/O 的方法也可用于所有 file 对象。所以，gets 从标准输入读取一行，*aFile.gets* 从文件对象 aFile 读取一行。但是，I/O 对象提供了访问方法的附加设置，为我们提供了便利，先来说方法 *sysread* ，它是用来读取文件的内容。当使用方法 sysread 时，我们可以使用任意一种模式打开文件，我们接下来将读取文件内容为“This is a simple text file for testing purpose.”的文件：

#!/usr/bin/ruby
     
    aFile = File.new("input.txt", "r")
    if aFile
       content = aFile.sysread(20)
       puts content
    else
       puts "Unable to open file!"
    end

上述代码将输入文件的头 20 个字符。文件指针将被放置在文件中第 21 个字符的位置。

我们还可以使用方法 *syswrite* 来向文件写入内容。当使用方法 syswrite 时，我们需要以写入模式打开文件：

#!/usr/bin/ruby
     
    aFile = File.new("input.txt", "r+")
    if aFile
       aFile.syswrite("1")
    else
       puts "Unable to open file!"
    end

上述代码将会把1写入到文件里。

然后就是方法 *each\_byte*，它属于类 *File*，是个可以迭代字符串中每个字符，来看实例：

#!/usr/bin/ruby
     
    aFile = File.new("input.txt", "r+")
    if aFile
       aFile.syswrite("asdasdasd")
       aFile.rewind
       aFile.each_byte {|ch| putc ch; putc ?. }
    else
       puts "Unable to open file!"
    end

类 *File* 是类 IO 的一个子类,类 IO 也有一些用于操作文件的方法。*IO.readlines* 是 IO 类中的一个方法。该方法逐行返回文件的内容，我们来看下方法 *IO.readlines* 的使用案例：

#!/usr/bin/ruby
     
    arr = IO.readlines("input.txt")
    puts arr[0]
    puts arr[1]

上述代码中，变量 arr 是一个数组。文件 *input.txt* 的每一行将是数组 arr 中的一个元素。因此，arr\[0\] 将包含第一行，而 arr\[1\] 将包含文件的第二行。

然后方法 *foreach* ，它也是逐行返回输出，但是与方法 *readlines* 之间不同的是，方法 *foreach* 与块相关联。但是，不像方法 *readlines*，方法 *foreach* 不是返回一个数组，如下：

#!/usr/bin/ruby
     
    IO.foreach("input.txt"){|block| puts block}

上述代码将把文件 *test* 的内容逐行传给变量 block，然后输出将显示在屏幕上。

我们还可以通过 *rename* 和 *delete* 方法重命名和删除文件，如下：

#重命名
    #!/usr/bin/ruby
     
    # 重命名文件 test1.txt 为 test2.txt
    File.rename( "test1.txt", "test2.txt" )
    
    #删除
    #!/usr/bin/ruby
     
    # 删除文件 test2.txt
    File.delete("text2.txt")

我们使用带有掩码的 *chmod* 方法来改变文件的模式或权限/访问列表，如下：

#!/usr/bin/ruby
     
    file = File.new( "test.txt", "w" )
    file.chmod( 0755 )

我们来看下*chmod* 方法中可使用的不同的掩码：

<table> 
 <tbody> 
  <tr> 
   <th>掩码</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>0700</td> 
   <td>rwx 掩码，针对所有者</td> 
  </tr> 
  <tr> 
   <td>0400</td> 
   <td>r ，针对所有者</td> 
  </tr> 
  <tr> 
   <td>0200</td> 
   <td>w ，针对所有者</td> 
  </tr> 
  <tr> 
   <td>0100</td> 
   <td>x ，针对所有者</td> 
  </tr> 
  <tr> 
   <td>0070</td> 
   <td>rwx 掩码，针对所属组</td> 
  </tr> 
  <tr> 
   <td>0040</td> 
   <td>r ，针对所属组</td> 
  </tr> 
  <tr> 
   <td>0020</td> 
   <td>w ，针对所属组</td> 
  </tr> 
  <tr> 
   <td>0010</td> 
   <td>x ，针对所属组</td> 
  </tr> 
  <tr> 
   <td>0007</td> 
   <td>rwx 掩码，针对其他人</td> 
  </tr> 
  <tr> 
   <td>0004</td> 
   <td>r ，针对其他人</td> 
  </tr> 
  <tr> 
   <td>0002</td> 
   <td>w ，针对其他人</td> 
  </tr> 
  <tr> 
   <td>0001</td> 
   <td>x ，针对其他人</td> 
  </tr> 
  <tr> 
   <td>4000</td> 
   <td>执行时设置用户 ID</td> 
  </tr> 
  <tr> 
   <td>2000</td> 
   <td>执行时设置所属组 ID</td> 
  </tr> 
  <tr> 
   <td>1000</td> 
   <td>保存交换文本，甚至在使用后也会保存</td> 
  </tr> 
 </tbody> 
</table>

我们来看下在打开文件前检查文件是否已存在的案例：

#!/usr/bin/ruby
     
    File.open("file.rb") if File::exists?( "file.rb" )

还有查询文件是否确实是一个文件的案例：

#!/usr/bin/ruby
     
    # 返回 true 或false
    File.file?( "text.txt" )

再来就是检查给定的文件名是否是一个目录的案例：

#!/usr/bin/ruby
     
    # 一个目录
    File::directory?( "/usr/local/bin" ) # => true
     
    # 一个文件
    File::directory?( "file.rb" ) # => false

还有检查文件是否可读、可写、可执行的案例：

#!/usr/bin/ruby
     
    File.readable?( "test.txt" )   # => true
    File.writable?( "test.txt" )   # => true
    File.executable?( "test.txt" ) # => false

还有检查文件是否大小为零的案例：

#!/usr/bin/ruby
     
    File.zero?( "test.txt" )      # => true

再来返回文件的大小的案例：

#!/usr/bin/ruby
     
    File.size?( "text.txt" )     # => 100

还有检查文件的类型的案例：

#!/usr/bin/ruby
     
    File::ftype( "test.txt" )     # => file

最后就是检查文件被创建、修改或最后访问的时间：

File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008
    File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
    File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008

所有的文件都是包含在目录中，Ruby 提供了处理文件和目录的方式。*File* 类用于处理文件，*Dir* 类用于处理目录，关于这两个类，我们之后的文章会进行详细的说明，在这里，咱们只是简单的了解下。

为了在 Ruby 程序中改变目录，我们可以使用 *Dir.chdir*。下面的实例改变当前目录为 */asd*：

Dir.chdir("/asd")

我们可以通过 *Dir.pwd* 查看当前目录：

puts Dir.pwd # 返回当前目录

还可以使用 *Dir.entries* 获取指定目录内的文件和目录列表：

puts Dir.entries("/asd").join(' ')

*Dir.entries* 返回一个数组，包含指定目录内的所有项。*Dir.foreach* 提供了相同的功能：

Dir.foreach("/usr/bin") do |entry|
       puts entry
    end

获取目录列表的一个更简洁的方式是通过使用 Dir 的类数组的方法：

Dir["/sdf/*"]

*Dir.mkdir* 可用于创建目录：

Dir.mkdir("a")

我们也可以通过 mkdir 在新目录（不是已存在的目录）上设置权限，要注意的是，掩码 755 设置所有者（owner）、所属组（group）、每个人（world \[anyone\]）的权限为 rwxr-xr-x，其中 r = read 读取，w = write 写入，x = execute 执行，如下：

Dir.mkdir( "a", 755 )

*Dir.delete* 可用于删除目录。*Dir.unlink* 和 *Dir.rmdir* 执行同样的功能，为我们提供了便利：

Dir.delete("a")

临时文件是那些在程序执行过程中被简单地创建，但不会永久性存储的信息。*Dir.tmpdir* 提供了当前系统上临时目录的路径，但是该方法默认情况下是不可用的。为了让 *Dir.tmpdir* 可用，使用必需的 'tmpdir' 是必要的。我们可以把 *Dir.tmpdir* 和 *File.join* 一起使用，来创建一个独立于平台的临时文件，如下：

require 'tmpdir'
    tempfilename = File.join(Dir.tmpdir, "tingtong")
    tempfile = File.new(tempfilename, "w")
    tempfile.puts "This is a temporary file"
    tempfile.close
    File.delete(tempfilename)

上述代码代码创建了一个临时文件，并向其中写入数据，然后删除文件。Ruby 的标准库也包含了一个名为 *Tempfile* 的库，该库可用于创建临时文件，如下：

require 'tempfile'
    f = Tempfile.new('tingtong')
    f.puts "Hello"
    puts f.path
    f.close

好啦，本次记录就到这里了。

如果感觉不错的话，请多多点赞支持哦。。。