Ruby 范围、迭代器、文件的输入和输出

最新推荐文章于 2023-05-18 11:19:27 发布
最新推荐文章于 2023-05-18 11:19:27 发布
阅读量207 收藏 1
点赞数
分类专栏： Ruby 文章标签： Ruby
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42655663/article/details/100862256
版权

Ruby 范围（Range）

范围（Range）无处不在：a 到 z、 0 到 9、等等。
Ruby 支持范围，并允许我们以不同的方式使用范围：

  • 作为序列的范围
  • 作为条件的范围
  • 作为间隔的范围

作为序列的范围

范围的第一个也是最常见的用途是表达序列。
序列有一个起点、一个终点和一个在序列产生连续值的方式。
Ruby 使用 ‘’…’’ 和 ‘’…’’ 范围运算符创建这些序列。
两点形式创建一个包含指定的最高值的范围，三点形式创建一个不包含指定的最高值的范围。

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

序列1..100是一个 Range 对象，包含了两个 Fixnum对象的引用。
如果需要，您可以使用 to_a 方法把范围转换为列表。尝试下面的实例：

#!/usr/bin/ruby
 
$, =", "   # Array 值分隔符
range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a
 
puts "#{range1}"
puts "#{range2}"

以上实例运行输出结果为：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]

范围实现了让您可以遍历它们的方法，您可以通过多种方式检查它们的内容：

实例
#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
# 指定范围
digits = 0..9
 
puts digits.include?(5)
ret = digits.min
puts "最小值为 #{ret}"
 
ret = digits.max
puts "最大值为 #{ret}"
 
ret = digits.reject {|i| i < 5 }
puts "不符合条件的有 #{ret}"
 
digits.each do |digit|
   puts "在循环中 #{digit}"
end

以上实例运行输出结果为：

true
最小值为 0
最大值为 9
不符合条件的有 [5, 6, 7, 8, 9]
在循环中 0
在循环中 1
在循环中 2
在循环中 3
在循环中 4
在循环中 5
在循环中 6
在循环中 7
在循环中 8
在循环中 9

作为条件的范围

范围也可以用作条件表达式。例如，下面的代码片段从标准输入打印行，其中每个集合的第一行包含单词 start，最后一行包含单词 end.：

while gets
   print if /start/../end/
end

范围可以用在 case 语句中：
实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
score = 70
 
result = case score
when 0..40
    "糟糕的分数"
when 41..60
    "快要及格"
when 61..70
    "及格分数"
when 71..100
       "良好分数"
else
    "错误的分数"
end
 
puts result

以上实例运行输出结果为：

及格分数

作为间隔的范围

范围的最后一个用途是间隔检测：检查指定值是否在指定的范围内。
需要使用 ===相等运算符来完成计算。
实例

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
if ((1..10) === 5)
  puts "5 在 (1..10)"
end
 
if (('a'..'j') === 'c')
  puts "c 在 ('a'..'j')"
end
 
if (('a'..'j') === 'z')
  puts "z 在 ('a'..'j')"
end

尝试一下 »
以上实例运行输出结果为：

5 在 (1..10)
c 在 ('a'..'j')

Ruby 迭代器

简单来说：迭代(iterate)指的是重复做相同的事，所以迭代器(iterator)就是用来重复多次相同的事。
迭代器是集合支持的方法。存储一组数据成员的对象称为集合。在 Ruby 中，数组(Array)和哈希(Hash)可以称之为集合。
迭代器返回集合的所有元素，一个接着一个。在这里我们将讨论两种迭代器，each和 collect。

Ruby each 迭代器

each 迭代器返回数组或哈希的所有元素。
语法

collection.each do |variable|
   code
end

为集合中的每个元素执行 code。在这里，集合可以是数组或哈希。

#!/usr/bin/ruby
 
ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

尝试一下 »
以上实例运行输出结果为：

1
2
3
4
5

each 迭代器总是与一个块关联。
它向块返回数组的每个值，一个接着一个。
值被存储在变量 i 中，然后显示在屏幕上。

