《Programming Ruby 第二章 Ruby.new》学

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方法有副作用：它返回刚读取的这行数据的同时，也把这行保存到$_变量中。如果不带任何参数地调用print，它会打印出$_中的内容。如果用正则表达式作为条件编写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/}

2.8 更高更远