Ruby stöder enkel arv (<) — en klass ärver från en superclass. När du anropar en metod, söker Ruby genom en väldefinierad metoduppslagsväg (ancestorkedjan, inklusive mixade moduler) för att hitta den. Att förstå denna väg förklarar hur arv och mixins löser metoder.
() = = name
=
<
.new().speak
.new().fetch
En subklass (Dog < Animal) ärver superklassens metoder och instansvariabler, och kan åsidosätta metoder. super anropar förälderversionen.
class Dog < Animal
def initialize(name, breed)
super(name) # call Animal#initialize
@breed = breed
end
def speak
super + " (woof)" # super (no parens) passes the same args; here calls Animal#speak
end
end
# Ruby searches for a method in this ORDER (the ancestors chain):
Dog.ancestors
# => [Dog, <included modules>, Animal, <Animal's modules>, Object, Kernel, BasicObject]
# lookup: the class itself → its included MODULES (last included first) →
# the superclass → ITS modules → ... up to BasicObject
När du anropar en metod, går Ruby genom ancestorkedjan (Class.ancestors): själva klassen, sedan dess inkluderade moduler (mixins — senast inkluderad först), sedan superklassen och dess moduler, upp till BasicObject. Första träffen vinner. Denna enskilda väg förklarar hur arv OCH mixins löser tillsammans.
module Swimmer
def move = "swimming"
end
class Fish < Animal
include Swimmer # Swimmer is inserted into the lookup path (before Animal)
end
# Fish.ancestors → [Fish, Swimmer, Animal, ...] — a module's methods come before the superclass's
Att förstå arv och metoduppslagvägen är viktig Ruby-kunskap för både utformning av klasshierarkier och — särskilt — för att förstå hur Ruby löser metoder när arv och mixins kombineras.
Rubys enkla arv (<) ger kodåteranvändning via "är-en"-relationer, med super för att anropa överordnade implementeringar.
Men det mer karakteristiska och viktiga konceptet är metoduppslagvägen (ancestorkedjan): när en metod anropas, söker Ruby i en väldefinierad ordning — själva klassen, dess inkluderade moduler (mixins, senast-inkluderad först), sedan superklassen och dess moduler, upp till BasicObject — och första träffen vinner.
Att förstå denna enskilda, enhetliga uppslagsväg är avgörande eftersom det förklarar hur arv och mixins löser tillsammans (moduler sätts in i kedjan, deras metoder får företräde över superklassens), vilket förtydligar annars förvirrande beteende om vilken metod som faktiskt anropas när du har både arv och flera mixins.
Detta är särskilt viktigt i Ruby givet hur mycket det använder mixins — att veta att Class.ancestors visar den exakta uppslagsordningen, och hur moduler passar in i den, låter dig resonera om och felsöka metodupplösning.
Att förstå arv, super, och särskilt metoduppslagvägen (hur ancestorkedjan löser metoder över klasser och mixade moduler) är viktig, ofta relevant kunskap för att arbeta med Rubys klasssystem, felsöka "vilken metod anropas?"-frågor, och utforma klass-/modulhierarkier — och det är ett vanligt intervjuämne som reflekterar djupare förståelse för Rubys objektmodell och dess unika kombination av enkel arv med kraftfulla mixins.