【Ruby】【基础】

时间 2019-11-20

标签 Ruby 基础栏目 Ruby 繁體版

原文原文链接


# 【Ruby 块】
=begin
1 块由大量代码构成
2 块中代码包含在{}内
3 从与其相同名称的函数调用
4 可使用yield语句调用块
=end
def test
  p '在test方法内'
  yield
  p '又回到了test方法内'
  yield
end

test {p '你在块内'}
#也能够传递由参数的yield
def test
  yield 5
  p '在方法内'
  yield 100
end
test {|i| p "你在块#{i}内"}

# 传递多个参数
def test
  yield 5,100
  p '在方法内'
  yield 6,90
end
test {|a,b| p "你在块#{b}和#{a}内"}
=begin
"你在块100内"
"你在块100和5内"
"在方法内"
"你在块90和6内"
=end
#另外一种调用块的方式
def test(&block)
  block.call
end
test {p 'hello world!'}    #"hello world!"

# 【【运算符】】html

#【比较运算符】
=begin
<=> 联合比较运算符，相等返回0；第一个数大返回1；第二个数大返回-1
== 值相等
.eql? 类型相同且值相等
.equal? 是否具备相同的对象ID(内存地址是否相同)
=== 判断是否具备相同的类，或父类 判断两个实例对象是否具备血缘关系。另外一种说法  判断case 语句的 when 子句内的 相等
=end

puts 1 == 1.0                 #true

puts 1 === 1.0                #true
puts 1 === "abc"              #false
puts (1...10) ===  5          #true
puts (1...10) === 3           #true
puts (1..3) === 3             #true
puts (1...3) === 3            #false
 
puts 1.eql?(1)        #true
puts 1.eql?(1.0)      #false

puts 1.equal?(1)        #true
puts 1.equal?(1.0)      #false

a = 1
b = a
A = 'ABC'
B = A
AA = "A"
BB = AA + ""
print "a's ID : ",a.object_id,"\n"
print "b's ID : ",b.object_id,"\n"
print "A's ID : ",A.object_id,"\n"
print "B's ID : ",B.object_id,"\n"
print "AA's ID : ",AA.object_id,"\n"
print "BB's ID : ",BB.object_id,"\n"
print 'AA == BB : ',AA == BB,"\n"
print 'AA.eql?(BB) : ',AA.eql?(BB),"\n"
print 'AA.equal?(BB) : ',AA.equal?(BB),"\n"
print 'a.equal?(1) : ', a.equal?(1),"\n"
print 'b.equal?(1) : ',b.equal?(1),"\n"
print 'a.equal?(b) : ',a.equal?(b),"\n"
print '1.equal?(a) : ',1.equal?(a),"\n"
print '1.equal?(b) : ',1.equal?(b),"\n"
print 'A.equal?(B) : ',A.equal?(B),"\n"
=begin
a's ID : 3
b's ID : 3
A's ID : 70215304749280
B's ID : 70215304749280
AA's ID : 70215304749260
BB's ID : 70215304749180
AA == BB : true
AA.eql?(BB) : true
AA.equal?(BB) : false
a.equal?(1) : true
b.equal?(1) : true
a.equal?(b) : true
1.equal?(a) : true
1.equal?(b) : true
A.equal?(B) : true
=end

#【Ruby defined运算符】 以方法调用的形式判断传递的表达式是否已定义。返回表达式的描述字符串，若是表达式未定义则返回nil.
foo = 42
puts defined? foo      #local-variable
puts defined? $_       #global-variable
puts defined? bar      #打印了一个空行

puts defined? puts     #method
puts defined? puts(var)#打印了一个空行
puts defined? unpack   #打印了一个空行

#【Ruby 中的.运算符 和  :: 运算符】经过在方法名称前加上类或模块名称和 . 来调用类或模块中的方法。你可使用类或模块名称和两个冒号 :: 来引用类或模块中的常量
#例子
# 定义在主Object类上的常量
MR_COUNT = 0
module Foo
  MR_COUNT = 0
  #设置全局计数为1
  ::MR_COUNT = 1
  #设置局部计数为2
  MR_COUNT = 2
end

puts MR_COUNT         #1
puts Foo::MR_COUNT    #2

#例子
CONST = ' out there '
class Inside_one

end


#【Ruby 点运算符 "." 和双冒号运算符 "::"】
=begin
你能够经过在方法名称前加上类或模块名称和 . 来调用类或模块中的方法。你可使用类或模块名称和两个冒号 :: 来引用类或模块中的常量。

:: 是一元运算符，容许在类或模块内定义常量、实例方法和类方法，能够从类或模块外的任何地方进行访问。

请记住：在 Ruby 中，类和方法也能够被看成常量。

你只须要在表达式的常量名前加上 :: 前缀，便可返回适当的类或模块对象。

若是 :: 前的表达式为类或模块名称，则返回该类或模块内对应的常量值；若是 :: 前未没有前缀表达式，则返回主Object类中对应的常量值。 。
=end
CONST =  ' out there'
class Inside_one
  CONST = proc{' in there'}
  def where_is_my_CONST
    ::CONST + ' inside one'
  end
end
class Inside_two
  CONST = ' inside two'
  def where_is_my_CONST
    CONST
  end
end

puts Inside_one.new.where_is_my_CONST             # out there inside one
puts Inside_two.new.where_is_my_CONST             # inside two
puts Object::CONST +  Inside_two::CONST           # out there inside two
puts Inside_two::CONST + CONST                    # inside two out there
puts Inside_one::CONST                            ##<Proc:0x15d0c81b@D:/DATA/wangxue/RubymineProjects/untitled/class_and_obj.rb:5>
puts Inside_one::CONST.call + Inside_two::CONST   # in there inside two



# 【模块】
=begin
1。 相似于类，但有不一样
2。 模块不能实例化
3。 模块没有子类
4。 模块只能被另外一个模块定义
=end


# 例子 同级目录下有 trip.rb 里面有模块Trip  ；同级目录下有 moral.rb 里面有模块 Moral
$LOAD_PATH << '.'   # 【备注】从当前目录中搜索被引用的文件。若是不像使用$LOAD_PATH 可以使用 require_relative 来从一个相对目录引用文件。

require 'trip'
require 'moral'

y = Trip.sin(Trip::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)


# 例子 同级下有support.rb ，里面有模块 Week
$LOAD_PATH << '.'
require 'support'

class Decade
include Week

  num_of_year = 10
  def num_of_months
    puts Week::FIRST_DAY
    numbers = 10*12
    puts numbers
  end
end

d1 = Decade.new
puts Week::FIRST_DAY
Week.week_in_month
Week.week_in_year
d1.num_of_months
=begin
Sunday
you have four weeks in a month
you have 52 weeks in a year
Sunday
120
=end


# 【Ruby 中的 Mixins】
=begin
面向对象的概念。
当一个类能够从多个父类继承类的特性时，该类显示为多重继承。
Ruby不能直接支持多重继承，可是Ruby的模块有另外一个神奇的功能。它几乎消除了多重继承的须要，一共了一种名为mixin的装置。
Ruby没有真正实现多重继承，而是采用成为mixin技术做为替代品，将模块include到类定义中，模块中的方法就mix进了类中。
=end

#例子
module A
  def a1

  end
  def a2

  end
end

module B
  def b1

  end
  def b2

  end
end

class Sample
  include A
  include B
  def s1

  end
end

samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1


# 【【Ruby字符串】】String
# 例子
x,y,z = 12,36,72
puts "x 的值：#{x}"
puts "x + y 的值： #{x + y}"
puts "x + y + z 的平均值： #{(x + y + z)/3}"
=begin
x 的值：12
x + y 的值： 48
x + y + z 的平均值： 40
=end

# 【字符串的内建方法】
# 例子
myStr = String.new("THIS IS TEST")
foo = myStr.downcase()
puts "#{foo}"
puts foo
=begin
this is test
this is test
=end

