2014-09-17 13 views
6

Ho letto qualche metodo aliasing in questo modo:Qual è la differenza tra il metodo alias e il simbolo alias?

alias :original_method :method 

Che assomiglia a simboli in rubino per me. Qual è la differenza se ho digitato questo alias in questo modo:

alias original_method method 

Il risultato sarà diverso?

+2

Si può o non si può sapere, ma solo per vostra informazione. Una cosa da notare qui è che 'alias' non è un metodo ma è una parola chiave. Se fosse un metodo, il secondo non funzionerebbe. – sawa

+4

@sawa il primo non funzionerebbe neanche a causa della mancanza ',' tra gli argomenti – Stefan

+0

@Stefan Hai ragione. Ho perso questo. – sawa

risposta

7

Non sembra essere una differenza, dal documentation:

Il alias parola chiave è più frequentemente usato a metodi alias. Quando aliasing un metodo che è possibile utilizzare il proprio nome o un simbolo:

alias new_name old_name 
alias :new_name :old_name 
+0

Hmm, interessante. Preferirei che la precedente sintassi eseguisse entrambi i metodi e usasse il loro valore restituito. Tuttavia, poiché l'alias non è un metodo ma una parola chiave, ha perfettamente senso comportarsi diversamente. Se si tenta di utilizzare i nomi dei metodi anziché i simboli per "alias_method", vengono eseguiti entrambi i metodi. – BroiSatse

+1

Inoltre, se 'alias' fosse un metodo, la prima riga significherebbe' self.alias (self.new_name (self.old_name())) 'e non' self.alias (self.new_name(), self.old_name()) '. –

1

Al di là del fatto che uno è un metodo (e quindi valuta i suoi argomenti come qualsiasi metodo fa) dovete lasciare l'uso comune casi per trovare una differenza.

Per esempio, se si fa

class Foo 
    def old_name 
    'foo' 
    end 

    def self.rename_name 
    alias_method :new_name, :old_name 
    end 
end 

class Bar < Foo 
    def new_name 
    'bar' 
    end 
end 

Bar.rename_name 

Poi Bar ha il suo metodo new_name sovrascritti, e Foo è intatta

Come mai, se si modifica questa opzione per utilizzare alias cioè

class Foo 
    def old_name 
    'foo' 
    end 

    def self.rename_name 
    alias :new_name :old_name 
    end 
end 

class Bar < Foo 
    def new_name 
    'bar' 
    end 
end 

Bar.rename_name 

Quindi la classe Bar non è stata modificata e ottiene un metodo ca lled: new_name. Questo non è diverso dalla differenza tra l'utilizzo di define_method rispetto alla definizione di un metodo con def.

In un caso l'ambito è puramente lessicale: la posizione della linea che chiama alias determina completamente cosa succede, mentre nell'altro caso è il valore di self quando ruby ​​valuta quel bit del codice.

Problemi correlati