Dois-je utiliser un alias ou alias_method?

J’ai trouvé un article de blog sur alias vs. alias_method . Comme le montre l’exemple donné dans cet article, je veux simplement aliaser une méthode à une autre dans la même classe. Que dois-je utiliser? Je vois toujours un alias utilisé, mais quelqu’un m’a dit alias_method est préférable.

Utilisation d’alias

 class User def full_name puts "Johnnie Walker" end alias name full_name end User.new.name #=>Johnnie Walker 

Utilisation de alias_method

 class User def full_name puts "Johnnie Walker" end alias_method :name, :full_name end User.new.name #=>Johnnie Walker 

Blog post lien ici

alias_method peut être redéfini si besoin est. (il est défini dans la classe Module .)

Le comportement de l’ alias change en fonction de sa scope et peut parfois être imprévisible.

Verdict: Utilisez alias_method – cela vous donne plus de flexibilité.

Usage:

 def foo "foo" end alias_method :baz, :foo 

Outre la syntaxe, la principale différence réside dans la scope :

 # scoping with alias_method class User def full_name puts "Johnnie Walker" end def self.add_rename alias_method :name, :full_name end end class Developer < User def full_name puts "Geeky geek" end add_rename end Developer.new.name #=> 'Gekky geek' 

Dans le cas ci-dessus, la méthode “name” choisit la méthode “full_name” définie dans la classe “Developer”. Maintenant, essayons avec un alias .

 class User def full_name puts "Johnnie Walker" end def self.add_rename alias :name :full_name end end class Developer < User def full_name puts "Geeky geek" end add_rename end Developer.new.name #=> 'Johnnie Walker' 

Avec l’utilisation d’alias, la méthode «name» ne peut pas choisir la méthode «full_name» définie dans Developer.

Cela est dû au fait que l’ alias est un mot clé et qu’il a une scope lexicale. Cela signifie qu’il traite self comme la valeur de soi au moment où le code source a été lu. En revanche, alias_method traite self comme la valeur déterminée au moment de l’exécution.

Source: http://blog.bigbinary.com/2012/01/08/alias-vs-alias-method.html

Je pense qu’il y a une règle non écrite (quelque chose comme une convention) qui dit d’utiliser «alias» juste pour enregistrer un alias de nom de méthode, signifie que si vous voulez donner à l’utilisateur de votre code une méthode avec plus d’un nom:

 class Engine def start #code goes here end alias run start end 

Si vous avez besoin d’étendre votre code, utilisez l’alternative méta ruby.

 class Engine def start puts "start me" end end Engine.new.start() # => start me Engine.class_eval do unless method_defined?(:run) alias_method :run, :start define_method(:start) do puts "'before' extension" run() puts "'after' extension" end end end Engine.new.start # => 'before' extension # => start me # => 'after' extension Engine.new.run # => start me 

Un point en faveur de l’ alias au lieu de alias_method est que sa sémantique est reconnue par rdoc, ce qui conduit à des références croisées dans la documentation générée, tandis que rdoc ignore complètement la alias_method .

Un an après avoir posé la question vient un nouvel article sur le sujet:

http://erniemiller.org/2014/10/23/in-defense-of-alias/

Il semble que “tant d’hommes, tant d’esprits”. De l’ancien article, l’auteur encourage à utiliser alias_method , tandis que le second suggère d’utiliser un alias .

Cependant, il existe un aperçu commun de ces méthodes dans les deux articles et réponses ci-dessus:

  • utiliser un alias lorsque vous souhaitez limiter l’alias au domaine où il est défini
  • utiliser alias_method pour permettre aux classes héritées d’y accéder

Ceci est maintenant géré dans le Ruby Style Guide :

Préférer les alias lors de l’aliasing des méthodes dans l’étendue de la classe lexicale car la résolution de soi dans ce contexte est également lexicale, et communique clairement à l’utilisateur que l’indirection de votre alias ne sera altérée ni lors de l’exécution, ni par une sous-classe.

 class Westerner def first_name @names.first end alias given_name first_name end 

Toujours utiliser alias_method lors de l’exécution d’aliasing de méthodes de modules, de classes ou de classes singleton, car la scope lexicale de l’alias entraîne une imprévisibilité dans ces cas

 module Mononymous def self.included(other) other.class_eval { alias_method :full_name, :given_name } end end class Sting < Westerner include Mononymous end 

alias_method new_method , old_method

old_method sera déclaré dans une classe ou un module hérité maintenant de notre classe où new_method sera utilisé.

ceux-ci peuvent être variables ou méthode les deux.

Supposons que Class_1 a old_method et que Class_2 et Class_3 héritent tous deux de Class_1.

Si l’initialisation de Class_2 et Class_3 est effectuée dans Class_1, les deux peuvent avoir un nom différent dans Class_2 et Class_3 et son utilisation.

Bien que cela puisse être mineur, mais il y a deux choses que j’aime dans l’alias, plus que dans alias_method:

(1) l’alias est plus court

et

(2) Vous ne devez pas taper le,

C’est peu, je sais, mais quand vous faites cela quelques centaines de fois au fil des ans, vous avez simplement tendance à préférer un alias chaque fois que possible.