# 【字符串的公共方法】
=begin
序号 方法 & 描述
1  str % arg
使用格式规范格式化字符串。若是 arg 包含一个以上的替代，那么 arg 必须是一个数组。如需了解更多格式规范的信息，请查看"内核模块"下的 sprintf。
2  str * integer
返回一个包含 integer 个 str 的新的字符串。换句话说，str 被重复了 integer 次。
3  str + other_str
链接 other_str 到 str。
4  str << obj
链接一个对象到字符串。若是对象是范围为 0.255 之间的固定数字 Fixnum，则它会被转换为一个字符。把它与 concat 进行比较。
5  str <=> other_str
把 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。比较是区分大小写的。
6  str == obj
检查 str 和 obj 的相等性。若是 obj 不是字符串，则返回 false，若是 str <=> obj，则返回 true，返回 0。
7  str =~ obj
根据正则表达式模式 obj 匹配 str。返回匹配开始的位置，不然返回 false。
8  str[position] # 注意返回的是ASCII码而不是字符
str[start, length]
str[start..end]
str[start...end]
使用索引截取子串
9  str.capitalize
把字符串转换为大写字母显示。
10 str.capitalize!
与 capitalize 相同，可是 str 会发生变化并返回。
11 str.casecmp
不区分大小写的字符串比较。
12 str.center
居中字符串。
13 str.chomp
从字符串末尾移除记录分隔符（$/），一般是 \n。若是没有记录分隔符，则不进行任何操做。
14 str.chomp!
与 chomp 相同，可是 str 会发生变化并返回。
15 str.chop
移除 str 中的最后一个字符。
16 str.chop!
与 chop 相同，可是 str 会发生变化并返回。
17 str.concat(other_str)
链接 other_str 到 str。
18 str.count(str, ...)
给一个或多个字符集计数。若是有多个字符集，则给这些集合的交集计数。
19 str.crypt(other_str)
对 str 应用单向加密哈希。参数是两个字符长的字符串，每一个字符的范围为 a.z、 A.Z、 0.九、 . 或 /。
20 str.delete(other_str, ...)
返回 str 的副本，参数交集中的全部字符会被删除。
21 str.delete!(other_str, ...)
与 delete 相同，可是 str 会发生变化并返回。
22 str.downcase
返回 str 的副本，全部的大写字母会被替换为小写字母。
23 str.downcase!
与 downcase 相同，可是 str 会发生变化并返回。
24 str.dump
返回 str 的版本，全部的非打印字符被替换为 \nnn 符号，全部的特殊字符被转义。
25 str.each(separator=$/) { |substr| block }
使用参数做为记录分隔符（默认是 $/）分隔 str，传递每一个子字符串给被提供的块。
26 str.each_byte { |fixnum| block }
传递 str 的每一个字节给 block，以字节的十进制表示法返回每一个字节。
27 str.each_line(separator=$/) { |substr| block }
使用参数做为记录分隔符（默认是 $/）分隔 str，传递每一个子字符串给被提供的 block。
28 str.empty?
若是 str 为空（即长度为 0），则返回 true。
29 str.eql?(other)
若是两个字符串有相同的长度和内容，则这两个字符串相等。
30 str.gsub(pattern, replacement) [or]
str.gsub(pattern) { |match| block }
返回 str 的副本，pattern 的全部出现都替换为 replacement 或 block 的值。pattern 一般是一个正则表达式 Regexp；若是是一个字符串 String，则没有正则表达式元字符被解释（即，/\d/ 将匹配一个数字，但 '\d' 将匹配一个反斜杠后跟一个 'd'）。
31 str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]
使用下列的参数引用 str：参数为一个 Fixnum，则返回 fixnum 的字符编码；参数为两个 Fixnum，则返回一个从偏移（第一个 fixnum）开始截至到长度（第二个 fixnum）为止的子字符串；参数为 range，则返回该范围内的一个子字符串；参数为 regexp，则返回匹配字符串的部分；参数为带有 fixnum 的 regexp，则返回 fixnum 位置的匹配数据；参数为 other_str，则返回匹配 other_str 的子字符串。一个负数的 Fixnum 从字符串的末尾 -1 开始。
32 str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] =new_str [or] str[regexp, fixnum] =new_str [or] str[other_str] = new_str ]
替换整个字符串或部分字符串。与 slice! 同义。
33 str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block }
执行 String#gsub 的替换，返回 str，若是没有替换被执行则返回 nil。
34 str.hash
返回一个基于字符串长度和内容的哈希。
35 str.hex
把 str 的前导字符看成十六进制数字的字符串（一个可选的符号和一个可选的 0x），并返回相对应的数字。若是错误则返回零。
36 str.include? other_str [or] str.include? fixnum
若是 str 包含给定的字符串或字符，则返回 true。
37 str.index(substring [, offset]) [or]
str.index(fixnum [, offset]) [or]
str.index(regexp [, offset])
返回给定子字符串、字符（fixnum）或模式（regexp）在 str 中第一次出现的索引。若是未找到则返回 nil。若是提供了第二个参数，则指定在字符串中开始搜索的位置。
38 str.insert(index, other_str)
在给定索引的字符前插入 other_str，修改 str。负值索引从字符串的末尾开始计数，并在给定字符后插入。其意图是在给定的索引处开始插入一个字符串。
39 str.inspect
返回 str 的可打印版本，带有转义的特殊字符。
40 str.intern [or] str.to_sym
返回与 str 相对应的符号，若是以前不存在，则建立符号。
41 str.length
返回 str 的长度。把它与 size 进行比较。
42 str.ljust(integer, padstr=' ')
若是 integer 大于 str 的长度，则返回长度为 integer 的新字符串，新字符串以 str 左对齐，并以 padstr 做为填充。不然，返回 str。
43 str.lstrip
返回 str 的副本，移除了前导的空格。
44 str.lstrip!
从 str 中移除前导的空格，若是没有变化则返回 nil。
45 str.match(pattern)
若是 pattern 不是正则表达式，则把 pattern 转换为正则表达式 Regexp，而后在 str 上调用它的匹配方法。
46 str.oct
把 str 的前导字符看成十进制数字的字符串（一个可选的符号），并返回相对应的数字。若是转换失败，则返回 0。
47 str.replace(other_str)
把 str 中的内容替换为 other_str 中的相对应的值。
48 str.reverse
返回一个新字符串，新字符串是 str 的倒序。
49 str.reverse!
逆转 str，str 会发生变化并返回。
50 str.rindex(substring [, fixnum]) [or]
str.rindex(fixnum [, fixnum]) [or]
str.rindex(regexp [, fixnum])
返回给定子字符串、字符（fixnum）或模式（regexp）在 str 中最后一次出现的索引。若是未找到则返回 nil。若是提供了第二个参数，则指定在字符串中结束搜索的位置。超出该点的字符将不被考虑。
51 str.rjust(integer, padstr=' ')
若是 integer 大于 str 的长度，则返回长度为 integer 的新字符串，新字符串以 str 右对齐，并以 padstr 做为填充。不然，返回 str。
52 str.rstrip
返回 str 的副本，移除了尾随的空格。
53 str.rstrip!
从 str 中移除尾随的空格，若是没有变化则返回 nil。
54 str.scan(pattern) [or]
str.scan(pattern) { |match, ...| block }
两种形式匹配 pattern（能够是一个正则表达式 Regexp 或一个字符串 String）遍历 str。针对每一个匹配，会生成一个结果，结果会添加到结果数组中或传递给 block。若是 pattern 不包含分组，则每一个独立的结果由匹配的字符串、$& 组成。若是 pattern 包含分组，每一个独立的结果是一个包含每一个分组入口的数组。
55 str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]
str.slice(range) [or] str.slice(regexp) [or]
str.slice(regexp, fixnum) [or] str.slice(other_str)
See str[fixnum], etc.
str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str)
从 str 中删除指定的部分，并返回删除的部分。若是值超出范围，参数带有 Fixnum 的形式，将生成一个 IndexError。参数为 range 的形式，将生成一个 RangeError，参数为 Regexp 和 String 的形式，将忽略执行动做。
56 str.split(pattern=$;, [limit])
基于分隔符，把 str 分红子字符串，并返回这些子字符串的数组。
若是 pattern 是一个字符串 String，那么在分割 str 时，它将做为分隔符使用。若是 pattern 是一个单一的空格，那么 str 是基于空格进行分割，会忽略前导空格和连续空格字符。
若是 pattern 是一个正则表达式 Regexp，则 str 在 pattern 匹配的地方被分割。当 pattern 匹配一个玲长度的字符串时，str 被分割成单个字符。
若是省略了 pattern 参数，则使用 $; 的值。若是 $; 为 nil（默认的），str 基于空格进行分割，就像是指定了 ` ` 做为分隔符同样。
若是省略了 limit 参数，会抑制尾随的 null 字段。若是 limit 是一个正数，则最多返回该数量的字段（若是 limit 为 1，则返回整个字符串做为数组中的惟一入口）。若是 limit 是一个负数，则返回的字段数量不限制，且不抑制尾随的 null 字段。
57 str.squeeze([other_str]*)
使用为 String#count 描述的程序从 other_str 参数创建一系列字符。返回一个新的字符串，其中集合中出现的相同的字符会被替换为单个字符。若是没有给出参数，则全部相同的字符都被替换为单个字符。
58 str.squeeze!([other_str]*)
与 squeeze 相同，可是 str 会发生变化并返回，若是没有变化则返回 nil。
59 str.strip
返回 str 的副本，移除了前导的空格和尾随的空格。
60 str.strip!
从 str 中移除前导的空格和尾随的空格，若是没有变化则返回 nil。
61 str.sub(pattern, replacement) [or]
str.sub(pattern) { |match| block }
返回 str 的副本，pattern 的第一次出现会被替换为 replacement 或 block 的值。pattern 一般是一个正则表达式 Regexp；若是是一个字符串 String，则没有正则表达式元字符被解释。
62 str.sub!(pattern, replacement) [or]
str.sub!(pattern) { |match| block }
执行 String#sub 替换，并返回 str，若是没有替换执行，则返回 nil。
63 str.succ [or] str.next
返回 str 的继承。
64 str.succ! [or] str.next!
至关于 String#succ，可是 str 会发生变化并返回。
65 str.sum(n=16)
返回 str 中字符的 n-bit 校验和，其中 n 是可选的 Fixnum 参数，默认为 16。结果是简单地把 str 中每一个字符的二进制值的总和，以 2n - 1 为模。这不是一个特别好的校验和。
66 str.swapcase
返回 str 的副本，全部的大写字母转换为小写字母，全部的小写字母转换为大写字母。
67 str.swapcase!
至关于 String#swapcase，可是 str 会发生变化并返回，若是没有变化则返回 nil。
68 str.to_f
返回把 str 中的前导字符解释为浮点数的结果。超出有效数字的末尾的多余字符会被忽略。若是在 str 的开头没有有效数字，则返回 0.0。该方法不会生成异常。
69 str.to_i(base=10)
返回把 str 中的前导字符解释为整数基数（基数为 二、 八、 10 或 16）的结果。超出有效数字的末尾的多余字符会被忽略。若是在 str 的开头没有有效数字，则返回 0。该方法不会生成异常。
70 str.to_s [or] str.to_str
返回接收的值。
71 str.tr(from_str, to_str)
返回 str 的副本，把 from_str 中的字符替换为 to_str 中相对应的字符。若是 to_str 比 from_str 短，那么它会以最后一个字符进行填充。两个字符串均可以使用 c1.c2 符号表示字符的范围。若是 from_str 以 ^ 开头，则表示除了所列出的字符之外的全部字符。
72 str.tr!(from_str, to_str)
至关于 String#tr，可是 str 会发生变化并返回，若是没有变化则返回 nil。
73 str.tr_s(from_str, to_str)
把 str 按照 String#tr 描述的规则进行处理，而后移除会影响翻译的重复字符。
74 str.tr_s!(from_str, to_str)
至关于 String#tr_s，可是 str 会发生变化并返回，若是没有变化则返回 nil。
75 str.unpack(format)
根据 format 字符串解码 str（可能包含二进制数据），返回被提取的每一个值的数组。format 字符由一系列单字符指令组成。每一个指令后能够跟着一个数字，表示重复该指令的次数。星号（*）将使用全部剩余的元素。指令 sSiIlL 每一个后可能都跟着一个下划线（_），为指定类型使用底层平台的本地尺寸大小，不然使用独立于平台的一致的尺寸大小。format 字符串中的空格会被忽略。
76 str.upcase
返回 str 的副本，全部的小写字母会被替换为大写字母。操做是环境不敏感的，只有字符 a 到 z 会受影响。
77 str.upcase!
改变 str 的内容为大写，若是没有变化则返回 nil。
78 str.upto(other_str) { |s| block }
遍历连续值，以 str 开始，以 other_str 结束（包含），轮流传递每一个值给 block。String#succ 方法用于生成每一个值。