Ruby collect 迭代器

collect 迭代器返回集合的所有元素。
语法

collection = collection.collect

collect 方法不需要总是与一个块关联。
collect 方法返回整个集合，不管它是数组或者是哈希。

实例
#!/usr/bin/ruby
 
a = [1,2,3,4,5]
b = Array.new
b = a.collect{ |x|x }
puts b

尝试一下 »
以上实例运行输出结果为：

1
2
3
4
5

注意：collect 方法不是数组间进行复制的正确方式。
这里有另一个称为 clone 的方法，用于复制一个数组到另一个数组。

当您想要对每个值进行一些操作以便获得新的数组时，您通常使用 collect 方法。例如，下面的代码会生成一个数组，其值是 a 中每个值的 10 倍。
实例

#!/usr/bin/ruby
 
a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

尝试一下 »
以上实例运行输出结果为：

10
20
30
40
50

Ruby 文件的输入与输出

Ruby 提供了一整套I/O相关的方法，在内核（Kernel）模块中实现。所有的I/O方法派生自 IO类。
类 IO 提供了所有基础的方法，比如 read、 write、 gets、 puts、 readline、 getc 和 printf。
本章节将讲解所有 Ruby 中可用的基础的 I/O 函数。如需了解更多的函数，请查看 Ruby 的 IO 类。

puts 语句

在前面的章节中，您赋值给变量，然后使用 puts 语句打印输出。

puts 语句指示程序显示存储在变量中的值。这将在每行末尾添加一个新行。

#!/usr/bin/ruby
 
val1 = "This is variable one"
val2 = "This is variable two"
puts val1
puts val2

以上实例运行输出结果为：

This is variable one
This is variable two

gets 语句

gets 语句可用于获取来自名为 STDIN 的标准屏幕的用户输入。

实例
下面的代码演示了如何使用 gets 语句。
代码将提示用户输入一个值，该值将被存储在变量 val 中，最后会被打印在 STDOUT 上。

实例

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

以上实例运行输出结果为：

Enter a value :
This is entered value
This is entered value

putc 语句

与 puts 语句不同，puts 语句输出整个字符串到屏幕上，而 putc 语句可用于依次输出一个字符。
下面代码的输出只是字符 H：
实例

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

以上实例运行输出结果为：

H

print 语句

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

#!/usr/bin/ruby
 
print "Hello World"
print "Good Morning"

以上实例运行输出结果为：

Hello WorldGood Morning

打开和关闭文件

截至现在，您已经读取并写入标准输入和输出。现在，我们将看看如何操作实际的数据文件。

File.new 方法

您可以使用 File.new方法创建一个 File 对象用于读取、写入或者读写，读写权限取决于 mode 参数。
最后，您可以使用 File.close方法来关闭该文件。
语法

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

File.open 方法

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

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

下表列出了打开文件的不同模式：

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

读取和写入文件

用于简单I/O的方法也可用于所有 file 对象。所以，gets 从标准输入读取一行，aFile.gets 从文件对象 aFile 读取一行。

但是，I/O对象提供了访问方法的附加设置，为我们提供了便利。

sysread 方法

您可以使用方法 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 来向文件写入内容。
当使用方法 syswrite 时，您需要以写入模式打开文件。例如：
实例

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

该语句将写入 "ABCDEF" 到文件中。

each_byte 方法

该方法属于类 File。方法 each_byte 是个可以迭代字符串中每个字符。请看下面的代码实例：
实例

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

字符一个接着一个被传到变量 ch，然后显示在屏幕上，如下所示：

A.B.C.D.E.F.s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...
IO.readlines 方法

类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] 将包含文件的第二行。

IO.foreach 方法

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

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

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

重命名和删除文件

您可以通过 rename和delete方法重命名和删除文件。
下面的实例重命名一个已存在文件test1.txt：
实例

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

下面的实例删除一个已存在文件 test2.txt：
实例

#!/usr/bin/ruby
 
# 删除文件 test2.txt
File.delete("text2.txt")

文件模式与所有权

