【用代码说话】#1.实例对象

喵呜喵5

【前言】

现在的论坛已经基本上没有什么技术输出或者干货分享了，所以最近一段时间一直想正正经经写一个 RM 脚本教程来误人子弟，思考了很多形式很多主题，比如【RM 永远不会告诉你的那些 Ruby 知识】啦【如何一步一步用脚本实现某个简单的功能】啦【Try This，Not This】啦啥的，但是仔细去推敲的话又写不动了。今天看了这个帖子（https://rpg.blue/forum.php?mod=viewthread&tid=394657）忽然意识到很多人所谓的“能理解、修改脚本代码”实际上从 Ruby 的层面上来看简直惨不忍睹，技术讨论区已经没了，黑科技区则不适合发这些东西，思考再三，决定在水区开始一个不定期更新的连载，每次给出一段构造简单包含基础知识的 Ruby 代码，用代码说话，让人能够真正理解代码背后的逻辑，而不至于说出【我能改脚本，但是变量为什么前面要加@啊】这种让人啼笑皆非的话出来
当然，阅读我这个系列需要你拥有一定的脚本基础，这个脚本基础指的是：你至少应该知道代码是一行一行执行的吧？至少要知道比较是否相等用的是 == 赋值用的是 = 吧，大概就是这种类似 Ruby 语言的常识一样的东西

鉴于我自己学术不精，这个系列又完全是由我自己发起自己执行的，没有什么人来负责内容的校对，帖子包含的内容难免存在各种错误，所以如果诸位阅读者发现了什么纰漏请不吝指正
同时，由于帖子可能包含错误，我可能会直接编辑原帖内容进行修正，因此，请不要转载这些帖子的内容以免帖子中的错误在转载后给他人带来困扰，最最不济，转载烦请注明原帖地址，谢谢合作

那么，下面是这个系列的正文

【用代码说话】#1.实例对象

引

1. class A
   
2.   def m1
   
3.     p 'foo'
   
4.   end
   
5. end
   
6. 
   
7. a = A.new
   
8. aa = A.new
   
9. a.m1
   
10. aa.m1
    
11. p (a.object_id == aa.object_id)

复制代码

请不要借助任何代码执行工具，阅读上面的代码并思考，输出的结果是什么？
如果你对 Ruby 接触不深的话，这里给你提供一个简单的补充知识，object_id 可以看作是一个座位号，在你的程序中，如果两个东西的座位号是相同的，那么他们就是【完全相同】的，如果两个东西的座位号是不同的，那么系统就会把他们当成【不同的东西】来区别对待

解

作为一门完全面向对象的语言，这样一段代码也许是个不错的开始。关于面向对象、类、实例对象这三个术语，这里并不想对其进行过多描述性的解释，毕竟，一堆的编程语言，一堆的脚本教程里已经变着法子讨论过一遍了，又是学生又是猫又是汽车的，以我拙劣的描述水平估计再去解释也只会让你更加混乱，所以，用代码说话，在上面这段代码中

• A 是类
• a 和 aa 是对象，并且是 A 的实例对象
• 使用 A 来定义 m1，使用 a 和 aa 来执行 m1 的这种写代码的方式就是面向对象的编程方式
  

（当然，从严格的意义上来看，上面这三条描述并不严谨）

有了以上几句话的基础，下面我们可以从头开始完整的分析一遍代码了，我们一起从上往下看一下

• A 做出了一个声明，告诉电脑，自己是一个类
• A 定义了一个 m1 方法，告诉电脑，执行 m1 方法要做哪些事情
• a 做出了一个声明，告诉电脑，刚刚来了一个新来的实例，他是 A 的实例，你们以后叫一声 a 就能找到他！
• aa 做出了一个声明，告诉电脑，刚刚来了一个新来的实例，他是 A 的实例，你们以后叫一声 aa 就能找到他！
• a 说，我要执行 m1 方法！
• aa 说，我也要执行 m1 方法！
• 我们询问系统，a 和 aa 的座位号相同吗？
  

这段代码的输出结果是

1. "foo"
   
2. "foo"
   
3. false

复制代码

为什么 a 说我要执行 m1，输出的是"foo"？
因为 a 是 A 的实例，A 规定了执行 m1 要输出 "foo"

为什么 aa 说我要执行 m1，输出的是"foo"？
因为 aa 是 A 的实例，A 规定了执行 m1 要输出 "foo"