=end

# 【字符串 unpack 指令】
=begin
指令 返回 描述
A  String 移除尾随的 null 和空格。
a  String 字符串。
B  String 从每一个字符中提取位（首先是最高有效位）。
b  String 从每一个字符中提取位（首先是最低有效位）。
C  Fixnum 提取一个字符做为无符号整数。
c  Fixnum 提取一个字符做为整数。
D, d Float  把 sizeof(double) 长度的字符看成原生的 double。
E  Float  把 sizeof(double) 长度的字符看成 littleendian 字节顺序的 double。
e  Float  把 sizeof(float) 长度的字符看成 littleendian 字节顺序的 float。
F, f Float  把 sizeof(float) 长度的字符看成原生的 float。
G  Float  把 sizeof(double) 长度的字符看成 network 字节顺序的 double。
g  Float  把 sizeof(float) 长度的字符看成 network 字节顺序的 float。
H  String 从每一个字符中提取十六进制（首先是最高有效位）。
h  String 从每一个字符中提取十六进制（首先是最低有效位）。
I  Integer  把 sizeof(int) 长度（经过 _ 修改）的连续字符看成原生的 integer。
i  Integer  把 sizeof(int) 长度（经过 _ 修改）的连续字符看成有符号的原生的 integer。
L  Integer  把四个（经过 _ 修改）连续字符看成无符号的原生的 long integer。
l  Integer  把四个（经过 _ 修改）连续字符看成有符号的原生的 long integer。
M  String 引用可打印的。
m  String Base64 编码。
N  Integer  把四个字符看成 network 字节顺序的无符号的 long。
n  Fixnum 把两个字符看成 network 字节顺序的无符号的 short。
P  String 把 sizeof(char *) 长度的字符看成指针，并从引用的位置返回 \emph{len} 字符。
p  String 把 sizeof(char *) 长度的字符看成一个空结束字符的指针。
Q  Integer  把八个字符看成无符号的 quad word（64 位）。
q  Integer  把八个字符看成有符号的 quad word（64 位）。
S  Fixnum 把两个（若是使用 _ 则不一样）连续字符看成 native 字节顺序的无符号的 short。
s  Fixnum 把两个（若是使用 _ 则不一样）连续字符看成 native 字节顺序的有符号的 short。
U  Integer  UTF-8 字符，做为无符号整数。
u  String UU 编码。
V  Fixnum 把四个字符看成 little-endian 字节顺序的无符号的 long。
v  Fixnum 把两个字符看成 little-endian 字节顺序的无符号的 short。
w  Integer  BER 压缩的整数。
X     向后跳过一个字符。
x     向前跳过一个字符。
Z  String 和 * 一块儿使用，移除尾随的 null 直到第一个 null。
@     跳过 length 参数给定的偏移量。
实例
尝试下面的实例，解压各类数据。
"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now=20is".unpack('M*')             #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]
=end


#【【Ruby数组】】Array
=begin
uby 数组是任何对象的有序整数索引集合。数组中的每一个元素都与一个索引相关，并可经过索引进行获取。
数组的索引从 0 开始，这与 C 或 Java 中同样。一个负数的索相对于数组的末尾计数的，也就是说，索引为 -1 表示数组的最后一个元素，-2 表示数组中的倒数第二个元素，依此类推。
Ruby 数组可存储诸如 String、 Integer、 Fixnum、 Hash、 Symbol 等对象，甚至能够是其余 Array 对象。
Ruby 数组不须要指定大小，当向数组添加元素时，Ruby 数组会自动增加
=end

# 【建立数组】
# 例子
name = Array.new(20)
puts name.length        #20
puts name.size          #20

# 例子  能够给数组中的每一个元素赋值
names = Array.new(4,'mac')
puts names
=begin
mac
mac
mac
mac
=end
puts "#{names}"       #["mac", "mac", "mac", "mac"]


# 例子  new 块，填充元素
num1 = Array.new(10)
num2 = Array.new(10){|e| e = e * 2}
puts "#{num1}"          #[nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]
puts "#{num2}"          #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 数组建立方法2
num2 = Array.[](1,2,3)
# 数组建立方法3
num3 = Array[1,2,3]
puts "#{num2}"          #[1, 2, 3]
puts "#{num3}"          #[1, 2, 3]

# 数组建立方法4，使用范围
num4 = Array(1...4)
puts "#{num4}"          #[1, 2, 3]

# 【数组的内建方法】
digits = Array(1...4)
num = digits.at(3)
puts "#{num}"           #什么都没打印，不知道为何

