默认方法名 后面2个方法名 如何用 alias

z2z4

比如 默认的 方法名 def make_damage_value(user, item)


                   后面  def make_damage_value(user, item)
              在后面   def make_damage_value(user, item)    当然这个是最终的

那如何利用 alias  别让 后面2个 互相 冲突

RUBY 代码复制

def apply_critical(damage, item)
    item.cri_damage ? damage * item.cri_damage.truncate : damage * 3
  end

def apply_critical(damage, item)


    item.cri_damage ? damage * item.cri_damage.truncate : damage * 3


  end

       貌似这个做了定义

RUBY 代码复制

def make_damage_value(user, item)
    value = item.damage.eval(user, self, $game_variables)
    value *= item_element_rate(user, item)
    value *= pdr if item.physical?
    value *= mdr if item.magical?
    value *= rec if item.damage.recover?
    value = apply_critical(value, item) if @result.critical
    value = apply_variance(value, item.damage.variance)
    value = apply_guard(value)
    @result.make_damage(value.to_i, item)
  end

def make_damage_value(user, item)


    value = item.damage.eval(user, self, $game_variables)


    value *= item_element_rate(user, item)


    value *= pdr if item.physical?


    value *= mdr if item.magical?


    value *= rec if item.damage.recover?


    value = apply_critical(value, item) if @result.critical


    value = apply_variance(value, item.damage.variance)


    value = apply_guard(value)


    @result.make_damage(value.to_i, item)


  end

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

RUBY 代码复制

def make_damage_value(user, item)
    value = item.damage.eval(user, self, $game_variables)
 
    value = apply_reverse_heel(value, item)
 
    value *= item_element_rate(user, item)
    value *= pdr if item.physical?
    value *= mdr if item.magical?
    value *= rec if item.damage.recover?
    value = apply_critical(value) if @result.critical
    value = apply_counter_gain(user, value, item) if user.actor_add_cheack[24]
    value = apply_variance(value, item.damage.variance)
    value = apply_guard(value)
 
    value = apply_defense_wall(value, item)
    value = apply_invalidate_wall(value, item)
    value = apply_metalbody(value, item)
    value = apply_goldconvert(value, item)
    value = apply_mpconvert(value, item)
    value = apply_stand(value, item)
    @result.make_damage(value.to_i, item)
  end

def make_damage_value(user, item)


    value = item.damage.eval(user, self, $game_variables)


 


    value = apply_reverse_heel(value, item)


 


    value *= item_element_rate(user, item)


    value *= pdr if item.physical?


    value *= mdr if item.magical?


    value *= rec if item.damage.recover?


    value = apply_critical(value) if @result.critical


    value = apply_counter_gain(user, value, item) if user.actor_add_cheack[24]


    value = apply_variance(value, item.damage.variance)


    value = apply_guard(value)


 


    value = apply_defense_wall(value, item)


    value = apply_invalidate_wall(value, item)


    value = apply_metalbody(value, item)


    value = apply_goldconvert(value, item)


    value = apply_mpconvert(value, item)


    value = apply_stand(value, item)


    @result.make_damage(value.to_i, item)


  end

圆寂丨不羁的风

z2z4 发表于 2013-6-25 13:04
A因为 我自己 有一套 很强大的脚本 里面包括很多的  然后 我又加个 B技能暴击伤害和暴击率的设置 这个是独 ...

  其实呢……发现事实上后者的内容几乎涵盖了前者，试试直接删掉前者（在前者头加个左对齐顶格的=begin尾加个=end）………………

z2z4

A因为 我自己 有一套 很强大的脚本 里面包括很多的  然后 我又加个 B技能暴击伤害和暴击率的设置 这个是独立的  这样堆 技能暴击伤害 是控制住了 蛋暴击率没法控制 设置1 他依然 会有100%的几率 我把他放到 A脚本的前面 A的脚本  就开始出错了

圆寂丨不羁的风

由于没见到make_damage_value(user, item) 的关于user和item相关的用法， 只好推测是这样了：假如施主后面两个ruby代码是互相独立的脚本，而第一个是放在上面的老定义，就不用改了。这种情况下，下面的代码改为：

1.   
   
2. alias  make_damage_value_new(user, item) make_damage_value(user, item)
   
3. #前面新名字随便改，别重复就是了，但记得变量（，）的内容要保持一致。
   
4. #这里贫道也没底。没改过带复杂函数的，注，下文带#的，若有备份可以直接删去。
   
5. #实际上要做的就是把重复内容去掉，然后作为一个新内容加进去。
   
6. def make_damage_value(user, item)
   
7.       make_damage_value_new(user, item)
   
8. #   value = item.damage.eval(user, self, $game_variables)
   
9.       value = apply_reverse_heel(value, item)   
   
10. #   value *= item_element_rate(user, item)
    
11. #   value *= pdr if item.physical?
    
12. #   value *= mdr if item.magical?
    
13. #    value *= rec if item.damage.recover?
    
