En Ruby, ¿hay alguna manera de sobrecargar el constructor de inicialización?

Question

En Java se puede sobrecargar constructores:

public Person(String name) { 
    this.name = name; 
} 
public Person(String firstName, String lastName) { 
    this(firstName + " " + lastName); 
} 

¿Hay alguna manera en Ruby para lograr el mismo resultado: dos constructores que toman diferentes argumentos?

Answer 1

La respuesta es sí y no

se puede lograr el mismo resultado que se puede en otros idiomas usando una variedad de mecanismos, incluyendo: -

• valores por defecto de los argumentos
• lista de argumentos (el operador splat)
• la definición de su argumento como un hash

La sintaxis real del idioma no le permite definir un método dos veces, incluso si los argumentos son diferentes.

Teniendo en cuenta las tres opciones anteriores éstos podrían ser implementadas con el ejemplo de la siguiente manera

# As written by @Justice 
class Person 
    def initialize(name, lastName = nil) 
    name = name + " " + lastName unless lastName.nil? 
    @name = name 
    end 
end 


class Person 
    def initialize(args) 
    name = args["name"] + " " + args["lastName"] unless args["lastName"].nil? 
    @name = name 
    end 
end 

class Person 
    def initialize(*args) 
    #Process args (An array) 
    end 
end 

Usted se encontrará con el segundo mecanismo de frecuencia del código Ruby, en particular dentro de los carriles, ya que ofrece lo mejor de ambos mundos y permite un poco de azúcar sintáctico para producir código bonito, particularmente sin tener que encerrar el hash pasado entre paréntesis.

Este wikibooks link proporciona una lectura más

Answer 2

class Person 
    def initialize(name, lastName = nil) 
    name = name + " " + lastName unless lastName.nil? 
    @name = name 
    end 
end 

Answer 3

que tienden a hacer

class Person 
    def self.new_using_both_names(first_name, last_name) 
    self.new([first_name, last_name].join(" ")) 
    end 

    def self.new_using_single_name(single_name) 
    self.new(single_name) 
    end 

    def initialize(name) 
    @name = name 
    end 
end 

Pero no sé si este es el mejor enfoque.

Answer 4

class StatementItem 
    attr_reader :category, :id, :time, :amount 

    def initialize(item) 
    case item 
    when Order 
     initialize_with_order(item) 
    when Transaction 
     initialize_with_transaction(item) 
    end 
    end 

    def valid? 
    !(@category && @id && @time && @amount).nil? 
    end 

    private 
    def initialize_with_order(order) 
     return nil if order.status != 'completed' 
     @category = 'order' 
     @id = order.id 
     @time = order.updated_at 
     @amount = order.price 
    end 

    def initialize_with_transaction(transaction) 
     @category = transaction.category 
     @id = transaction.id 
     @time = transaction.updated_at 
     @amount = transaction.amount 
    end 

end 

Answer 5

Puede utilizar konstructor joya para declarar varios constructores en Ruby e imitar la sobrecarga:

class Person 
    def initialize(name) 
    @name = name 
    end 

    konstructor 
    def from_two_names(first_name, last_name) 
    @name = first_name + ' ' + last_name 
    end 
end 

Person.new('John Doe') 
Person.from_two_names('John', 'Doe') 

Answer 6

que suelo hacer:

class Person 
    attr_reader :name 
    def initialize(first: nil, last: nil) 
    @name = [first, last].compact.join(' ') 
    end 
end 

Person.new(first: 'ya').name 
# => "ya" 

Person.new(first: 'ya', last: 'ku').name 
# => "ya ku"