=begin
序号 方法 & 描述
1  array & other_array
返回一个新的数组，包含两个数组中共同的元素，没有重复。
2  array * int [or] array * str
返回一个新的数组，新数组经过链接 self 的 int 副本建立的。带有 String 参数时，至关于 self.join(str)。
3  array + other_array
返回一个新的数组，新数组经过链接两个数组产生第三个数组建立的。
4  array - other_array
返回一个新的数组，新数组是从初始数组中移除了在 other_array 中出现的项的副本。
5  str <=> other_str
把 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。比较是区分大小写的。
6  array | other_array
经过把 other_array 加入 array 中，移除重复项，返回一个新的数组。
7  array << obj
把给定的对象附加到数组的末尾。该表达式返回数组自己，因此几个附加能够连在一块儿。
8  array <=> other_array
若是数组小于、等于或大于 other_array，则返回一个整数（-一、 0 或 +1）。
9  array == other_array
若是两个数组包含相同的元素个数，且每一个元素与另外一个数组中相对应的元素相等（根据 Object.==），那么这两个数组相等。
10 array[index] [or] array[start, length] [or]
array[range] [or] array.slice(index) [or]
array.slice(start, length) [or] array.slice(range)
返回索引为 index 的元素，或者返回从 start 开始直至 length 个元素的子数组，或者返回 range 指定的子数组。负值索引从数组末尾开始计数（-1 是最后一个元素）。若是 index（或开始索引）超出范围，则返回 nil。
11 array[index] = obj [or]
array[start, length] = obj or an_array or nil [or]
array[range] = obj or an_array or nil
设置索引为 index 的元素，或者替换从 start 开始直至 length 个元素的子数组，或者替换 range 指定的子数组。若是索引大于数组的当前容量，那么数组会自动增加。负值索引从数组末尾开始计数。若是 length 为零则插入元素。若是在第二种或第三种形式中使用了 nil，则从 self 删除元素。
12 array.abbrev(pattern = nil)
为 self 中的字符串计算明确的缩写集合。若是传递一个模式或一个字符串，只考虑当字符串匹配模式或者以该字符串开始时的状况。
13 array.assoc(obj)
搜索一个数组，其元素也是数组，使用 obj.== 把 obj 与每一个包含的数组的第一个元素进行比较。若是匹配则返回第一个包含的数组，若是未找到匹配则返回 nil。
14 array.at(index)
返回索引为 index 的元素。一个负值索引从 self 的末尾开始计数。若是索引超出范围则返回 nil。
15 array.clear
从数组中移除全部的元素。
16 array.collect { |item| block } [or]
array.map { |item| block }
为 self 中的每一个元素调用一次 block。建立一个新的数组，包含 block 返回的值。
17 array.collect! { |item| block } [or]
array.map! { |item| block }
为 self 中的每一个元素调用一次 block，把元素替换为 block 返回的值。
18 array.compact
返回 self 的副本，移除了全部的 nil 元素。
19 array.compact!
从数组中移除全部的 nil 元素。若是没有变化则返回 nil。
20 array.concat(other_array)
追加 other_array 中的元素到 self 中。
21 array.delete(obj) [or]
array.delete(obj) { block }
从 self 中删除等于 obj 的项。若是未找到相等项，则返回 nil。若是未找到相等项且给出了可选的代码 block，则返回 block 的结果。
22 array.delete_at(index)
删除指定的 index 处的元素，并返回该元素。若是 index 超出范围，则返回 nil。
23 array.delete_if { |item| block }
当 block 为 true 时，删除 self 的每一个元素。
24 array.each { |item| block }
为 self 中的每一个元素调用一次 block，传递该元素做为参数。
25 array.each_index { |index| block }
与 Array#each 相同，可是传递元素的 index，而不是传递元素自己。
26 array.empty?
若是数组自己没有包含元素，则返回 true。
27 array.eql?(other)
若是 array 和 other 是相同的对象，或者两个数组带有相同的内容，则返回 true。
28 array.fetch(index) [or]
array.fetch(index, default) [or]
array.fetch(index) { |index| block }
尝试返回位置 index 处的元素。若是 index 位于数组外部，则第一种形式会抛出 IndexError 异常，第二种形式会返回 default，第三种形式会返回调用 block 传入 index 的值。负值的 index 从数组末尾开始计数。
29 array.fill(obj) [or]
array.fill(obj, start [, length]) [or]
array.fill(obj, range) [or]
array.fill { |index| block } [or]
array.fill(start [, length] ) { |index| block } [or]
array.fill(range) { |index| block }
前面三种形式设置 self 的被选元素为 obj。以 nil 开头至关于零。nil 的长度至关于 self.length。最后三种形式用 block 的值填充数组。block 经过带有被填充的每一个元素的绝对索引来传递。
30 array.first [or]
array.first(n)
返回数组的第一个元素或前 n 个元素。若是数组为空，则第一种形式返回 nil，第二种形式返回一个空的数组。
31 array.flatten
返回一个新的数组，新数组是一个一维的扁平化的数组（递归）。
32 array.flatten!
把 array 进行扁平化。若是没有变化则返回 nil。（数组不包含子数组。）
33 array.frozen?
若是 array 被冻结（或排序时暂时冻结），则返回 true。
34 array.hash
计算数组的哈希代码。两个具备相同内容的数组将具备相同的哈希代码。
35 array.include?(obj)
若是 self 中包含 obj，则返回 true，不然返回 false。
36 array.index(obj)
返回 self 中第一个等于 obj 的对象的 index。若是未找到匹配则返回 nil。
37 array.indexes(i1, i2, ... iN) [or]
array.indices(i1, i2, ... iN)
该方法在 Ruby 的最新版本中被废弃，因此请使用 Array#values_at。
38 array.indices(i1, i2, ... iN) [or]
array.indexes(i1, i2, ... iN)
该方法在 Ruby 的最新版本中被废弃，因此请使用 Array#values_at。
39 array.insert(index, obj...)
在给定的 index 的元素前插入给定的值，index 能够是负值。
40 array.inspect
建立一个数组的可打印版本。
41 array.join(sep=$,)
返回一个字符串，经过把数组的每一个元素转换为字符串，并使用 sep 分隔进行建立的。
42 array.last [or] array.last(n)
返回 self 的最后一个元素。若是数组为空，则第一种形式返回 nil。
43 array.length
返回 self 中元素的个数。可能为零。
44 array.map { |item| block } [or]
array.collect { |item| block }
为 self 的每一个元素调用一次 block。建立一个新的数组，包含 block 返回的值。
45 array.map! { |item| block } [or]
array.collect! { |item| block }
为 array 的每一个元素调用一次 block，把元素替换为 block 返回的值。
46 array.nitems
返回 self 中 non-nil 元素的个数。可能为零。
47 array.pack(aTemplateString)
根据 aTemplateString 中的指令，把数组的内容压缩为二进制序列。指令 A、 a 和 Z 后能够跟一个表示结果字段宽度的数字。剩余的指令也能够带有一个表示要转换的数组元素个数的数字。若是数字是一个星号（*），则全部剩余的数组元素都将被转换。任何指令后均可以跟一个下划线（_），表示指定类型使用底层平台的本地尺寸大小，不然使用独立于平台的一致的尺寸大小。在模板字符串中空格会被忽略。
48 array.pop
从 array 中移除最后一个元素，并返回该元素。若是 array 为空则返回 nil。
49 array.push(obj, ...)
把给定的 obj 附加到数组的末尾。该表达式返回数组自己，因此几个附加能够连在一块儿。
50 array.rassoc(key)
搜索一个数组，其元素也是数组，使用 == 把 key 与每一个包含的数组的第二个元素进行比较。若是匹配则返回第一个包含的数组。
51 array.reject { |item| block }
返回一个新的数组，包含当 block 不为 true 时的数组项。
52 array.reject! { |item| block }
当 block 为真时，从 array 删除元素，若是没有变化则返回 nil。至关于 Array#delete_if。
53 array.replace(other_array)
把 array 的内容替换为 other_array 的内容，必要的时候进行截断或扩充。
54 array.reverse
返回一个新的数组，包含倒序排列的数组元素。
55 array.reverse!
把 array 进行逆转。
56 array.reverse_each {|item| block }
与 Array#each 相同，可是把 array 进行逆转。
57 array.rindex(obj)
返回 array 中最后一个等于 obj 的对象的索引。若是未找到匹配，则返回 nil。
58 array.select {|item| block }
调用从数组传入连续元素的 block，返回一个数组，包含 block 返回 true 值时的元素。
59 array.shift
返回 self 的第一个元素，并移除该元素（把全部的其余元素下移一位）。若是数组为空，则返回 nil。
60 array.size
返回 array 的长度（元素的个数）。length 的别名。
61 array.slice(index) [or] array.slice(start, length) [or]
array.slice(range) [or] array[index] [or]
array[start, length] [or] array[range]
返回索引为 index 的元素，或者返回从 start 开始直至 length 个元素的子数组，或者返回 range 指定的子数组。负值索引从数组末尾开始计数（-1 是最后一个元素）。若是 index（或开始索引）超出范围，则返回 nil。
62 array.slice!(index) [or] array.slice!(start, length) [or]
array.slice!(range)
删除 index（长度是可选的）或 range 指定的元素。返回被删除的对象、子数组，若是 index 超出范围，则返回 nil。
63 array.sort [or] array.sort { | a,b | block }
返回一个排序的数组。
64 array.sort! [or] array.sort! { | a,b | block }
把数组进行排序。
65 array.to_a
返回 self。若是在 Array 的子类上调用，则把接收参数转换为一个 Array 对象。
66 array.to_ary
返回 self。
67 array.to_s
返回 self.join。
68 array.transpose
假设 self 是数组的数组，且置换行和列。
69 array.uniq
返回一个新的数组，移除了 array 中的重复值。
70 array.uniq!
从 self 中移除重复元素。若是没有变化（也就是说，未找到重复），则返回 nil。
71 array.unshift(obj, ...)
把对象前置在数组的前面，其余元素上移一位。
72 array.values_at(selector,...)
返回一个数组，包含 self 中与给定的 selector（一个或多个）相对应的元素。选择器能够是整数索引或者范围。
73 array.zip(arg, ...) [or]
array.zip(arg, ...){ | arr | block }
把任何参数转换为数组，而后把 array 的元素与每一个参数中相对应的元素合并。

数组 pack 指令
下表列出了方法 Array#pack 的压缩指令。
指令 描述
@  移动到绝对位置。
A  ASCII 字符串（填充 space，count 是宽度）。
a  ASCII 字符串（填充 null，count 是宽度）。
B  位字符串（降序）
b  位字符串（升序）。
C  无符号字符。
c  字符。
D, d 双精度浮点数，原生格式。
E  双精度浮点数，little-endian 字节顺序。
e  单精度浮点数，little-endian 字节顺序。
F, f 单精度浮点数，原生格式。
G  双精度浮点数，network（big-endian）字节顺序。
g  单精度浮点数，network（big-endian）字节顺序。
H  十六进制字符串（高位优先）。
h  十六进制字符串（低位优先）。
I  无符号整数。
i  整数。
L  无符号 long。
l  Long。
M  引用可打印的，MIME 编码。
m  Base64 编码字符串。
N  Long，network（big-endian）字节顺序。
n  Short，network（big-endian）字节顺序。
P  指向一个结构（固定长度的字符串）。
p  指向一个空结束字符串。
Q, q 64 位数字。
S  无符号 short。
s  Short。
U  UTF-8。
u  UU 编码字符串。
V  Long，little-endian 字节顺序。
v  Short，little-endian 字节顺序。
w  BER 压缩的整数 \fnm。
X  向后跳过一个字节。
x  Null 字节。
Z  与 a 相同，除了 null 会被加上 *。
实例
尝试下面的实例，压缩各类数据。
实例
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3")   #=> "a  b  c  "
puts a.pack("a3a3a3")   #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc")      #=> "ABC"
以上实例运行输出结果为：
a  b  c
abc
ABC
=end



# 【【哈希】】 Hash
=begin
健值对集合。相似于数组，不过索引不局限于数字。
索引几乎能够是任何对象
和数组有一个很重要的区别，无序的，若是顺序很重要，就使用数组了。
=end

#建立哈希
month1 = Hash.new
puts "#{month1}"          #{}
puts month1[0]            #空
puts month1[72]           #空
month2 = Hash.new("months")
puts "#{month2}"          #{}
puts month2[0]            #months
puts month2[72]           #months
month3 = Hash.new"months"
puts "#{month3}"          #{}
puts month3[0]            #months
puts month3[72]           #months

# 例子
H = Hash['a' => 100,'b' => 200]
puts H['a']         #100
puts H['b']         #200

# 【备注】可以使用任意Ruby对象做为键或值，甚至可使用数组
#[1,'jan']  =>  'January'

# 例子
months = Hash.new("months")
months = {'1' => 'January','2' => 'Febrary',[1,'jan']  =>  'January'}
keys = months.keys
puts "#{keys}"          #["1", "2", [1, "jan"]]

#【【Ruby日期、时间】】Date Time

# 例子 获取当前日期和时间
time1 = Time.new
puts "当前时间：#{time1}"
print "当前时间：" , time1.inspect, "\n"

time2 = Time.now
puts "当前时间：#{time2}"
print "当前时间：", time2.inspect
=begin
当前时间：2018-07-07 12:42:17 +0800
当前时间：2018-07-07 12:42:17 +0800
当前时间：2018-07-07 12:42:17 +0800
当前时间：2018-07-07 12:42:17 +0800
=end


# 【获取Date & Time 组件】
time = Time.new
puts "当前时间：" ,time
puts time.year      #2018
puts time.month     #7
puts time.day       #7【一个月中的第几天】
puts time.wday      #6【一周中的星期几】
puts time.yday      #188【一年中的第几天】
puts time.hour      #12
puts time.min       #46
puts time.sec       #20
puts time.usec      #840399【微秒】
puts time.zone      #CST   【备注】能够表示四个国家的标准时间，四个不一样的时区，根据当前编程环境自行判断的结果

# 【Time.utc Time.gm  Time.local 函数】格式化
puts Time.local(2018,7,7)         #2018-07-07 00:00:00 +0800
puts Time.local(2018,7,7,13,29)   #2018-07-07 13:29:00 +0800
puts Time.utc(2018,7,7,13,29)     #2018-07-07 13:29:00 UTC
puts Time.gm(2018,7,7,13,28)      #2018-07-07 13:28:00 UTC  【备注】格林威治时间，通UTC


# 时间组件组成的数组
time = Time.new
values = time.to_a
puts "#{values}"            #[32, 35, 13, 7, 7, 2018, 6, 188, false, "CST"]  【备注】[sec,min,hour,day,month,year,wday,yday,isdst,zone]