14. #    value = apply_critical(value) if @result.critical
    
15.     value = apply_counter_gain(user, value, item) if user.actor_add_cheack[24]
    
16. #    value = apply_variance(value, item.damage.variance)
    
17. #    value = apply_guard(value)
    
18.    
    
19.     value = apply_defense_wall(value, item)
    
20.     value = apply_invalidate_wall(value, item)
    
21.     value = apply_metalbody(value, item)
    
22.     value = apply_goldconvert(value, item)
    
23.     value = apply_mpconvert(value, item)
    
24.     value = apply_stand(value, item)
    
25.     @result.make_damage(value.to_i, item)  #这句不知道要不要一定放最后，试试用#注释它，不行的话注释前面的脚本。
    
26.   end
    

复制代码

圆寂丨不羁的风

施主，重命名的话，大多情况下后者会覆盖前者的。所以别想着保留两个一样名字的。alias的实质，就是将后者的定义内容完全复制给前者。

1. def A
   
2.   A = 0
   
3. end
   
4. alias B A  （alias:B:A）#alias 新名字 旧名称 OR alias: 新名字:旧名称

复制代码

结果将会相当于：

1. def B
   
2. A = 0 #（A原内容）
   
3. end

复制代码

假如要加入新定义的A，可以这样操作：

1. alias B A
   
2. def A
   
3. B  #（A原内容）
   
4. B = 1 #新内容
   
5. end

复制代码

这样的结果，就是将原来的A通过B重新加进A，而再加入新内容，这时候的A已经不是原来的A了。就成了原来的A+新代码。
实际上相当于

1. def A
   
2. A = 0  #（A原内容）  #是将A赋给B，B再赋回A，和原来一样，可是又不同。
   
3. B = 1 #新内容
   
4. end

复制代码

这样做的好处就是假如再加入“新的”A，产生冲突的可能性会少很多。假如要加入“新的”A，

1. def A
   
2. A_1 = 1
   
3. end

复制代码

如果直接当作插件插到后面，会直接把原来内容（A = 0）覆盖掉，原来的A=0和新内容就直接没了，被覆盖了。
最后的A的内容就是上面所示的功能，可是如果用alias的话，就可以无冲突插入：

1. alias C A #这个随便起，符合规范就是了#alias 新名字 旧名称
   
2. #此时C的内容相当于上面的 A = 0 ; B = 1
   
3. def A
   
4. C
   
5. A_1 = 1
   
6. end
   
7. 
   
8. 
   

复制代码

这个时候的A就相当于：

1. def
   
2. A = 0
   
3. B = 1
   
4. A_1 = 1
   
5. end

复制代码

而不是直接被覆盖。不知道明白了没……

Sion

1. def method1
   
2.   '方法1'
   
3. end
   
4. 
   
5. alias method2 method1# 为 method1 起一个别名 method2 。目前为止，method1、method2拥有一样的功能
   
6. 
   
7. def method1 #而 现在 method1 被重新定义。
   
8.   '新' + method2
   
9. end
   
10. p method1 # => '新方法1''
    
11. p method2 #=> '方法1'
    

复制代码

#以上代码相当于

1. def method2
   
2.   '方法1'
   
3. end
   
4. def method1
   
5.   '新' + method2
   
6. end
   
7. 
   
8. p method1 # => '新方法1''
   
9. p method2 #=> '方法1'

复制代码

Sion

alias 本来就是为了覆盖原来的方法才使用的，一般是给原有的方法添加新功能。
你如果要调用原来的方法，就调用新的方法名。
然后你能告诉我为什么一定要 alias 两次吗 - -b

DeathKing

z2z4 发表于 2013-6-25 11:55
我想把 这2个方法名 都保留 别让覆盖 要怎么做

解决方法那不正是我2#给出的代码么？

z2z4

DeathKing 发表于 2013-6-25 11:47
你想表达什么呢？似乎没太明白，我猜测的是：要分两次向make_damage_value添加内容。无论怎么说，按照下面 ...

我想把 这2个方法名 都保留 别让覆盖 要怎么做

DeathKing

你想表达什么呢？似乎没太明白，我猜测的是：要分两次向make_damage_value添加内容。无论怎么说，按照下面这个方法都是没错的：

1. 
   
2. #第一次补丁
   
3. class X #<-你的类的名称
   
4.   alias make_damage_value_patch1 make_damage_value
   
5.   def make_damage_value(user, item)
   
6.     make_damage_value_patch1(user, item)
   
7.     # your code here
   
8.   end
   
9. end
   
10. 
    
11. # 第二次补丁
    
12. class X #<-你的类的名称
    
13.   alias make_damage_value_patch2 make_damage_value
    
14.   def make_damage_value(user, item)
    
15.     make_damage_value_patch2(user, item)
    
16.     # your code here
    
17.   end
    
18. end

复制代码

关于alias，可以参考这里：http://rpg.blue/thread-307096-1-1.html