那么，为什么我们询问系统 a 和 aa 座位号是不是相同的时候，系统告诉我们不是呢？
因为，a 做了声明：坐在 a 这个位置的是一个新来的实例！
aa 也做了声明：坐在 aa 这个位置的也是一个新来的实例！
系统一看，哟呵，来了两个新来的实例，那么给你们两个各自分配一个座位号你们待着吧
这就是实例的特点了，即使 a 和 aa 都是 A 的实例，他们所做的事情是完全一样的，但是，他们却在不同的座位上坐着，在系统的层面，他们是不一样的两个东西

而像是这种用类定义行为，用实例执行行为的编程方式正是面向对象的编程方式

作为实用主义者，你大概会问了，道理我都懂，但是面向对象有什么用呢？
想想看吧，假设主角进入了一个史莱姆的巢穴，正与 1 只史莱姆战斗，史莱姆的动作非常单调，只会随机执行下列行动中的其中一种

• 防御
• 攻击
  

请问，你打算如何写代码来实现这些这只史莱姆的逻辑呢？
——哦，不好，你发现敌人不止 1只史莱姆，而是 100 只史莱姆！
——哦，不好，你在和史莱姆战斗的过程中发现史莱姆的动作居然不是【防御】和【攻击】而是【防御】、【攻击】和【逃跑】
面向对象正是为了解决这样的问题，你不需要为这 100 只史莱姆都各自定义相应的行为，你只需定义一个史莱姆的类，然后让史莱姆实例执行史莱姆类定义的行为就好了。正因为所有的史莱姆实例都会忠实的执行史莱姆类所定义的行为，所以，只要改变史莱姆类的定义，所有史莱姆实例的行为都能立刻发生改变，这听起来可比重新给把100只史莱姆的逻辑都重写一遍好多了不是吗？

那么，最后，附上一个会让你对这次学到的内容感到有点混乱的恶作剧

1. class A
   
2.   def m1
   
3.     p 'foo'
   
4.   end
   
5. end
   
6. 
   
7. a = A.new
   
8. aa = a
   
9. a.m1
   
10. aa.m1
    
11. p (a.object_id == aa.object_id)

复制代码

如果无法理解上面这段代码的输出结果，那么，比较一下这段代码和最开始那段代码的不同，然后再考虑一遍吧
也许，你能在后续的帖子中学到更多关于这个恶作剧的细节？

御曹司

好棒的帖子~~
居然今天才发现的说

kuerlulu

其实

ruby有很多应该小心的地方没错

但是一开始就讲这些对于新人是否太深了

喵喵喵觉得应该先快速地体现一下ruby"容易写"的特点(即, 书写时比较符合直觉, 而且直接读起来应该是很流畅的)
# 这也是ruby被各种语法糖包裹的一个目的

并且用ruby来解释面向对象将会十分容易(比如, 类的基本形式就是用class包住一些methods和instance_variables【雾)

快速地介绍完变量 方法 类 模块的简单写法和笑果之后, 可以紧接着画个作用域的盒模型【大雾

到这里就可以说入门结束了吧, 不用考虑一些枝节(这些东西应该直接丢doc, 而且理解了上一行的内容之后大都是可以自己看懂的)。

因为喵喵喵差不多也就是个入门的层次所以话就说到这了【逃

喵呜喵5

有丘直方 发表于 2016-7-18 14:31
没错，这非常让人疑惑。@英顺的马甲 @garfeng

并没有什么好疑惑的，很简单，因为这里的 == 等于 true 代表的是：两个对象【完全一样】

什么是完全一样呢
假设，你进入一场战斗，敌人是两个史莱姆，你打了左边那个史莱姆，右边那个史莱姆一脸没事的样子看着你，那这两个史莱姆就是不一样的
你打了左边那个史莱姆，右边那个史莱姆的血跟着左边史莱姆一起扣，那这两个史莱姆是完全一样的

面向对象想要实现的就是，不管出来一只史莱姆还是一百只史莱姆，只要他们是不一样的对象，那么打了左边史莱姆，右边的史莱姆就不应该跟着一起扣血

有丘直方

1. class A; end
   
2. p(A.new)
   
3. a = A.new; p(a)
   
4. b = A.new; p(b)
   
5. p(a == A.new)
   
6. p(b == A.new)
   
7. p(a == b)
   
8. p(A.new == A.new)
   
9. # =>
   
10. #    #<A:0x8c****>
    
11. #    #<A:0x8c****>
    
12. #    #<A:0x8c****>
    
13. #    false
    
14. #    false
    
15. #    false
    
16. #    false

复制代码

没错，这非常让人疑惑。@英顺的马甲 @garfeng