# 该数组可被传到Time.utc  Time.local 来获取日期的不一样格式
time = Time.now
values = time.to_a
puts Time.utc(*values)      #2018-07-07 13:38:38 UTC

# 【获取时间的方式，从纪元以来的秒数（平台相关）】
time = Time.now.to_i        #纪元以来的秒数
puts time
time_obj = Time.at(time)    #把秒数转成Time对象
puts time_obj
time_f = Time.now.to_f      #返回纪元以来的秒数，包含微秒
puts time_f
=begin
1530942192
2018-07-07 13:43:12 +0800
1530942192.656307
=end

# 【时区和夏令时】
time = Time.now

puts time.zone              #CST
puts time.utc_offset        #28800 【相对于utc的多少秒偏移】
puts time.zone              #CST
puts time.isdst             #false 【若是utc没有夏令时】
puts time.utc?              #false 【若是在utc时区】
puts time.localtime         #2018-07-07 13:57:50 +0800
time.gmtime                 #【转换为UTC】
puts time.getlocal          #2018-07-07 13:57:50 +0800  【备注】返回本地时区中一个新的Time对象
puts time.getutc            #2018-07-07 06:03:31 UTC    【备注】返回utc中一个新的Time对象
puts time                   #2018-07-07 05:59:47 UTC
puts time.zone
puts time.utc_offset
puts time.isdst
puts time.utc?
time.localtime         # 转换回本地时间
puts time.getlocal
puts time.getutc
=begin
CST
28800
CST
false
false
2018-07-07 14:05:03 +0800
2018-07-07 14:05:03 +0800
2018-07-07 06:05:03 UTC
2018-07-07 06:05:03 UTC
UTC
0
false
true
2018-07-07 14:05:03 +0800
2018-07-07 06:05:03 UTC
=end

# 【格式化时间和日期】
time = Time.now

puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime('%Y-%m-%d %H:%M:%S')
=begin
Sat Jul  7 14:09:16 2018
2018-07-07 14:09:16 +0800
2018-07-07 14:09:16
=end

=begin
时间格式化指令
下表所列出的指令与方法 Time.strftime 一块儿使用。
指令 描述
%a 星期几名称的缩写（好比 Sun）。
%A 星期几名称的全称（好比 Sunday）。
%b 月份名称的缩写（好比 Jan）。
%B 月份名称的全称（好比 January）。
%c 优选的本地日期和时间表示法。
%d 一个月中的第几天（01 到 31）。
%H 一天中的第几小时，24 小时制（00 到 23）。
%I 一天中的第几小时，12 小时制（01 到 12）。
%j 一年中的第几天（001 到 366）。
%m 一年中的第几月（01 到 12）。
%M 小时中的第几分钟（00 到 59）。
%p 子午线指示（AM 或 PM）。
%S 分钟中的第几秒（00 或 60）。
%U 当前年中的周数，从第一个星期日（做为第一周的第一天）开始（00 到 53）。
%W 当前年中的周数，从第一个星期一（做为第一周的第一天）开始（00 到 53）。
%w 一星期中的第几天（Sunday 是 0，0 到 6）。
%x 只有日期没有时间的优先表示法。
%X 只有时间没有日期的优先表示法。
%y 不带世纪的年份表示（00 到 99）。
%Y 带有世纪的年份。
%Z 时区名称。
%% % 字符。
=end

# 【时间算法】
now = Time.now
puts now

past = now - 10
puts past

future = now + 10
puts future

diff = future - now
puts diff
=begin
2018-07-07 14:14:17 +0800
2018-07-07 14:14:07 +0800
2018-07-07 14:14:27 +0800
10.0
=end

# 【【Ruby 范围】】
=begin
1. 做为序列的范围
2。做为条件的范围
3。做为间隔的范围
=end

# 【做为序列的范围】
$, = ","  # Array 值分隔符
range1 = (1..10)
puts "#{range1}"            #1..10
puts range1                 #1..10
range1_1 = range1.to_a
puts "#{range1_1}"          #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

range2 = ('bar'..'bat').to_a
puts "#{range2}"            #["bar", "bas", "bat"]

# 例子  遍历
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
=begin
最小值：0
最大值：9
不符合条件的是：[5, 6, 7, 8, 9]
在循环中： 0
在循环中： 1
在循环中： 2
在循环中： 3
在循环中： 4
在循环中： 5
在循环中： 6
在循环中： 7
在循环中： 8
在循环中： 9
=end

#【做为条件的范围】
score = 70

result = case score
         when 0..40
           "糟糕的分数"
         when 41..60
           "快要及格"
         when 61..70
           "及格分数"
         when 71..100
           "良好分数"
         else
           "错误的分数"
         end

puts result  #及格分数

#【做为间隔的判断】
if ((1..5) === 5)
  puts "5 在 (1..5) 里"
end

if (('a'..'j') === 'c')
  puts "c 在 ('a'..'j') 里"
end

if (('a'..'j') === 'z')
  puts "z 在 ('a'..'j') 里"
end
=begin
5 在 (1..5) 里
c 在 ('a'..'j') 里
=end

#【【迭代器】】each collect
# 迭代器是集合支持的方法。在Ruby中，数组和哈希能够称之为集合。迭代器返回集合的全部元素。

# 【each】
ary = [1,2,3,4,5]
ary.each do |i|
  puts i
end
print "****************\n"
puts ary
=begin
1
2
3
4
5
****************
1
2
3
4
5
=end

# 【collect】
a = [1,2,3]
b = a.collect{|x|x}
puts b
=begin
1
2
3
=end

#例子
a = [1,2,3]
b = a.collect{|x| 10 * x}
puts "#{b}"         #[10, 20, 30]

#【【文件的输入与输出】】
=begin
Ruby提供了一整套I/O相关的方法，在内核(Kernel)模块中实现。全部的I/O方法派生自I／O类。
=end

# 【gets】
=begin
puts 'enter a value:'
value = gets
puts value
=end

#【putc】puts输出整个字符串到屏幕上。putc一次输出一个字符。
str = 'Hello Ruby!'
putc str     #H
putc "\n"

#【打开和关闭文件】
=begin
模式 描述
r  只读模式。文件指针被放置在文件的开头。这是默认模式。
r+ 读写模式。文件指针被放置在文件的开头。新写入的覆盖原有的。
w  只写模式。若是文件存在，则重写文件。若是文件不存在，则建立一个新文件用于写入。
w+ 读写模式。若是文件存在，则重写已存在的文件。若是文件不存在，则建立一个新文件用于读写。
a  只写模式。若是文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。若是文件不存在，则建立一个新文件用于写入。
a+ 读写模式。若是文件存在，则文件指针被放置在文件的末尾。也就是说，文件是追加模式。若是文件不存在，则建立一个新文件用于读写。
=end

aFile = File.new('input.txt','r') # input.txt 内容
if aFile
  content = aFile.sysread(20)
  puts content
else
  puts 'unable to open file!'
end
#This is a sample tex  【备注】输入文件的头20个字符，文件指针将被放置在文件中第21个字符的位置。

# 【syswrite方法】

aFile = File.new('input.txt','r+')
if aFile
  aFile.syswrite('ABCDEFG')
else
  puts 'unable to open file!'
end
# 如今文件内容 ABCDEFG a sample text file for testing perpose.


# 【each_byte】
# 当前文件内容 this is a sample text file for testing perpose.

aFile = File.new('input.txt','r+')
if aFile
  aFile.syswrite('ABCDEF')
  aFile.rewind
  #aFile.each_byte {|ch| putc ch;putc ?.}         #【备注】这一句与下面一句是等价的
  aFile.each_byte {|ch| putc ch;putc '.'}
else
  puts 'unable to open file!'
end
=begin
文件内容：ABCDEFG a sample text file for testing perpose.
控制台打印：
A.B.C.D.E.F.G. .a. .s.a.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.e.r.p.o.s.e...
.
=end

# 练习
putc "\n"
putc 'a';
putc ?.
putc '.'
putc "\n"
=begin
a..
=end

#【IO readlines方法】逐行返回

=begin
此时文件的内容：
ABCDEFG a sample text file for testing perpose.
这是第二行。
=end
arr = IO.readlines('input.txt')
puts arr[0]
puts arr[1]
=begin
ABCDEFG a sample text file for testing perpose.
这是第二行。
=end

# 【IO foreach方法】与IO.readlines方法不一样的是，IO.foreach方法与块关联
# #例子   将把文件 test 的内容逐行传给变量 block，而后输出将显示在屏幕上
# =begin
# 此时文件的内容：
# ABCDEFG a sample text file for testing perpose.
# 这是第二行。
# =end
IO.foreach('input.txt'){|block| puts block}
=begin
ABCDEFG a sample text file for testing perpose.
这是第二行。
=end

#【重命名和删除文件】 rename  delete
File.rename('input.txt','input.txt')
#此时看到已经变名字了
File.rename('input.txt','input.txt')
#此时看到名字已经改回来了

# 【文件查询】
# 打开文件前，检查文件是否已存在
File.open('a.txt') if File::exists?('a.txt')

# 查询文件是不是一个文件
puts File.file?('input.txt')                        #true

# 检查给定的文件名是不是一个目录
puts File::directory?('/usr/local/bin')     #true
puts File::directory?('input.txt')          #false

# 检查文件是否可读、可写、可执行
puts File.readable?('input.txt')            #true
puts File.writable?('input.txt')            #true
puts File.executable?('input.txt')          #false

# 检查文件大小是否为0
puts File.zero?('input.txt')                #false

# 返回文件大小
puts File.size?('input.txt')                #67

# 检查文件的类型
puts File.ftype('input.txt')                #file
=begin
ftype 方法经过返回下列中的某个值来标识了文件的类型：file、 directory、 characterSpecial、 blockSpecial、 fifo、 link、 socket 或 unknown。
=end

# 文件被建立、修改、最后访问的时间
puts File::ctime('input.txt')
puts File::mtime('input.txt')
puts File::atime('input.txt')

