Ruby编程语言

按有用程度 按页码先后 最新笔记

• 

  第221页

  梗言 (收心 〒_〒メ)

  良好的接口实现技巧之一 注意，我们定义的 * 方法需要一个数值参数，而非 Point 对象。如果 p 是一个点， p * 2 是允许的；不过由于我们的实现方式， 2 * p是不能工作的。第二个表达式是对 Integer 类调用 * 方法，这个类根本不知道如何与 Point 类一块工作，因为 Integer 类不知道怎样和一个点相乘，它调用 Point 的 coerce 方法来寻求帮助（参见第 3.8.7.4 节来获得更多细节）。如果我们想让 2 * p 与 p * 2 返回同样的结果.. (更多)

  良好的接口实现技巧之一

  注意，我们定义的 * 方法需要一个数值参数，而非 Point 对象。如果 p 是一个点， p * 2 是允许的；不过由于我们的实现方式， 2 * p是不能工作的。第二个表达式是对 Integer 类调用 * 方法，这个类根本不知道如何与 Point 类一块工作，因为 Integer 类不知道怎样和一个点相乘，它调用 Point 的 coerce 方法来寻求帮助（参见第 3.8.7.4 节来获得更多细节）。如果我们想让 2 * p 与 p * 2 返回同样的结果，可以定义一个 coerce 方法：

  #注释省略
  def coerce(other)
    [self, other]
  end
  

  (收起)

  2012-01-12 15:48:44   回应

  收藏

  推荐
• 

  第198页

  梗言 (收心 〒_〒メ)

  lambda 和 proc的区别 return 这样，在 lambda 中的 return 语句仅仅从 lambda 自身返回，而不会从产生 lambda 的方法中返回 在 Proc 对象中使用 return 则要承担从一个已经返回的方法中返回的风险，Ruby 会抛出 LocalJumpError 异常。 =============================================================== Page 200 传给 proc 和 lambda 的参数 调用 proc 使用的是 yield 语义，而调用 lambda 使用的是 inv... (更多)

  lambda 和 proc的区别

  return

  这样，在 lambda 中的 return 语句仅仅从 lambda 自身返回，而不会从产生 lambda 的方法中返回

  在 Proc 对象中使用 return 则要承担从一个已经返回的方法中返回的风险，Ruby 会抛出 LocalJumpError 异常。

  ===============================================================

  Page 200

  传给 proc 和 lambda 的参数

  调用 proc 使用的是 yield 语义，而调用 lambda 使用的是 invocation 语义

  proc 对参数处理的灵活性：可以安静的抛弃多余参数，将 nil 赋给遗漏的参数，甚至可以拆开数组。lambda在这方面就没有那么灵活了，跟方法一样，我们必须用与声明时同样多的参数对它进行调用

  (收起)

  2011-12-30 10:21:57   回应

  收藏

  推荐
• 

  第197页

  梗言 (收心 〒_〒メ)

  Proc 对象的相等性 Proc 类定义了 == 方法来判定两个 Proc 对象是否相等。不过，要记住两个 proc 或 lambda 拥有同样的代码并不意味着它们是相等的：/代码内容已省略/ 只有当一个 Proc 对象是另一个 Proc 对象的克隆（clone）或复制品（duplicate）时， == 方法才返回 true: /代码内容已省略/ (更多)

  Proc 对象的相等性

  Proc 类定义了 == 方法来判定两个 Proc 对象是否相等。不过，要记住两个 proc 或 lambda 拥有同样的代码并不意味着它们是相等的：

  lambda {|x| x*x} == lambda {|x| x*x}   # => false

  只有当一个 Proc 对象是另一个 Proc 对象的克隆（clone）或复制品（duplicate）时， == 方法才返回 true:

  p = lambda {|x| x*x}
  q = p.dup
  p == q                      # => true: the two procs are equal
  p.object_id == q.object_id  # => false: they are not the same object
  

  (收起)

  2011-12-30 09:52:27   回应

  收藏

  推荐

