Héritage et délégation Ruby

Je ne sais pas grand-chose sur l'utilisation appropriée de l'héritage et de la délégation, alors je l'ai résumé.

Héritage

Il s'agit de reprendre la fonction d'une autre classe et de créer une nouvelle classe.

Exemple

Créer une classe Foo en héritant de toutes les méthodes de la classe Base

class Base
  def message
    'ok'
  end
end

class Foo < Base; end
  
foo = Foo.new
puts foo.message
# => ok

transfert

Il s'agit de déléguer un processus spécifique (responsabilité) à une méthode d'une autre classe.

Exemple

Déléguez la méthode de message de la classe Base à la classe Foo

class Base
  def message
    'ok'
  end
end

require 'forwardable'
class Foo
  extend Forwardable
  attr_reader :mess

  def initialize
    @mess = Base.new
  end
  def_delegator :mess, :message
end
  
foo = Foo.new
puts foo.message
# => ok

Scènes qui utilisent l'héritage

Même rôle

Que vous soyez un ingénieur débutant ou un ingénieur Tsuyotsuyo expérimenté, le rôle d'un programmeur est le même. Alors, héritons de la classe Progurammer et héritons de la fonction telle qu'elle est.

class Programmer
  def initialize(type, langages)
    @type = type
    @langages = Array(langages)
  end

  def type_is
    puts "je#{type}est."
  end

  def langage_is
    str = ''
    langages.each do |lang|
      str += "#{lang} "
    end
    puts "je#{str}Peut gérer la langue de"
  end

  def klass_is
    str = case self.class.name
    when 'TsuyoTsuyo'
      'Ingénieur fort'
    when 'Kakedashi'
      'Ingénieur débutant'
    end

    puts "je#{str}est."
  end

  private
  attr_accessor :type, :langages
end

class TsuyoTsuyo < Programmer; end

class Kakedashi < Programmer; end

tsuyo = TsuyoTsuyo.new('Backend', %w[C C++ Python Go Ruby])
tsuyo.type_is
tsuyo.langage_is
tsuyo.klass_is

kake = Kakedashi.new('Frontend', %w[HTML CSS jQuery])
kake.type_is
kake.langage_is
kake.klass_is

Scènes utilisant la délégation

Je souhaite utiliser certaines fonctions bien que les rôles soient différents

Les programmeurs et les concepteurs ont des rôles différents. Donc, dans ce cas, utilisez la délégation pour que seule la méthode type_is soit héritée de la classe Programmer.

require 'forwardable'
class Programmer
  def initialize(type, langages)
    @type = type
    @langages = Array(langages)
  end

  def type_is
    puts "je#{type}est."
  end

  private
  attr_accessor :type, :langages
end

class Designer
  extend Forwardable

  def initialize(type, skills)
    @programmer = Programmer.new(type, nil)
    @type = type
    @skills = Array(skills)
  end

  def_delegator :@programmer, :type_is

  private
  attr_accessor :type, :skills
end

class IkeIke < Designer; end

ikeike = IkeIke.new('WebDesigner', %w[HTML CSS Adobe JavaScript])
ikeike.type_is #Ce type_est la méthode`Programmer`Méthode héritée de la classe

Sommaire

Merci d'avoir lu jusqu'ici. J'espère que ce sera l'occasion de revoir mon code.

Je développe généralement des services Web avec Rails, mais je ne pense pas qu'il existe de nombreuses occasions d'utiliser la délégation. Il est vrai aussi que je disais "héritage !!" Il est difficile de juger si la relation d'héritage est bonne ou s'il vaut mieux utiliser la délégation, mais à l'avenir, j'ai décidé de la mettre en œuvre en incluant l'option d'utiliser la délégation.