使用带有掩码的chmod方法来改变文件的模式或权限/访问列表：
下面的实例改变一个已存在文件 test.txt的模式为一个掩码值：
实例

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

下表列出了 chmod方法中可使用的不同的掩码：

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

文件查询

下面的命令在打开文件前检查文件是否已存在：
实例

#!/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" )     # => 1002

下面的命令用于检查文件的类型：
实例

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

ftype 方法通过返回下列中的某个值来标识了文件的类型：file、 directory、 characterSpecial、 blockSpecial、fifo、 ink、 socket或 unknown。

下面的命令用于检查文件被创建、修改或最后访问的时间：
实例

#!/usr/bin/ruby
 
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 中的目录

所有的文件都是包含在目录中，Ruby提供了处理文件和目录的方式。
File 类用于处理文件，Dir 类用于处理目录。
浏览目录
为了在 Ruby 程序中改变目录，请使用 Dir.chdir。
下面的实例改变当前目录为/usr/bin。

Dir.chdir("/usr/bin")

您可以通过 Dir.pwd 查看当前目录：

puts Dir.pwd # 返回当前目录，类似 /usr/bin

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

puts Dir.entries("/usr/bin").join(' ')

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

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

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

Dir["/usr/bin/*"]

创建目录

Dir.mkdir可用于创建目录：

Dir.mkdir("mynewdir")

您也可以通过mkdir在新目录（不是已存在的目录）上设置权限：

注意：掩码 755 设置所有者（owner）、所属组（group）、每个人（world [anyone]）的权限为 rwxr-xr-x，其中r = read读取，w = write 写入，x = execute执行。

Dir.mkdir( "mynewdir", 755 )

删除目录

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

Dir.delete("testdir")

创建文件 & 临时目录

临时文件是那些在程序执行过程中被简单地创建，但不会永久性存储的信息。
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

Ruby 异常

异常和执行总是被联系在一起。如果您打开一个不存在的文件，且没有恰当地处理这种情况，那么您的程序则被认为是低质量的。
如果异常发生，则程序停止。异常用于处理各种类型的错误，这些错误可能在程序执行期间发生，所以要采取适当的行动，而不至于让程序完全停止。
Ruby 提供了一个完美的处理异常的机制。我们可以在 begin/end块中附上可能抛出异常的代码，并使用 rescue 子句告诉 Ruby 完美要处理的异常类型。
语法

begin #开始
 
 raise.. #抛出异常
 
rescue [ExceptionType = StandardException] #捕获指定类型的异常默认值是 StandardException
 $! #表示异常信息
 $@ #表示异常出现的代码位置
else #其余异常
 ..
ensure #不管有没有异常，进入该代码块
 
end #结束

从 begin 到 rescue中的一切是受保护的。
如果代码块执行期间发生了异常，控制会传到 rescue 和end之间的块。

对于 begin 块中的每个 rescue子句，Ruby 把抛出的异常与每个参数进行轮流比较。
如果 rescue 子句中命名的异常与当前抛出的异常类型相同，或者是该异常的父类，则匹配成功。

如果异常不匹配所有指定的错误类型，我们可以在所有的 rescue 子句后使用一个 else 子句。
实例

#!/usr/bin/ruby
 
begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
print file, "==", STDIN, "\n"

以上实例运行输出结果为。您可以看到，STDIN 取代了 file ，因为打开失败。

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

使用 retry 语句

您可以使用 rescue 块捕获异常，然后使用 retry 语句从开头开始执行 begin 块。
语法

begin
    # 这段代码抛出的异常将被下面的 rescue 子句捕获
rescue
    # 这个块将捕获所有类型的异常
    retry  # 这将把控制移到 begin 的开头
end

实例

#!/usr/bin/ruby
 
begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
   fname = "existant_file"
   retry
end

以下是处理流程：

  • 打开时发生异常。
  • 跳到 rescue。fname 被重新赋值。
  • 通过retry跳到begin的开头。
  • 这次文件成功打开。
  • 继续基本的过程。
    注意：如果被重新命名的文件不存在，本实例代码会无限尝试。
    所以异常处理时，谨慎使用 retry。

