Ruby学习笔记之Ruby 对象

obj = Object.new

if obj.respond_to?("talk")
  obj.talk
else
  puts "Sorry, the object doesn't understand the 'talk' message."
end
创建一个对象，使用对象的 respond_to? ，问一下它能不能 talk 。respond_to? 是对象天生有的能力，它可以查询出对象是不是可以对某些信息做出响应。

使用 send 方法发送信息

之前创建的那个票对象，假设你想根据用户输入的东西，来返回对应的关于这个对象的信息，代码像这样：

print "Information desired: "
request = gets.chomp
然后你可以做判断：

if request == "venue"
  puts ticket.venue
elsif request == "performer"
  puts ticket.performer
...
上面的方法有点长，你也可以这样来做：

if ticket.respond_to?(request)
  puts ticket.send(request)
else
  puts "no such information"
end
上面用 respond_to? 问一下输入的东西有没有，也就是对象是不是可以对这个信息做出响应，如果是的话，就用 send 这个方法去发送这个信息，也就是让对象去执行对应的方法。

方法的参数

Ruby 里的方法可以包含零个或多个参数。参数的数量也可以是可变的。

必须与可选

先做个实验：

obj = Object.new

def obj.one_arg(x)
  puts "I require one and only one argument!"
end

obj.one_arg(1,2,3)
结果会是：

ArgumentError: wrong number of arguments (3 for 1)
意思就是参数的数量错了，应该只有一个参数，你确给出了三个。

在方法里添加多个参数，可以使用 * 号，像这样：

def obj.multi_args(*x)
  puts "I can take zero or more arguments!"
end
*x 这个参数的意思是，你调用这个方法的时候可以添加任意数量的参数。这个参数的值会是一个数组。

再看一个混合使用参数的例子：

def two_or_more(a,b,*c)
  puts "I require two or more arguments!"
  puts "And sure enough, I got: "
  p a, b, c
end
如果像这样调用上面这个方法：two_or_more(1,2,3,4,5) ，得到的东西应该像这样：

I require two or more arguments!
And sure enough, I got:
1
2
[3, 4, 5]
方面里的 p 是输出东西用的，要输出的是传递给方法里的 a，b，c 这几个参数的值。调用方法的时候传递的参数是1，2，3，4，5，这样 a 参数的值应该是 1 ，b 参数的值是 2 ，剩下的是 c 参数的值，它会是一个数组，里面包含了 3，4，5  。

参数的默认值

定义方法的时候可以为参数设置默认的值，如果调用方法的时候没有设置参数的值，就会使用它的默认的那个值。

def default_args(a,b,c=1)
  puts "Values of variables: ",a,b,c
end
如果像这样调用上面这个方法：

default_args(3,2)
得到的结果是：

Values of variables:
3
2
1
调用方法的时候我们没给 c 参数传递值，这样就会使用它的默认的值，也就是 1 。

参数的顺序

先看个例子：

def mixed_args(a,b,*c,d)
  puts "Arguments:"
  p a,b,c,d
end

mixed_args(1,2,3,4,5)
调用方法返回的结果像这样：

Arguments:
1
2
[3, 4]
5
*c 是一个海绵参数，它的优先级比较低，所以如果这样调用方法：

mixed_args(1,2,3)
返回的结果会是：

1
2
[]
3
下面是更详细的参数例子：

必须
def m(abc)
  m(1,2,3)
    a = 1, b = 2, c = 3

可选
def m(*a)
  m(1,2,3)
    a = [1,2,3]

默认
def m(a=1)
  m
    a = 1
  m(2)
    a = 2

必须/可选
def m(a, *b)
  m(1)
    a = 1, b = []

必须/默认
def m(a,b=1)
  m(2)
    a = 2, b = 1
  m(2,3)
    a = 2, b = 3

默认/可选
def m(a=1, *b)
  m
    a = 1, b = []
  m(2)
    a = 2, b = []

必须/默认/可选
def m(a,b=2,*c)
  m(1)
    a = 1, b = 2, c = []
  m(1,3)
    a = 1, b = 3, c = []
  m(1,3,5,7)
    a = 1, b = 3, c = [5,7]

必须/默认/可选/必须
def m(a,b=2,*c,d)
  m(1,3)
    a = 1, b = 2, c = [], d = 3
  m(1,3,5)
    a = 1, b = 3, c = [], d = 5
  m(1,3,5,7)
    a = 1, b = 3, c = [5], d = 7
  m(1,3,5,7,9)
    a = 1, b = 3, c = [5, 7], d = 9

下午2:15 ****