# 【【Ruby中的目录】】全部文件都包含在目录中。File 处理文件。Dir 处理目录。

# 查看当前目录
puts Dir.pwd                    #/Users/suren/RubymineProjects/ruby_test_one

# 获取指定目录内的文件和目录列表
puts Dir.entries('/Users/suren/RubymineProjects/ruby_test_one')
=begin
  返回一个数组
.
..
.idea
arith.rb
class_and_obj.rb
data.rb
grammer.rb
input.txt
moral.rb
support.rb
test_one.rb
trip.rb
x.rb
=end
puts Dir.entries('/Users/suren/RubymineProjects/ruby_test_one').join(' ')
#. .. .idea arith.rb class_and_obj.rb data.rb grammer.rb input.txt moral.rb support.rb test_one.rb trip.rb x.rb

# Dir.foreach返回一个数组，包含指定目录内的全部项，同Dir.entries
Dir.foreach('/Users/suren/RubymineProjects/ruby_test_one') do |entry|
  puts entry
end
=begin
.
..
.idea
arith.rb
class_and_obj.rb
data.rb
grammer.rb
input.txt
moral.rb
support.rb
test_one.rb
trip.rb
x.rb
=end

# 建立目录
#Dir.mkdir('aa',755)  # 还能够顺便设置文件的权限

# 建立文件 & 临时目录
=begin
临时文件是那些在程序执行过程当中被简单地建立，但不会永久性存储的信息。
Dir.tmpdir 提供了当前系统上临时目录的路径，可是该方法默认状况下是不可用的。能够把Dir.tmpdir 和 File.join 一块儿用，建立一个独立于平台的独立文件
=end

# 例子
require 'tmpdir'
tempfilename = File.join(Dir.tmpdir,'tingtong')
puts tempfilename           # 本次执行结果： /var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong
tempfile = File.new(tempfilename,'w')
tempfile.puts "This is a temporary file"
tempfile.rewind
tempfile_for_read = File.new(tempfilename,'r')
value = tempfile_for_read.sysread(30)
puts value
tempfile.close
tempfile_for_read.close
File.delete(tempfilename)
=begin
/var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong
This is a temporary file
=end

#例子 Ruby的标准库包含了Tempfile,可用于建立临时文件
require 'tempfile'
f = Tempfile.new('tingtong4')
f.puts "Hello Ruby!"
puts f.path             # 当前执行结果：/var/folders/7b/v65b2_394_jdz_24k80htg840000gn/T/tingtong420180707-60134-1g73o9p
f.close

# 【【Ruby异常】】
=begin
从 begin 到 rescue 中的一切是受保护的。若是代码块执行期间发生了异常，控制会传到 rescue 和 end 之间的块。
对于 begin 块中的每一个 rescue 子句，Ruby 把抛出的异常与每一个参数进行轮流比较。若是 rescue 子句中命名的异常与当前抛出的异常类型相同，或者是该异常的父类，则匹配成功。
若是异常不匹配全部指定的错误类型，咱们能够在全部的 rescue 子句后使用一个 else 子句
=end

# 例子
begin
   file = open("/unexistant_file")
   if file
      puts "File opened successfully"
   end
rescue
      file = STDIN
end
#puts  "#{file}==#{STDIN}\n"               ##<IO:0x007f9c6409c718>==#<IO:0x007f9c6409c718>

begin #开始
  #试图打开一个不存在的文件，注意，其实直接调用open也能够！Ruby实在太乱了！不过 open 返回的是File对象而不是文件内容
  file = open('/cygdrive/d/workspace/notexists')
  if file
    puts "文件打开正常，path=#{file.path}"
  end
rescue Errno::ENOENT => e #文件打不开的具体异常类型是这种，很奇怪把！
  #STDIN 是标准输入，此处意思是若是拿不到File对象就用标准输入对象代替，并无什么特别的用意
  file = STDIN
  puts "这是一种Errno::ENOENT"
  puts
  #用 e.inspect能够看到具体的异常类型
  puts "e.inspect #{e.inspect}"
  puts
  # 用 e.message 能够打印出信息
  puts "e.message: #{e.message}"
  puts
  #用 e.backtrace.inspect 能够打印出堆栈
  puts "e.backtrace.inspect: #{e.backtrace.inspect}"
  puts
  puts "异常信息: #{$!}"
  puts
  puts "异常代码位置: #{$@}"
rescue StandardError => e #获取e对象
  #STDIN 是标准输入，此处意思是若是拿不到File对象就用标准输入对象代替，并无什么特别的用意
  file = STDIN
  puts "这是一种StandardError" #默认都是StandardError
rescue => e #还能够直接不写类型，意思是全部类型，至关于else了
  #STDIN 是标准输入，此处意思是若是拿不到File对象就用标准输入对象代替，并无什么特别的用意
  file = STDIN
  puts "不知道是什么类型的Error"
ensure
  puts "怎样都会进入的代码"
end #结束

#逗号隔开并非连在一块儿输出，而是屡次调用print方法的意思
print file, " == ", STDIN
=begin
这是一种Errno::ENOENT

e.inspect #<Errno::ENOENT: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists>

e.message: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists

