这算？“条件编译？”

DeathKing

1. if true
   
2.         def a
   
3.                 p 1
   
4.         end
   
5. end
   
6. 
   
7. class A
   
8.         if true
   
9.                 def b
   
10.                         p 2
    
11.                 end
    
12.         end
    
13. end
    
14. 
    
15. a
    
16. A.new.b

复制代码

Ruby 1.9.6

1. irb(main):001:0> if true
   
2. irb(main):002:1> def a
   
3. irb(main):003:2> p 1
   
4. irb(main):004:2> end
   
5. irb(main):005:1> end
   
6. => nil
   
7. irb(main):007:0* class A
   
8. irb(main):008:1> if true
   
9. irb(main):009:2> def b
   
10. irb(main):010:3> p 2
    
11. irb(main):011:3> end
    
12. irb(main):012:2> end
    
13. irb(main):013:1> end
    
14. => nil
    
15. irb(main):014:0>
    
16. irb(main):015:0* a
    
17. 1
    
18. => 1
    
19. irb(main):016:0> A.new.b
    
20. 2
    
21. => 2

复制代码

DeathKing

回复 roxiel 的帖子


    if true啊。。。

moy

if true....
if false是啥结果....

苏小脉

概念类似，它们都是一种元编程，不过＂编译＂一词不妥。C/C++ 预处理指令直接影响了编译时生成的二进制代码，可以静态决定参与编译的代码内容，所以可以说是＂条件编译＂；而 CRuby （１.9 后）代码无论如何都会先被编译为 YARV 字节码，条件只是决定了解释器＂解释＂与否。
如：

1. 
   
2.         if false
   
3.                 def foo
   
4.                         p 1
   
5.                 end
   
6.         end
   

复制代码

这段代码会被编译为：

1. == disasm: <RubyVM::InstructionSequence:<compiled>@<compiled>>==========
   
2. 0000 trace            1                                               (   1)
   
3. 0002 jump             22
   
4. 0004 trace            1                                               (   2)
   
5. 0006 putspecialobject 1
   
6. 0008 putspecialobject 2
   
7. 0010 putobject        :foo
   
8. 0012 putiseq          foo
   
9. 0014 send             :"core#define_method", 3, nil, 0, <ic:0>
   
10. 0020 leave                                                            (   1)
    
11. 0021 pop
    
12. 0022 putnil                                                           (   2)
    
13. 0023 leave
    
14. == disasm: <RubyVM::InstructionSequence:foo@<compiled>>=================
    
15. 0000 trace            8                                               (   2)
    
16. 0002 trace            1                                               (   3)
    
17. 0004 putnil
    
18. 0005 putobject        1
    
19. 0007 send             :p, 1, nil, 8, <ic:0>
    
20. 0013 trace            16                                              (   4)
    
21. 0015 leave                                                            (   3)

复制代码

而如果是 C/C++ 预处理指令，foo 这个函数压根儿就不参与编译。预处理指令条件是静态的，在编译时确定；而 Ruby 的条件可以是动态的，在运行时确定。

DeathKing

回复 菜鸟飞呀飞 的帖子

特殊的情况下与 define? 一起用。效果其佳，当然是在特殊的情况下。。。。。