• 

  第78页

  梗言 (收心 〒_〒メ)

  小节 3.8.5.4 === 操作符 第二段后半部分： 在 Ruby 1.9 中，Symbol 类定义了 === ，当其右操作数和左操作数是同一个符号对象时，或者当其右侧操作数是一个持有和左侧符号对象相同文本的字符串时，该操作符返回 true。 但是在 Ruby 1.9.3 p0 (Windows) 上测试的结果并不如此 /代码内容已省略/ (更多)

  小节 3.8.5.4 === 操作符 第二段后半部分：

  在 Ruby 1.9 中，Symbol 类定义了 === ，当其右操作数和左操作数是同一个符号对象时，或者当其右侧操作数是一个持有和左侧符号对象相同文本的字符串时，该操作符返回 true。

  但是在 Ruby 1.9.3 p0 (Windows) 上测试的结果并不如此

  irb(main):102:0> :s === "s"
  => false
  

  (收起)

  2011-12-13 16:46:23   回应

  收藏

  推荐
• 

  第81页

  梗言 (收心 〒_〒メ)

  小节 3.8.7.3 转换函数 全局转换函数有 Array() Float() Integer() String() Array() 会依次尝试使用实参的 to_ary to_a 方法，如果均失败（返回 nil） 则直接生成一个新数组，将实参作为数组的第一个参数： /代码内容已省略/ Float() 对于类型为 Numeric 的实参直接转换为 Float，其余的则调用实参的 to_f 方法 Interger() 如果实参是 Numeric 类型，则直接转换.. (更多)

  小节 3.8.7.3 转换函数

  全局转换函数有 Array() Float() Integer() String()

  Array() 会依次尝试使用实参的 to_ary to_a 方法，如果均失败（返回 nil）

  则直接生成一个新数组，将实参作为数组的第一个参数：

  irb(main):021:0> Array("abc  def")
  => ["abc  def"]
  

  Float() 对于类型为 Numeric 的实参直接转换为 Float，其余的则调用实参的 to_f 方法

  Interger() 如果实参是 Numeric 类型，则直接转换，浮点值会被截断。对于String类型实参，则寻找基数指示器。 Interger() 与 String.to_i 不同的地方在于，Interger() 不允许尾端出现非数值的字符：

  irb(main):022:0> "12345abcd".to_i
  => 12345
  irb(main):023:0> Integer("12345abcd")
  ArgumentError: invalid value for Integer(): "12345abcd"
          from (irb):23:in `Integer'
          from (irb):23
          from D:/Ruby193/bin/irb:12:in `<main>'
  

  String() 则是调用实参的 to_s 方法

  需要注意的就是 Integer() 和 String.to_i 的区别

  另，浮点数的四舍五入为调用实参的 round 方法。

  (收起)

  2011-12-14 09:46:05   回应

  收藏

  推荐
• 

  第83页

  梗言 (收心 〒_〒メ)

  小节 3.8.8 拷贝对象 dup 和 clone 的区别 这两个方法都返回对象的浅拷贝(shallow copy) 区别在于 clone 会复制对象的 被冻结(frozen) 和受污染(tainted)状态， 而dup 只复制对象的受污染状态。 其次 clone 会复制对象的所有单键方法(特定对象方法)，而 dup 则不会。 /代码内容已省略/ 在一个被冻结对象上调用 dup 方法将返回一个未被冻结的副本。 (更多)

  小节 3.8.8 拷贝对象

  dup 和 clone 的区别

  这两个方法都返回对象的浅拷贝(shallow copy)

  区别在于 clone 会复制对象的 被冻结(frozen) 和受污染(tainted)状态，

  而dup 只复制对象的受污染状态。

  其次 clone 会复制对象的所有单键方法(特定对象方法)，而 dup 则不会。

  irb(main):030:0> a = "string"
  => "string"
  irb(main):031:0> def a.haha
  irb(main):032:1> puts "HaHa"
  irb(main):033:1> end
  => nil
  irb(main):034:0> a.freeze
  => "string"
  irb(main):035:0> b = a.clone
  => "string"
  irb(main):036:0> c = a.dup
  => "string"
  irb(main):037:0> b.frozen?
  => true
  irb(main):038:0> c.frozen?
  => false
  irb(main):039:0> b.haha
  HaHa
  => nil
  irb(main):040:0> c.haha
  NoMethodError: undefined method `haha' for "string":String
          from (irb):40
          from D:/Ruby193/bin/irb:12:in `<main>'
  

  在一个被冻结对象上调用 dup 方法将返回一个未被冻结的副本。

  (收起)

  2011-12-14 10:07:14   回应

  收藏

  推荐