e.backtrace.inspect: ["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `initialize'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `open'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]

异常信息: No such file or directory @ rb_sysopen - /cygdrive/d/workspace/notexists

异常代码位置: ["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `initialize'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `open'", "/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:3:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
怎样都会进入的代码
#<IO:0x007fcbe909c718> == #<IO:0x007fcbe909c718>
=end



# 【retry】
begin
  file = open('/unexistant_file')
  if file
    puts "File opened successfully"
  end
rescue
  filename = open('input.txt')
  retry
end
puts filename

# 【retry】
#例子  死循环了
=begin
begin
  file = open('/unexistant_file')
  if file
    puts "File opened successfully"
  end
rescue
  filename = open('/input.txt')
  retry
end
puts filename
=end

# 例子 针对上面例子的解决方案

aa = 'input1.txt'
begin
  file = open($aa)
  if file
    puts 'file opened successfully'
  end
rescue
  $aa = 'input.txt'
  retry
end
puts file


=begin
如下是处理流程：
打开时发生异常。
跳到 rescue。fname 被从新赋值。
经过 retry 跳到 begin 的开头。
此次文件成功打开。
继续基本的过程。
注意：若是被从新命名的文件不存在，本实例代码会无限尝试。因此异常处理时，谨慎使用 retry。

【备注】我这里并未打印出任何内容
=end

# 【raise】
=begin
语法
raise

或

raise "Error Message"

或

raise ExceptionType, "Error Message"

或

raise ExceptionType, "Error Message" condition
第一种形式简单地从新抛出当前异常（若是没有当前异常则抛出一个 RuntimeError）。这用在传入异常以前须要解释异常的异常处理程序中。
第二种形式建立一个新的 RuntimeError 异常，设置它的消息为给定的字符串。该异常以后抛出到调用堆栈。
第三种形式使用第一个参数建立一个异常，而后设置相关的消息为第二个参数。
第四种形式与第三种形式相似，您能够添加任何额外的条件语句（好比 unless）来抛出异常。
=end


# 例子

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'
=begin
I am before the raise
I am rescued.
I am after the begin block
=end

#例子
begin
  raise 'A test Exception.'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
end
=begin
A test Exception.
["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:70:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
=end

# 【ensure】至关于finally

begin
  raise 'A Test Exception'
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
ensure
  puts 'Ensuring execution'

end
=begin
A Test Exception
["/Users/suren/RubymineProjects/ruby_test_one/test_one.rb:83:in `<top (required)>'", "-e:1:in `load'", "-e:1:in `<main>'"]
Ensuring execution
=end

# 【else】只有在代码主体未抛出异常时执行
# 例子
begin
  puts "I'm not  raising exeception."
rescue Exception => e
  puts e.message
  puts e.backtrace.inspect
else
  puts "Congratuations-- no errors!"
ensure
  puts 'Ensuring execution'
end

=begin
I'm not  raising exeception.
Congratuations-- no errors!
Ensuring execution
=end


#throw/cathc
#例子


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

catch :quitReques do
## 首先进入catch块中，这是第一句被执行的，进入quitRequested方法，若是不输入感叹号，就不throw,直接返回调用处，这一行返回结果给name变量。而后接着执行catch中的下一行，直到readline.chmop接收到一个感叹号，此时会抛出异常，catch不会接，只会终止。
  name = promptAndGet('Name:')
  age = promptAndGet('age:')
  sex = promptAndGet('sex:')
end

promptAndGet('Name11:')
"""
'''
Name:wxue
age:er
sex:femail
Name11:wxue
'''


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

catch :quitReques do
  name = promptAndGet('Name:')
  age = promptAndGet('age:')
  sex = promptAndGet('sex:')
end

promptAndGet('Name11:')
"""
"""
Name:wxue
age:23
sex:femail
Name11:!
/Users/suren/RubymineProjects/ruby_test_one/x.rb:31:in `throw': uncaught throw :quitRequested (UncaughtThrowError)
from /Users/suren/RubymineProjects/ruby_test_one/x.rb:31:in `promptAndGet'
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:41:in `<top (required)>'
 from -e:1:in `load'
from -e:1:in `<main>'
"""

#例子
"""
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('Name11:')
"""
"""
Name:wxue
age:23
sex:femail
Name11:!
/Users/suren/RubymineProjects/ruby_test_one/x.rb:85:in `throw': uncaught throw :quitRequested (UncaughtThrowError)
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:85:in `promptAndGet'
 from /Users/suren/RubymineProjects/ruby_test_one/x.rb:94:in `<top (required)>'
 from -e:1:in `load'
 from -e:1:in `<main>'
"""

#例子
"""
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('Name11:')
"""
'''
Name:wxue
age:er
sex:femail
Name11:wxue
'''
#【备注】Ruby和其余语言不太同样，这里throw。。catch，不是主要处理异常的，而能够理解成控制流程的。




# 【类Exception】
=begin
Ruby 的标准类和模块抛出异常。全部的异常类组成一个层次，包括顶部的 Exception 类在内。下一层是七种不一样的类型：
Interrupt
NoMemoryError
SignalException
ScriptError
StandardError
SystemExit
Fatal 是该层中另外一种异常，可是 Ruby 解释器只在内部使用它。
ScriptError 和 StandardError 都有一些子类，可是在这里咱们不须要了解这些细节。最重要的事情是建立咱们本身的异常类，它们必须是类 Exception 或其子代的子类
=end

#例子 
=begin

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

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

a = FileSaveError.new('abc')
p a.reason    #abc


=end

# 【Ruby】【Symbol】
p :foo.object_id

p :foo.object_id

p :"foo".object_id

p :'foo'.object_id

p "foo".object_id

p "foo".object_id

p 'foo'.object_id

p 'foo'.object_id
=begin

2002
2002
2002
2002
2004
2006
2008
2010
=end

# 【:: 和 :】
# :: 是 引用或调用各类对象（Ruby中一切皆对象）: 是symbol
# ::例子  【若是 Foo::小写(new,test)---->就去需找方法 若是 Foo::大写(A,VERSION)--->就去寻找常量】
class Mao
  PPP='aaaaa'
  def ppp
    puts "maohaofu"
  end

end
def maomao
  puts ::Mao.new::ppp
  puts ::Mao:: new::ppp # 和上一行同样效果
  puts ::Mao::PPP
end
maomao()
=begin
这样会不会明白些

输出

maohaofu

maohaofu

aaaaa
=end



# : 例子
=begin

Symbol 是什么
Ruby 是一个强大的面向对象脚本语言（本文所用 Ruby 版本为1.8.6），在 Ruby 中 Symbol 表示“名字”，好比字符串的名字，标识符的名字。
建立一个 Symbol 对象的方法是在名字或者字符串前面加上冒号：

建立 symbol 对象

:foo
:test

:”abc”
:”I am a boy”

你可能会问，字符串就是字符串，干嘛还有字符串的名字？这是由于在 Ruby 中字符串也是一种对象，即 String 对象。不管其结构仍是操做和 Symbol 对象都是不一样的。
在 Ruby 中每个对象都有惟一的对象标识符（Object Identifier），能够经过 object_id 方法来获得一个对象的标识符。咱们来看看 Symbol 对象和 String 对象的差异：

Ruby 对象标识符

irb(main):001:0> puts :foo.object_id
327458
=> nil
irb(main):002:0> puts :foo.object_id
327458
=> nil
irb(main):003:0> puts :"foo".object_id
327458
=> nil
irb(main):004:0> puts "foo".object_id
24303850
=> nil
irb(main):005:0> puts "foo".object_id
24300010
=> nil
irb(main):006:0> puts "foo".object_id
24296170
=> nil

能够看到，前三行语句中的 :foo （或者 :"foo"）都是同一个 Symbol 对象，其 object id 为327458，然后三行中的字符串”foo”都是不一样的对象，其 object id 依次为24303850、243000十、24296170。
可见，每一个 String 对象都是不一样的，即使他们包含了相同的字符串内容；而对于 Symbol 对象，一个名字（字符串内容）惟一肯定一个 Symbol 对象。
值得注意的是建立 Symbol 对象的字符串中不能含有’\0’字符，而 String 对象是能够的。

非法 Symbol 字符串

irb(main):001:0>  :"fo\0o"
SyntaxError: compile error
(irb):1: symbol cannot contain '\0'
from (irb):1
irb(main):002:0> :"foo\0"
SyntaxError: compile error
(irb):2: symbol cannot contain '\0'
from (irb):2
irb(main):003:0> puts "foo\0".object_id
24305140
=> nil
irb(main):004:0> puts "fo\0o".object_id
24301000
=> nil
irb(main):005:0>

    除了能够采用通常的字符串，还可使用操做符（例如+, -, *, /），变量，常量，方法甚至类的名字来建立Symbol 对象，例如:+就是一个合法的 Symbol 。实际上，在 Ruby 内部操做符、变量等名字自己就是做为Symbol 处理的，例如当你定义一个实例变量时， Ruby 会自动建立一个 Symbol 对象，例如 @test 对应为 :@test 。

实例变量的 Symbol
                
class Test     
 attr_accessor :test
end
 
这个类定义了一个具备读写方法的实例变量 @test 。实际上 Ruby 建立了两个 Symbol ，一个是实例变量的symbol :@test ，另外一个是 :test 。那若是使用字符串对象 ”test” 做为参数呢？也能够，仍然会建立两个 symbol，:test 和 :@test ，为何还会建立 :test 呢？这是和Ruby的实现相关的（至少Ruby1.8.6里是这样）。
注意，类变量 @@test 和实例变量 @test 对应的 Symbol 显然是不一样的。记住：名字相同，则Symbol 相同。

名字相同， Symbol 相同
                
class Test     
  puts :Test.object_id
  Test = 10
  puts :Test.object_id
  
  def Test       
    puts :Test.object_id
  end  
end 

Test.new.Test


运行结果
                
224298
224298
224298


名字不一样， Symbol 不一样
                
class Test     
  puts :Test.object_id

  @@test = 10
  puts :@@test.object_id
  def test       
    puts :test.object_id
    @test = 10      
    puts :@test.object_id

  end  
end 

t =Test.new  
t.test  


运行结果
                
224298
288068
79858
288108
 
第一个例子里，类名、常量名和方法名都是 Test ，所以相应的 Symbol 对象都是 :Test 。不用担忧， Ruby 能够很好区分它在不一样上下文中到底表示什么。固然这并非一个好的编程风格，但对于理解 Ruby 的 Symbol仍是有帮助的： Symbol 表示一个名字，仅此而已。
Symbol 对象一旦定义将一直存在，直到程序执行退出。全部 Symbol 对象存放在 Ruby 内部的符号表中，能够经过类方法Symbol.all_symbols 获得当前 Ruby 程序中定义的全部 Symbol 对象，该方法返回一个 Symbol 对象数组。因为 Symbol 比较多，你能够 dump 到文件中来查看。

all_symbols 方法
                
irb(main):001:0> Symbol.all_symbols.size
=> 4047
irb(main):002:0> Symbol.all_symbols[0..9]
=> [:@level_notifier, :ppx, :msg_dn, :version, :secs, :@user, :pos, :socketpair,
 :TkENSURE, :HTTPAccepted]
irb(main):003:0> File.open("sym", "w") do |file| file.puts Symbol.all_symbols end
=> nil
 
 
Symbol 和 String
Symbol 对象和 String 对象是彻底不一样的东西，对象标识符很明确的说明了这一点。除此以外，咱们还能够从两种对象的方法上区分。
查看 Ruby 库参考，你会发现 String 类有很是多的方法，包括 Mixed-in 方法（Ruby中一个类经过 include 其余模块而获得的方法，实现多重继承的效果）、类方法和实例方法；而 Symbol 类只有一个类方法 all_symbols 和7个实例方法。
例如，能够经过 []= 方法改变 string 的内容，而 symbol 则不行：

[]= 方法比较
                
irb(main):001:0> s="test"
=> "test"
irb(main):002:0> s[0]='1'
=> "1"
irb(main):003:0> puts s
1est
=> nil
irb(main):004:0> sym=:test
=> :test
irb(main):005:0> sym[0]=1
NoMethodError: undefined method `[]=' for :test:Symbol
        from (irb):5
irb(main):006:0>
 
虽然 Symbol 和 String 是不一样的对象，但它们之间关系很密切。 Ruby 提供了方法在 Symbol和 String 之间转换。
Symbol 转化为 String
使用 to_s 或 id2name 方法将 Symbol 转化为一个 String 对象：

Symbol 到 String
                
irb(main):001:0> :test.id2name
=> "test"
irb(main):002:0> :test.to_s
=> "test"
irb(main):003:0> :"I am a boy".to_s
=> "I am a boy"
 
注意，每一个 String 对象都是惟一的，所以对一个 Symbol 调用屡次将产生多个 String 对象。
String 转化为 Symbol
除了在字符串前面加冒号，还可使用 to_sym 或 intern 方法将 String 转化为 Symbol ，若是该 Symbol 已经存在，则直接返回。

String 到 Symbol
                
irb(main):001:0> var1 = "test".to_sym
=> :test
irb(main):002:0> var2 = "test".intern
=> :test
irb(main):003:0> var1 == var2
=> true
irb(main):004:0>
 
 
使用 Symbol
正如前边提到的， Ruby 内部一直在使用 Symbol ，好比 Ruby 程序中的各类名字，Symbol本质上是 Ruby 符号表中的东西。使用 Symbol 处理名字能够下降 Ruby 内存消耗，提升执行速度，这点咱们在下一篇文章中会看到。
那么 Symbol 对咱们有什么用呢？固然也是内存。使用 String 的开销太大了，由于每个String 都是一个对象。想一想前边的例子，一个字符串每出现一次 Ruby 就会建立一个 String 对象。
一般来说，当你面临 String 仍是 Symbol 的选择时，能够参考如下标准：
若是使用字符串的内容，这个内容可能会变化，使用 String
若是使用固定的名字或者说是标识符，使用 Symbol
那么何时咱们会用到名字呢？不少时候都会，好比枚举值、关键字（哈希表关键字、方法的参数）等等
做为哈希表的 key
哈希表是 Symbol 应用最为普遍的地方。
在ruby中，哈希和数组相似，一个哈希表是一系列 key/value 对的集合，只不过它的 key 取值范围更普遍，能够是任何对象，好比正则表达式。但一般咱们都会取有意义的 key ，好比 String、Symbol 。
下面这个哈希表表示按城市分类的一些机器的集合。

一个哈希表例子

hosts{
  'beijing' => 'machine1',
      'shanghai'  => 'machine2',
      'guangzhou' => 'machine3',
      'tianjin' =>  'machine4',
      'shenzhen' =>　'machine5'
}

若是要引用 beijing 的机器，使用 hosts['beijing'] 。但若是咱们程序中要频繁引用哈希表中 value ，这样就不大好了，由于 Ruby 对每一次字符串引用都会生成一个 String 对象，累积下来这个开销是至关大的。
咱们彻底可使用 Symbol ，由于对于这些 key 来说，咱们用的就是名字而已，例以下面hosts[:beijing]


使用 Symbol 做为 key

hosts　=　{
  　:beijing　=>　'machine1',
               　:shanghai　=>　'machine2',
                             　:guangzhou　=>　'machine3',
                                            　:tianjin 　=>　'machine4',
                                                          　:shenzhen　=>　'machine5'
}

哈希参数
一般咱们定义的函数的参数的个数和顺序是写死的，调用函数的时候要确保参数的个数、顺序匹配，有时候这样很不方便，使用哈希参数能够解决这个问题。
ROR 中就大量地运用这种方式，也许你已经看到了，处处都是 Symbol 和哈希。好比：

使用哈希参数的方法调用

link_to 'Show', :action => 'show', :id => product

add_column :products, :price, :decimal,
           :precision => 8, :scale => 2, :default => 0

使用哈希参数的方法能够以下定义，前半部分为固定参数，后面为可变参数，或者干脆全采用哈希参数：

哈希参数

def my_method(para1, …, options={})
#your code
end

def my_method(options={})
#your code
end

若是你但愿设定一些默认参数，并容许调用者更改这些参数，可使用哈希对象的 merge! 方法
hsh.merge!( other_hash )。该方法将 other_hash 里内容加到 hsh 中，若是other_hash 与 hsh 有重复的 key ，则 key在 other_hash 中的 value 覆盖 hsh 中对应 key 的 value 。

方法定义-使用默认参数

class Test
  def my_method(opts={})
    default_opts={:arg1 => 10, :arg2 => "abc"}
    default_opts.merge!(opts)
    default_opts.each{|key,value| puts "#{key} is #{value}"}
  end
end

t = Test.new
t.my_method :arg1=>5, :arg3=>"def"


运行结果

arg1 is 5
arg2 is abc
arg3 is def

原文参考地址：https://blog.csdn.net/besfanfei/article/details/7966850

# 别的网站的讲解
Symbol看起来像一个没有引号的字符串前加了个冒号:myname
固然你也能够用冒号加引号的形式声明带空格的symbol。
:'my name'or :"my name" Symbol是不变的，不能够像其余变量同样对它进行赋值运算。
好比这样的写法是错误的:myname = "Tom"。 相反Symbol能够做为值赋给其余变量好比mystring = :myname。

=end



【【其余文件】】

# 【chop & chomp】
=begin
还没开始系统性的学习Ruby，最近在看metasploit框架的exploit会涉及到Ruby脚本，也就硬着头皮一遍查阅资料一遍作些笔记吧。

Ruby字符串中存在chop和chomp的内置函数。我在http://www.w3cschool.cc/ruby/ruby-string.html中获得的关于Ruby字符串chop和chomp的用法介绍以下：


str.chomp
从字符串末尾移除记录分隔符（$/），一般是 \n。若是没有记录分隔符，则不进行任何操做。
str.chomp!
与 chomp 相同，可是 str 会发生变化并返回。
str.chop
移除 str 中的最后一个字符。
str.chop!
与 chop 相同，可是 str 会发生变化并返回。
单从这几句话，仍是有些不明白（貌似借鉴于perl语言中的chop和chomp函数的用法），而后百度了一下，我在http://blog.chinaunix.net/uid-20691105-id-1568659.html获得以下内容：


chomp和chop的区别:
    chomp:去掉字符串末尾的\n或\r
chop:去掉字符串末尾的最后一个字符,无论是\n\r仍是普通字符
"hello".chomp            #=> "hello"
"hello\n".chomp          #=> "hello"
"hello\r\n".chomp        #=> "hello"
"hello\n\r".chomp        #=> "hello\n"
"hello\r".chomp          #=> "hello"
"hello".chomp("llo")     #=> "he"
"string\r\n".chop   #=> "string"
"string\n\r".chop   #=> "string\n"
"string\n".chop     #=> "string"
"string".chop       #=> "strin"

首先，能够看到print是不输出换行符的（不会自动换行），可是会解析双引号中的转义字符，
能够看到print输出了字符串中的换行符\n和回车符\r。我以前有点迷惑的是“\r\n”,“\n\r”这两个先后顺序不一样时，
chop和chomp函数是如何处理的。从运行的结果看，当字符串最后面跟的是“\r\n”时，”\r\n”都会被去掉，
而当字符串最后面跟的是”\n\r”时，只会去掉回车符。好吧，总算是明白了。
=end


input.txt

suport.rb:

module Week
  FIRST_DAY = 'Sunday'
  def Week.week_in_month
    puts 'you have four weeks in a month'
  end
  def Week.week_in_year
    puts 'you have 52 weeks in a year'
  end
end

moral.rb:

module Moral
  VERY_BAD = 0
  BAD = 1
  def Moral.sin(badness)

  end
end

#【控制流程】【循环语句】5.times{  |i|  print "这是第",i,"次","\n"}3.times{  print "hi"}print "\n"1.upto(9){  |i|  print i if i < 7}print "\n"9.downto(1){  |i|  print i if i < 7}print "\n"(1..9).each{  |i|  print i if i < 7}print "\n"0.step(11,3){  |i|  print i}print "\n"1.step(11,3){  |i|  print i}=begin这是第0次这是第1次这是第2次这是第3次这是第4次hihihi123456654321123456036914710=endprint "\n"#【【循环控制】】i = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    break  end  p [i,lang]}=begin[1, "Perl"][2, "Python"]=endi = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    redo  end  p [i,lang]}=begin[1, "Perl"][2, "Python"][4, "Ruby"][5, "Scheme"]=endi = 0['Perl','Python','Ruby','Scheme'].each{  |lang|  i += 1  if i == 3    next  end  p [i,lang]}=begin[1, "Perl"][2, "Python"][4, "Scheme"]=end#【【数据类型】】#例子 数值类型的相互转换puts 12.to_f                          #12.0puts 12.0.to_i                        #12#例子 字符串和数值的相互转化puts "12.34estts".to_f                #12.34puts "12.34esdff".to_i                #12puts 12.34.to_s                       #"12.34"puts 12.to_s                          #12#浮点数的处理 四舍五入p 1.2.round                           #1p 1.8.round                           #2p -1.2.round                          #-1p -1.8.round                          #-2#浮点数、进位取整。。p 1.5.ceil                            #2p -1.5.ceil                           #-1#返回小于或等于num的最大整数p 1.5.floor                           #1p -1.5.floor                          #-2#【数组】#初始化#B = []#B = Array.new                         #Array#p B.class#数组的获取B = [1,2,3]p B[0]        #1p B[1]        #2#数组运算和经常使用函数#& 交集p [1,1,3,5]&[1,3]                     #[1, 3]# *p [1,2,3] * 3p [1,2,3] * ' - 'p [1,2,3] * " - "=begin[1, 2, 3, 1, 2, 3, 1, 2, 3]"1 - 2 - 3""1 - 2 - 3"=end# + 串联p [1,2,3] + [4,5]                   #[1, 2, 3, 4, 5]p [1,2,3,4] + [4,5]                 #[1, 2, 3, 4, 4, 5]# - 数组差集 ：返回新数组，该数组是原数组的拷贝，并删除了出现再other_array中的元素p [1,1,2,2,3,3,4,5] - [1,2,4]       #[3, 3, 5]# << 将给定的对象添加到数组的末尾p [1,2] << "c" << "d" << [4,5]     #[1, 2, "c", "d", [4, 5]]a = [1,2,3,2,1]a.delete(2)p a           #[1, 3, 1]a = [1,2,3,2,1]a.delete_at(2)p a           #[1, 2, 2, 1]a = [1,[2,[3]],[4],5]a.flatten!p a           #[1, 2, 3, 4, 5]a = [2,5,3,5,1]a.sort!p a           #[1, 2, 3, 5, 5]#【字符串】#长度p "ruby".length     #4p "ruby".size       #4#分割字符串str = "hello world ! !"p str.split         #["hello", "world", "!", "!"]p str.split(" ")    #["hello", "world", "!", "!"]#字符串去空格str = "hello world ! !"p str.strip          #正常应该是"helloworld!!"str = "hello world ! !"p str.strip!         #正常应该是"helloworld!!"#字符串替换str = "hello world  !!"p str.sub("!","ruby")   #"hello world  ruby!"str = "hello world !!"p str.gsub("!","ruby")  #"hello world rubyruby"# 字符串的运算# *p "Ho" * 3            #"HoHoHo"p "hello" + "world"   #"helloworld"# << 把给定的对象串联到str 若是这个对象是一个值在0~255之间的fixnum，在串联以前会把它转成一个字符a = "hello"p a << 33p a << "world"# 索引，相似数组str = "abcdef"p str[0]          #"a"p str[0].chr      #"a"p str[2]          #"c"p str[2].chr      #"c"p str[1,2]        #"bc"p str[1,3]        #"bcd"#【哈希】#初始化h = {"R" => "Ruby"}hash2 = Hash.newp h["R"]            #"Ruby"#哈希的元素能够是哈希，但哈希的键是惟一的table = {"A" => {"a" => "x","b" => "y"},"B" => {"a" => "v","b" => "w"}}p table["A"]["a"]    #"x"p table["B"]["a"]    #"v"#删除元素h = {"R" => "Ruby"}h.delete("R")p h                   #{}p h["R"]              #nil#大小h = {"a" => "b","c" => "d"}p h.length            #2p h.size              #2#【【正则】】#匹配str = "hello,kaichuan,Welcome!"p str =~ /kaichuan/         #6p str =~ /a/                #7p str =~ /ABC/              #nil#不匹配str = "hello,kaichuan,Welcom!"p str !~ /kaichuan/         #falsep str !~ /a/                #falsep str !~ /ABC/              #true

# 知识点参考地址：https://blog.csdn.net/tse_e/article/details/54930073