In Ruby gibt es eine Möglichkeit, den Initialize-Konstruktor zu überladen?

Question

In Java können Sie Konstrukteurs überlasten:

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

Gibt es eine Möglichkeit in Ruby das gleiche Ergebnis zu erzielen: zwei Konstrukteure, die unterschiedliche Argumente?

Answer 1

Die Antwort ist Ja und Nein

Sie können das gleiche Ergebnis erzielen, wie Sie in anderen Sprachen können eine Vielzahl von Mechanismen, einschließlich: -

• Standardwerte für Argumente
• Variable Argumentlisten (Der Splat-Operator)
• Definieren Sie Ihr Argument als Hash

Die tatsächliche Syntax der Sprache ermöglicht es Ihnen nicht, eine Methode zweimal zu definieren, auch wenn die Argumente unterschiedlich sind.

die drei Optionen über diese Betrachtet man könnte mit Ihrem Beispiel implementiert werden, wie

# 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 

folgt Sie den zweiten Mechanismus häufig im Ruby-Code auftritt, vor allem in Rails, wie es das Beste aus beiden Welten bietet und ermöglicht etwas syntaktischer Zucker, um hübschen Code zu erzeugen, insbesondere den übergebenen Hash nicht in Klammern einschließen zu müssen.

Diese wikibooks link bietet einige weitere Lesung

Answer 2

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

Answer 3

Ich neige dazu,

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 

zu tun, aber ich weiß nicht, ob dies der beste Ansatz ist.

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

Sie konstructor gem verwenden können mehrere Konstrukteure in Ruby zu erklären und ahmen Überlastung:

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

ich in der Regel:

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"