summer92

a 当然等于 a的副本了 ：arr_b = arr_a.dup
a = a.dup
p (arr_a == arr_b) #=> true 还有 P 出来，我也是醉了

RyanBern

garfeng 发表于 2016-7-17 19:08
谢谢指出，在你提到%p之前，我从未意识到用%p来打印地址。%p是定长的16进制吧。

我没有想用C来类比ruby ...

其实喵呜在写这一段的时候不应该引入'=='这个符号的，因为这个给初学者造成了非常大的困扰。真正判断是否相等的方法应该是Object#equal?，这个方法才属于真正的所谓“判断地址”。这是因为'=='在某些内置类里面已经被覆盖，因此执行'=='判断的时候只是判断内容相等与否。

RUBY 代码复制

arr_a = [0, 1]
arr_b = arr_a.dup
p (arr_a == arr_b) #=> true
str_a = "Hello World"
str_b = str_a.dup
p (str_a == str_b) #=> true

arr_a = [0, 1]


arr_b = arr_a.dup


p (arr_a == arr_b) #=> true


str_a = "Hello World"


str_b = str_a.dup


p (str_a == str_b) #=> true

喵呜举例的时候，特地用了自己定义的类A，在默认情况下，'=='的含义等同于'equal?'，因此这样才不会出问题。因此我建议，不论是你还是楼主喵呜，都应该先引入'equal?'来解释这个问题为好。

嗯，不去类比或者类推是最好的，因为如果这样理解Ruby会经常出错。

另外%d表示32位整数，但是指针的话有两种，有32位指针和64位指针的区别（视系统而定），因此使用%d打印是不合理的，而%p才是专门用来打印指针的格式转换符。

garfeng

RyanBern 发表于 2016-7-17 18:06
永远不要用其他语言来类比Ruby，尤其是C语言。这也是我初学的时候犯的错误之一。

首先吐槽为什么输出 ...

谢谢指出，在你提到%p之前，我从未意识到用%p来打印地址。%p是定长的16进制吧。

我没有想用C来类比ruby，

我只是想用一个直观的办法，来解释我理解范围内的：
为什么一个类的两个实例不是同一个东西。
这个问题，在JavaScript，C++，Go……等其他语言里的原因都是地址不一样。
所以我妄断在ruby里，也是这个原因，
谢谢指出问题，因为ruby的某个比较的方法，还会比较哈希值吗？

RUBY 代码复制

a=A.new
b=a.dup

a=A.new


b=a.dup

这种情况，比较的时候，不是比较值本身而是地址吧。
ruby的比较机制确实跟其他语言大不相同呢。
谢谢指教。
你叫我把%d修改成%p吗？【已经修改，谢谢提醒】
还是修改不应该用c类比ruby这一段？【不是类比语言，而是类比数据在内存里的存储方式，所以先不改了……】

RyanBern

garfeng 发表于 2016-7-17 17:10
我猜你想问10楼我问过的东西。
因为开辟了不一样的内存地址来存储实例，而在比较时，默认==符号比较的是地 ...

永远不要用其他语言来类比Ruby，尤其是C语言。这也是我初学的时候犯的错误之一。

首先吐槽为什么输出指针不用%p而是%d

下面是从 Ruby 官方文档上截取下来的。
链接：http://ruby-doc.org/core-2.3.1/Object.html#method-i-eql-3F

请自己体会一下 Ruby 的这个机制（约定）。顺便修改一下回复吧。

garfeng

有丘直方 发表于 2016-7-17 14:10
至今没搞懂为啥同一个类的实例在执行了同一个方法之后会变成不同的东西。 ...

我猜你想问10楼我问过的东西。
因为开辟了不一样的内存地址来存储实例，而在比较时，默认==符号比较的是地址的值，而非实例里的成员的具体值。
内存地址不一样了，所以会不是同一个东西。

个人理解所写，欢迎拍砖：

RUBY 代码复制

a = A.new
 b = a
             Addr  Data    这是一个内存条
             +---+-------+
a ---------> | 1 |   3   |-------+
             +---+-------+       |
b ---------> | 2 |   3   |----+  |
             +---+-------+    |  |
             | 3 |       |<---+--+
             +---| Obj1  |
             | 4 |       |
             +---+-------+
             |...| ..... |
             +---+-------+
 
a = A.new
申请3~4的内存，吧Obj1存进去，将a赋值3
a --> Addr:1 --> Data:3 --> Addr:3 --> Obj1
b = a
b --> Addr:2 --> Data:3 --> Addr:3 --> Obj1
 