本地变量与变量分配

下午2:15 ****

本地变量可以使用小写字母或下划线开头，也可以包含数字，下面都是合格的本地变量名：

x
_x
name
first_name
plan9
user_ID
_
本地变量的意思就是它的作用范围会受到限制，每个本地变量只会在程序的某一块儿地方起作用。比如在程序的不同的地方可能会包含同样名字的两个本地变量。

常见的作用范围就是在一个方法的定义里面，看个例子：

def say_goodby
 x = 'goodbye'
 puts x
end

def start_here
 x = 'hello'
 puts x
 say_goodby
 puts 'Let us check whether x remained the same:'
 puts x
end

start_here
执行的结果应该是：

hello
goodbye
let us check whether x remained the same:
hello
第一行输出的是 start_here 里定义的 x 变量的值，也就是 hello ，第二行内容是在 start_here 里面执行了 say_goodby，输出了这个方法里定义的 x 的值，最后在 start_here 里输出的 x 的值，仍然是在这个方法内部定义的那个 x 的值。

变量，对象，引用

先试一下：

str = 'hello'
现在 str 这个变量表示的就是字符串 hello 。

再试一下：

str = 'hello'
abc = str
puts abc
str 表示 hello，把 str 的值分配给了 abc ，所以输出 abc 的时候，结果就会是 hello 。

再试一下：

str = "hello"
abc = str
str.replace("goodbye")
puts str
puts abc
def say_goodbye
  str = "hello"
  abc = str
  str.replace("goodbye")
  puts str
  puts abc
end

say_goodbye
输出的结果是：

goodbye
goodbye
第一个 goodbye 是 str 的，第二个是 abc 的，但是我们只替换了 str ，为啥 abc 的值也被替换了？

引用

在 Ruby 里，大部分情况下变量本身不存对象的值，上面的 str 其实不包含 hello 这个字符串，它只包含了一个对这个字符串对象的引用。

在一个分配里，左边是变量，右边是一个对象，变量会收到一个对这个对象的引用。如果分配的是一个变量到另一个变量，比如 abc = str，左边的变量会复制一份右边的变量的引用，也就是这两个变量引用的会是同一个对象。

str.replace("goodbye")
把 str 引用的那个字符串替换成了 goodbye ，变量 abc 引用了同样的字符串对象，所以在 str 上做的替换动作也会影响到 abc ，也就是字符串的内容变成了 goodbye 。

不被引用的东西

在 Ruby 里，有些对象会作为立即值存储在变量里。比如整数，符号（symbol，看起来像 :this，字符串的前面带个冒号），还有 true，false，nil 。你把这些值分配给一个变量的时候，变量会保存这个值本身，而不是一个到它们的引用。Ruby 会自动判断是否使用引用。

任何表示立即值的对象，永远都是唯一的一个对象，不管它分配给了多少个变量。比如只有一个 100 对象 ，只有一个 false 对象。

Ruby 的对象必须有一个或多个引用指向它，如果没有引用，会释放掉对象占用的内存。

如果你有两个或两个以上的变量指向了同一个对象，你可以使用这些变量里的其中的任何一个来发送信息给它们表示的对象。

分配与重新分配变量中的引用

对变量的每次分配，都会把变量之前表示的东西清除掉。来试一下：

str = "hello"
abc = str
str = "goodbye"
puts str
puts abc
这回输出的是：

goodbey
hello
引用与方法参数

来段代码：

def change_string(str)
  str.replace("新内容")
end
再创建一个字符串，把它发送给 change_string ：

s = "原始内容"
change_string(s)
再检查一下：

puts s
结果会是：

新内容
如果你不想改变那个字符串，可以这样试一下：

s = "Original string content!"
change_string(s.dup)
puts s
dup 方法会复制一个新的对象。也可以这样做：

s = "原始内容"
s.freeze
change_string(s)
puts s
本地变量和跟它们很像的东西

Ruby 看到这些东西：s，ticket，puts，user_name，会把它们解释成下面这三样东西其中的一种：

本地变量：local variable
关键词：keyword
方法调用：method call
关键词是 Ruby 的保留词，你不能把它们作为变量的名字。比如 def，if 这些都是关键词。跟本地变量差不多，方法调用也是纯文字，如果方法有参数，加上括号以后很容易知道它们不是一个变量。如果调用的方法没有括号，Ruby 会整明白它到底是个啥。

Ruby 是这样判断标识符的：

如果标识符是关键词，它就是一个关键词。
如果有个等号在标识符的右边出现，它就是一个本地变量。
其它的情况标识符就会是一个方法的调用。