使用 raise 语句

您可以使用raise 语句抛出异常。下面的方法在调用时抛出异常。
它的第二个消息将被输出。
语法

raise 
 
或
 
raise "Error Message" 
 
或
 
raise ExceptionType, "Error Message"
 
或
 
raise ExceptionType, "Error Message" condition

第一种形式简单地重新抛出当前异常（如果没有当前异常则抛出一个 RuntimeError）。这用在传入异常之前需要解释异常的异常处理程序中。
第二种形式创建一个新的 RuntimeError 异常，设置它的消息为给定的字符串。该异常之后抛出到调用堆栈。
第三种形式使用第一个参数创建一个异常，然后设置相关的消息为第二个参数。
第四种形式与第三种形式类似，您可以添加任何额外的条件语句（比如 unless）来抛出异常。
实例

#!/usr/bin/ruby
begin  
    puts 'I am before the raise.'  
    raise 'An error has occurred.'  
    puts 'I am after the raise.'  
rescue  
    puts 'I am rescued.'  
end  
puts 'I am after the begin block.'

以上实例运行输出结果为：

I am before the raise.  
I am rescued.  
I am after the begin block.

另一个演示 raise 用法的实例：
实例

#!/usr/bin/ruby
 
begin  
  raise 'A test exception.'  
rescue Exception => e  
  puts e.message  
  puts e.backtrace.inspect  
end

以上实例运行输出结果为：

A test exception.
["main.rb:4"]

使用 ensure 语句

有时候，无论是否抛出异常，您需要保证一些处理在代码块结束时完成。例如，您可能在进入时打开了一个文件，当您退出块时，您需要确保关闭文件。
ensure 子句做的就是这个。ensure放在最后一个 rescue 子句后，并包含一个块终止时总是执行的代码块。
它与块是否正常退出、是否抛出并处理异常、是否因一个未捕获的异常而终止，这些都没关系，ensure 块始终都会运行。
语法

begin 
   #.. 过程
   #.. 抛出异常
rescue 
   #.. 处理错误 
ensure 
   #.. 最后确保执行
   #.. 这总是会执行
end

实例

begin
  raise 'A test exception.'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
ensure
  puts "Ensuring execution"
end

以上实例运行输出结果为：

A test exception.
["main.rb:4"]
Ensuring execution

使用 else 语句

如果提供了 else 子句，它一般是放置在 rescue子句之后，任意ensure 之前。
else 子句的主体只有在代码主体没有抛出异常时执行。
语法

begin 
   #.. 过程 
   #.. 抛出异常
rescue 
   #.. 处理错误
else
   #.. 如果没有异常则执行
ensure 
   #.. 最后确保执行
   #.. 这总是会执行
end

实例

begin
 # 抛出 'A test exception.'
 puts "I'm not raising exception"
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
  puts "Ensuring execution"
end

以上实例运行输出结果为：

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

使用 $! 变量可以捕获抛出的错误消息。

Catch 和 Throw

raise 和 rescue 的异常机制能在发生错误时放弃执行，有时候需要在正常处理时跳出一些深层嵌套的结构。
此时 catch和 throw 就派上用场了。
catch 定义了一个使用给定的名称（可以是 Symbol 或 String）作为标签的块。块会正常执行直到遇到一个throw。
语法

throw :lablename
#.. 这不会被执行
catch :lablename do
#.. 在遇到一个 throw 后匹配将被执行的 catch
end

或

throw :lablename condition
#.. 这不会被执行
catch :lablename do
#.. 在遇到一个 throw 后匹配将被执行的 catch
end

实例
下面的实例中，如果用户键入 ‘!’ 回应任何提示，使用一个 throw 终止与用户的交互。

实例
def promptAndGet(prompt)
   print prompt
   res = readline.chomp
   throw :quitRequested if res == "!"
   return res
end

catch :quitRequested do
   name = promptAndGet("Name: ")
   age = promptAndGet("Age: ")
   sex = promptAndGet("Sex: ")
   # ..
   # 处理信息