a和b都是3，所以
a==b # =>>true
a equal? b # =>> true
a eql? b   # =>> true
 
==========================================================================
 
a = A.new
b = A.new
 
 
              Addr  Data        这是一个内存条
              +---+-------+
a ----------> | 1 |   3   |----+  a存储的内容是3，即obj1的起始地址位
              +---+-------+    |  ---------------------------------------
b ----------> | 2 |   5   |----+--+ b存储的内容是5，即obj2的起始地址位
              +---+-------+    |  | -------------------------------------
              | 3 |       |<---+  |
              +---+  Obj1 |       | 3,4号地址位里存储的内容obj1，和
              | 4 |       |       | 5,6号里存储的obj2一模一样。
              +---+-------+       | 假设hash也一样？
              | 5 |       |<------+
              +---+  Obj2 |
              | 6 |       |
              +---+-------+
 
 
 当使用a所代表的object时，访问顺序：
 
 a --> Addr:1 --> Data:3 --> Addr:3 --> Data:Obj1
 b --> Addr:2 --> Data:5 --> Addr:5 --> Data:Obj2
 
 a是3，而b是5，所以 
 a==b #=>>false
 a equal? b # =>> false
 a eql? b # =>> true
 
=====================================================================
 
涉及到哈希值的比较？
 
a = A.new
b = a.dup
             +---+--------+
a ---------> | 1 |   3    |----+
             +---+--------+    |
b ---------> | 2 |   5    |----+---+
             +---+--------+    |   |
             | 3 | Obj1   |<---+   |
             +---+ hash1  |        | hash1 和hash2 不一样，
             | 4 |        |        | 除此之外，Obj1和Obj2的
             +---+--------+        | 其他内容都一样？
             | 5 | Obj2   |<-------+
             +---+ hash2  |
             | 6 |        |
             +---+--------+
 
 a==b #=>>false
a equal? b =>> false
a eql? b =>> false

a = A.new


 b = a


             Addr  Data    这是一个内存条


             +---+-------+


a ---------> | 1 |   3   |-------+


             +---+-------+       |


b ---------> | 2 |   3   |----+  |


             +---+-------+    |  |


             | 3 |       |<---+--+


             +---| Obj1  |


             | 4 |       |


             +---+-------+


             |...| ..... |


             +---+-------+


 


a = A.new


申请3~4的内存，吧Obj1存进去，将a赋值3


a --> Addr:1 --> Data:3 --> Addr:3 --> Obj1


b = a


b --> Addr:2 --> Data:3 --> Addr:3 --> Obj1


 


a和b都是3，所以


a==b # =>>true


a equal? b # =>> true


a eql? b   # =>> true


 


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


 


a = A.new


b = A.new


 


 


              Addr  Data        这是一个内存条


              +---+-------+


a ----------> | 1 |   3   |----+  a存储的内容是3，即obj1的起始地址位


              +---+-------+    |  ---------------------------------------


b ----------> | 2 |   5   |----+--+ b存储的内容是5，即obj2的起始地址位


              +---+-------+    |  | -------------------------------------


              | 3 |       |<---+  |


              +---+  Obj1 |       | 3,4号地址位里存储的内容obj1，和


              | 4 |       |       | 5,6号里存储的obj2一模一样。


              +---+-------+       | 假设hash也一样？


              | 5 |       |<------+


              +---+  Obj2 |


              | 6 |       |


              +---+-------+


 


 


 当使用a所代表的object时，访问顺序：


 


 a --> Addr:1 --> Data:3 --> Addr:3 --> Data:Obj1


 b --> Addr:2 --> Data:5 --> Addr:5 --> Data:Obj2


 


 a是3，而b是5，所以 


 a==b #=>>false


 a equal? b # =>> false


 a eql? b # =>> true


 


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


 


涉及到哈希值的比较？


 


a = A.new


b = a.dup


             +---+--------+


a ---------> | 1 |   3    |----+


             +---+--------+    |


b ---------> | 2 |   5    |----+---+


             +---+--------+    |   |


             | 3 | Obj1   |<---+   |


             +---+ hash1  |        | hash1 和hash2 不一样，


             | 4 |        |        | 除此之外，Obj1和Obj2的


             +---+--------+        | 其他内容都一样？


             | 5 | Obj2   |<-------+


             +---+ hash2  |


             | 6 |        |


             +---+--------+


 


 a==b #=>>false


a equal? b =>> false


a eql? b =>> false

慎点……