2.1 Ruby是一门面向对象语言
Ruby是真正的面向对象语言。
类是状态和使用这些状态的方法的组合。
对象 = 类的实体
在Ruby中，通过调用构造函数来创建对象，这是一种与类相关联的特殊方法。标准的构造函数是new。
每个对象有一个唯一的对象标识符(Object ID)。
方法是通过向对象发送消息来唤起调用的。
C:\Users\John>irb
irb(main):001:0> "gin joint".length
=> 9
irb(main):002:0> "Rick".index("c")
=> 2
irb(main):003:0> -1945.abs
=> 1945
2.2 Ruby的一些基础知识
def say_goodnight(name)
result = "Good night, " + name
return result
end
# time for bed...
puts say_goodnight("John-Boy")
puts say_goodnight "Mary-Ellen"
运行结果：
E:\cloud\code\ruby>ruby method.rb
Good night, John-Boy
Good night, Mary-Ellen
只要每条语句放在单独的行上，就不需要在语句结束处加上分号。
Ruby注释以一个#字符开始，在行尾结束。
puts的功能就是输出其参数，后面跟一个回车换行符。
字符串字面量
irb(main):023:0> puts "And good night,\nGranma"
And good night,
Granma
=> nil
双引号字符串：字符串内的表达式内插（expression interpolation）,#{表达式}序列会被"表达式"的值替换。
def say_goodnight(name)
result = "Good night, #{name}"
return result
end
puts say_goodnight('Pa')
#输出结果
#Good night, Pa
def say_goodnight(name)
result = "Good night, #{name.capitalize}"
return result
end
puts say_goodnight('uncle')
#输出结果
#Good night, Uncle
如果表达式只是一个全局变量或类变量，则不需要提供花括号。
$greeting = "Hello" # $greeting是全部变量
@name = "Prudence" # @name是实例变量
puts "#$greeting,#@name"
Ruby方法所返回的值，是最后一个被求值的表达式的值。
def say_goodnight(name)
"Good night, #{name}"
end
puts say_goodnight('Ma')
Ruby使用一种命令惯例来区分名称的用途：名称的第一个字符显示这个名称如何被使用。
局部变量、方法参数、方法名称：小写字母或下划线
全局变量:$
实例变量：@
类变量：@@
类名、模块名、常量都必须以一个大写字母开始。
包含多个单词的实例变量名称在词与词之间使用下划线连接，包含多个单词的类变量名称使用混合大小写(每个单词首字母大写)。
2.3 数组和散列表
irb(main):001:0> a = [1, 'cat', 3.14] #有三个元素的数组
=> [1, "cat", 3.14]
#访问第一个元素
irb(main):002:0> a[0]
=> 1
irb(main):003:0> a[2]
=> 3.14
#设置第三个元素
irb(main):004:0> a[2] = nil
=> nil
# 显示这个数组
irb(main):005:0> a
=> [1, "cat", nil]
nil是一个对象，与别的对象一样，只不过它是用来表示没有任何东西的对象。
irb(main):009:0> a = ['ant', 'bee', 'cat', 'dog', 'elk']
=> ["ant", "bee", "cat", "dog", "elk"]
irb(main):010:0> a[0]
=> "ant"
irb(main):011:0> a[3]
=> "dog"
irb(main):012:0> a = %w{ant bee cat dog elk}
=> ["ant", "bee", "cat", "dog", "elk"]
irb(main):013:0> a
=> ["ant", "bee", "cat", "dog", "elk"]
inst_section = {
'cello' => 'string',
'clarinet' => 'woodwind',
'drum' => 'percussion',
'oboe' => 'woodwind',
'trumpet' => 'brass',
'violin' => 'string'
}
puts inst_section['oboe']
puts inst_section['cello']
puts inst_section['bassoon']
在条件表达式中nil意味着false。
irb(main):001:0> histogram = Hash.new(0)
=> {}
irb(main):002:0> histogram['key1']
=> 0
irb(main):003:0> histogram['key1'] = histogram['key1'] + 2
=> 2
irb(main):004:0> histogram['key1']
=> 2
2.4 控制结果
Ruby是使用end关键字来表明程序体的结束。
count = 1
tries = 2
if count > 10
puts "Try again"
elsif tries == 3
puts "You lose"
else
puts "Enter a number"
end
weight =0
num_pallets = 10
while weight < 100 and num_pallets <= 30
weight += rand(50)
num_pallets += 1
puts "weight:#{weight},num_pallets:#{num_pallets}"
end
大多数Ruby语句会返回值，这意味着可以把它们当条件使用。
gets方法从标准输入流返回下一行。
while line = gets
puts line.downcase
end
如果if或while语句的程序体只是一个表达式，Ruby的语句修饰符是一种有用的快捷方式。只要写出表达式，后面跟着if或while和条件。
radiation = 3001
if radiation > 3000
puts "Danger, Will Robinson"
end
radiation = 3001
puts "Danger, Will Robinson" if radiation > 3000
square = 2
while square < 1000
square = square * square
end
puts square
square = 2
square = square * square while square < 1000
puts square
2.5 正则表达式
在Ruby中，通常在斜线之间(/pattern/)编写模式(pattern)来创建正则表达式。
正则表达式是对象并且可以当做对象来操作。
irb(main):004:0> /Perl|Python/=~ 'python Perl'
=> 7
irb(main):005:0> /P(erl|ython)/=~ 'python Perl'
=> 7
irb(main):009:0> /ab+c/ =~ '123456abbc'
=> 6
irb(main):010:0> /ab+c/ =~ '123456abc'
=> 6
irb(main):011:0> /ab*c/ =~ '123456abc'
=> 6
irb(main):012:0> /ab*c/ =~ '123456ac'
=> 6
=~如果在字符串中发现了模式，返回模式的开始位置，否则返回nil，这意味着可以在if和while语句中把正则表达式当做条件使用。
line = 'this is Perl.'
if line =~ /Perl|Python/
puts "Scripting language mentioned: #{line}"
end
line = 'This is Ruby,but I want to learn Python.I love Python because google uses Python.'
puts line.sub(/Python/, 'Ruby') #用'Ruby'替换第一个'Python'
puts line.gsub(/Python/, 'Ruby') # 用'Ruby'替换所有的'Python'
puts line.gsub(/Ruby|Python/, 'Perl')
2.6 Block和迭代器
Block一种可以和方法调用相关联的代码块。
Block只是在花括号或者do...end之间的一组代码。
{ puts "Hello"} # this is a block
do
puts "Hello" # this is a block
end
单行block用花括号，多行block用do/end。
一旦创建了block，就可以与方法的调用相关联。把block的开始放在含有方法调用的源码行的结尾处，就可以实现关联。
如果方法有参数，它们出现在block之前。
使用Ruby的yield语句，方法可以一次或多次地调用相关联的block。可以把yield想象成方法调用。
def call_block
puts "Start of method"
yield
yield
puts "End of method"
end
call_block { puts "In the block" }
def call_block
puts "Start of method"
yield('hello', 99)
yield('world', 10)
puts "End of method"
end
call_block { |str, num| puts "In the block #{str},#{num}" }
animals = %w(ant bee cat dog elk) # 创建一个数组
animals.each {|animal| puts animal} # 迭代它的内容
['cat', 'dog', 'horse'].each{|name| print name, " "}
5.times { print "*" }
3.upto(6) { |i| print i }
('a'..'e').each { |char| print char }
其实我挺不喜欢Ruby这样对待block的方式。
2.7 读/写文件
puts输出它的参数，并在每个参数后面添加回车换行符。
print输出它的参数，但没有添加回车换行符。
irb(main):001:0> printf("Number: %5.2f,\nString: %s\n", 1.23, "hello")
Number: 1.23,
String: hello
=> nil
gets获取用户的输入
line = gets
print line
早期：
gets方法有副作用：它返回刚读取的这行数据的同时，也把这行保存到$_变量中。如果不带任何参数地调用$_中的内容。如果用正则表达式作为条件编写if或while语句，正则表达式会与$_匹配。
while gets
if /Ruby/
print
end
end
还是可以运行，不过有警告:
method.rb:2: warning: regex literal in condition
"Ruby风格"会使用迭代器和预定义的对象ARGF，ARGF表示程序的输入文件。
ARGF.each {|line| print line if line =~ /Ruby/}