• 

  第221页

  梗言 (收心 〒_〒メ)

  良好的接口实现技巧之一 注意，我们定义的 * 方法需要一个数值参数，而非 Point 对象。如果 p 是一个点， p * 2 是允许的；不过由于我们的实现方式， 2 * p是不能工作的。第二个表达式是对 Integer 类调用 * 方法，这个类根本不知道如何与 Point 类一块工作，因为 Integer 类不知道怎样和一个点相乘，它调用 Point 的 coerce 方法来寻求帮助（参见第 3.8.7.4 节来获得更多细节）。如果我们想让 2 * p 与 p * 2 返回同样的结果.. (更多)

  良好的接口实现技巧之一

  注意，我们定义的 * 方法需要一个数值参数，而非 Point 对象。如果 p 是一个点， p * 2 是允许的；不过由于我们的实现方式， 2 * p是不能工作的。第二个表达式是对 Integer 类调用 * 方法，这个类根本不知道如何与 Point 类一块工作，因为 Integer 类不知道怎样和一个点相乘，它调用 Point 的 coerce 方法来寻求帮助（参见第 3.8.7.4 节来获得更多细节）。如果我们想让 2 * p 与 p * 2 返回同样的结果，可以定义一个 coerce 方法：

  #注释省略
  def coerce(other)
    [self, other]
  end
  

  (收起)

  2012-01-12 15:48:44   回应

  收藏

  推荐
• 

  第198页

  梗言 (收心 〒_〒メ)

  lambda 和 proc的区别 return 这样，在 lambda 中的 return 语句仅仅从 lambda 自身返回，而不会从产生 lambda 的方法中返回 在 Proc 对象中使用 return 则要承担从一个已经返回的方法中返回的风险，Ruby 会抛出 LocalJumpError 异常。 =============================================================== Page 200 传给 proc 和 lambda 的参数 调用 proc 使用的是 yield 语义，而调用 lambda 使用的是 inv... (更多)

  lambda 和 proc的区别

  return

  这样，在 lambda 中的 return 语句仅仅从 lambda 自身返回，而不会从产生 lambda 的方法中返回

  在 Proc 对象中使用 return 则要承担从一个已经返回的方法中返回的风险，Ruby 会抛出 LocalJumpError 异常。

  ===============================================================

  Page 200

  传给 proc 和 lambda 的参数

  调用 proc 使用的是 yield 语义，而调用 lambda 使用的是 invocation 语义

  proc 对参数处理的灵活性：可以安静的抛弃多余参数，将 nil 赋给遗漏的参数，甚至可以拆开数组。lambda在这方面就没有那么灵活了，跟方法一样，我们必须用与声明时同样多的参数对它进行调用

  (收起)

  2011-12-30 10:21:57   回应

  收藏

  推荐
• 

  第197页

  梗言 (收心 〒_〒メ)

  Proc 对象的相等性 Proc 类定义了 == 方法来判定两个 Proc 对象是否相等。不过，要记住两个 proc 或 lambda 拥有同样的代码并不意味着它们是相等的：/代码内容已省略/ 只有当一个 Proc 对象是另一个 Proc 对象的克隆（clone）或复制品（duplicate）时， == 方法才返回 true: /代码内容已省略/ (更多)

  Proc 对象的相等性

  Proc 类定义了 == 方法来判定两个 Proc 对象是否相等。不过，要记住两个 proc 或 lambda 拥有同样的代码并不意味着它们是相等的：

  lambda {|x| x*x} == lambda {|x| x*x}   # => false

  只有当一个 Proc 对象是另一个 Proc 对象的克隆（clone）或复制品（duplicate）时， == 方法才返回 true:

  p = lambda {|x| x*x}
  q = p.dup
  p == q                      # => true: the two procs are equal
  p.object_id == q.object_id  # => false: they are not the same object
  

  (收起)

  2011-12-30 09:52:27   回应

  收藏

  推荐