end
promptAndGet("Name:")

上面的程序需要人工交互，您可以在您的计算机上进行尝试。以上实例运行输出结果为：

Name: Ruby on Rails
Age: 3
Sex: !
Name:Just Ruby

类 Exception

Ruby 的标准类和模块抛出异常。所有的异常类组成一个层次，包括顶部的 Exception 类在内。下一层是七种不同的类型：

Interrupt
NoMemoryError
SignalException
ScriptError
StandardError
SystemExit

Fatal 是该层中另一种异常，但是 Ruby 解释器只在内部使用它。
ScriptError 和 StandardError 都有一些子类，但是在这里我们不需要了解这些细节。
最重要的事情是创建我们自己的异常类，它们必须是类 Exception或其子代的子类。
实例

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

现在，看下面的实例，将用到上面的异常：
实例

File.open(path, "w") do |file|
begin
    # 写出数据 ...
rescue
    # 发生错误
    raise FileSaveError.new($!)
end
end

在这里，最重要的一行是 raise FileSaveError.new($!)。我们调用raise 来示意异常已经发生，把它传给 FileSaveError 的一个新的实例，由于特定的异常引起数据写入失败。

江洗河
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ruby 文件的输入与输出
chishipingping的博客
01-30 180
Ruby 文件的输入与输出
在Ruby中处理文件的输入和输出的教程
01-20
类 IO 提供了所有基础的方法，比如 read、 write、 gets、 puts、 readline、 getc 和 printf。 本章节将讲解所有 Ruby 中可用的基础的 I/O 函数。如需了解更多的函数，请查看 Ruby 的 IO 类。 puts 语句 在前面的...
ruby 变量类中范围_Ruby范围
cunfen6312的博客
07-31 181
ruby 变量类中范围 Ruby范围 (Range in Ruby) Ranges are a sequence of data. For example, numbers 0 through 9 are a range. Letters a through z are a range. We can also define our own range. 范围是数据序列。 例如，数字0到9是一...
ruby打开文件的不同模式
Toml_的博客
05-18 486
在 Ruby 中，打开文件时可以使用不同的模式来指定文件的读写方式。
Ruby_05_文件操作与异常处理
pre_eminent的JAVA学习园地
02-21 1080
Ruby 文件的输入与输出Ruby 提供了一整套 I/O 相关的方法，在内核（Kernel）模块中实现。所有的 I/O 方法派生自 IO 类。类 IO 提供了所有基础的方法，比如 read、 write、 gets、 puts、 readline、 getc 和 printf。本章节将讲解所有 Ruby 中可用的基础的 I/O 函数。puts 语句在前面的章节中，您赋值给变量，然后使用 puts ...
Ruby File.open 方法打开文件和File.new 方法打开文件的差别
lxq_9532的博客
06-21 4201
File.new 方法 您可以使用 File.new 方法创建一个 File 对象用于读取、写入或者读写，读写权限取决于 mode 参数。最后，您可以使用 File.close 方法来关闭该文件。 语法 aFile = File.new("filename", "mode") # ... 处理文件 aFile.close File.open 方法 您可以使用 File.open 方法创建一...
ruby文件的输入和输出的使用
Toml_的博客
05-18 680
以上是文件输入和输出的基本使用方式，通过这些方法可以进行文件的读写操作。需要注意的是，在使用File.open方法时，需要在块内部进行文件的操作，当块执行完毕时，文件会自动关闭。类和其方法来打开文件。在打开文件之前，你需要指定文件名、文件路径和操作模式。的文件，并以只读模式打开。方法将向文件中写入一个字符串，并在末尾添加一个换行符。方法将返回一个数组，其中每个元素都是文件中的一行。如果你想向文件中写入内容，你可以使用。方法将直接向文件中写入内容，而。方法将返回整个文件的内容，而。打开文件后，你可以使用。
Ruby中Block和迭代器的使用讲解
09-21
主要介绍了Ruby中Block和迭代器的使用,是Ruby入门学习中的基础知识,需要的朋友可以参考下
Ruby迭代器的7种技巧分享
01-02
Ruby由于吸收了Perl的正则表达式和Python的可读性，所以其中的计数取值方法，是非常人性化和灵活的，这里可以举例来说明下： 一、打印7次“hello,world”，如下： 代码如下: 7.times{puts “hello,world”} #在这里...
js 数组实现一个类似ruby的迭代器
01-19
·基本实现 ·在迭代中引用原来的对象，或者直接改变数组的值而不是返回一个新数组 ·向迭代传入无限多的参数 ·基本实现 今天突然发现js的数组处理起来真是麻烦,代码一些就是一大堆,相比起ruby的迭代器来真是逊色...
Ruby常用文件操作方法
01-02
一、新建文件 代码如下:     f=File.new(File.join(“C:”,”Test.txt”), “w+”)     f.puts(“I am Jack”)     f.puts(“Hello World”) 文件模式 “r” ：Read-only. Starts at beginning of file (default mode). “r+” ：Read-write. Starts at beginning of file. “w” ：Write-only. Truncates existing file to zero length or creates a new fi
『CTF Tricks』Ruby-利用File.open()执行shell命令
Ho1aAs‘s Blog
09-18 1071
# 利用 ```ruby file = '|whoami' puts open(file).read() # ubuntu puts open(file).gets # ubuntu ```
ruby 读写文件
产品人生
06-22 3953
ruby 读写文件#Ruby 读取文件 #方法一 file = File.open("/Users/Desktop/demo.txt","r") while line = file.gets puts line end#方法二 File.open("/Users/Desktop/demo.txt","r").each_line do |line| puts line end #Ruby 写
ruby 各式各样的迭代器
kukuwuwu的专栏
03-16 941
首先要介绍的是最基本的迭代器，也就是each方法。这个方法的功能是“依序获取元素，并使用这个元素进行一些处理”。Ruby的很多类都定义了这个方法。用在数组上数组的每个元素都有索引，所以可以依照索引的顺序取出所有的数据。alphabet = ["a", "b", "c", "d", "e"]alphabet.each{|i| print i, "/n"} 用
Ruby 迭代器
chishipingping的博客
01-30 115
Ruby 迭代器
Ruby学习笔记(13)_迭代器
天上白玉京 十二楼五城
10-13 326
简单来说：迭代(iterate)指的是重复做相同的事，所以迭代器(iterator)就是用来重复多次相同的事。 迭代器是集合支持的方法。存储一组数据成员的对象称为集合。在 Ruby 中，数组(Array)和哈希(Hash)可以称之为集合。 迭代器返回集合的所有元素，一个接着一个。在这里我们将讨论两种迭代器，each 和 collect。Ruby each 迭代器each 迭代器返回数组或哈希的所
迭代器+代码块，让代码更简短
未知世界
02-18 159
        刚开始接触ruby，作为一个以JAVA开发为主的程序员，ruby的代码风格多少让我有点不太适应，也许习惯了复杂的风格，再简单起来就比较困难了吧， 看来没有其他语言牵绊的话，学起ruby应该更快。         今天看了下ruby中的迭代器和代码块，这两个概念在其他语言当中也有，但是ruby中的迭代器和代码块却给我焕然一新的感觉，也让我更加了解到ruby代码简短的一个原因，正所谓实...
迭代器之输入和输出迭代器
weixin_30429201的博客
10-18 334
输入迭代器：只能前向读取的迭代器，支持++，不能-- 输出迭代器：只能前向写入的迭代器，支持++，不能-- 这两种迭代器最简单，基本只能读取/写入一次 例子： #include <algorithm> #include <iostream> #include <vector> #include <string> usi...
makefile脚本产生ruby文件
最新发布
05-31
您可以使用以下的Makefile脚本来生成Ruby文件： ``` # 指定生成文件的名称 FILENAME = my_ruby_file.rb # 定义生成Ruby文件的命令 define generate_ruby_file echo "#!/usr/bin/env ruby" > $(FILENAME) echo "...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值