Ruby støtter enkelt arv (<) — en klasse arver fra én superklasse. Når du kaller en metode, søker Ruby gjennom en veldefinert metodeslukk-sti (abstammingskjeden, inkludert blandet inn moduler) for å finne den. Å forstå denne stien forklarer hvordan arv og mixins løser metoder.
() = = name
=
<
.new().speak
.new().fetch
En subklasse (Dog < Animal) arver superklassens metoder og instansvariabler, og kan overstyre metoder. super kaller foreldreversionen.
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 kaller en metode, går Ruby gjennom abstammingskjeden (Class.ancestors): klassen selv, deretter dens inkluderte moduler (mixins — nylig inkludert først), deretter superklassen og dens moduler, opp til BasicObject. Det første treffet vinner. Denne enestående stien forklarer hvordan arv OG mixins løser seg sammen.
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
Å forstå arv og metodeslukk-stien er viktig Ruby-kunnskap for både å utforme klasshierarkier og — spesielt — for å forstå hvordan Ruby løser metoder når arv og mixins kombineres.
Rubys enkelt arv (<) gir kodegjenbruk via "is-a"-forhold, med super for å kalle foreldreimplementasjoner.
Men det mer karakteristiske og viktige konseptet er metodeslukk-stien (abstammingskjeden): når en metode kalles, søker Ruby i en veldefinert rekkefølge — klassen selv, dens inkluderte moduler (mixins, nylig-inkludert først), deretter superklassen og dens moduler, opp til BasicObject — og det første treffet vinner.
Å forstå denne enestående, enhetlige slukk-stien er avgjørende fordi den forklarer hvordan arv og mixins løser seg sammen (moduler settes inn i kjeden, deres metoder tar forrang foran superklassens), som avklarer ellers forvirrende oppførsel om hvilken metode som faktisk blir kalt når du har både arv og flere mixins.
Dette er spesielt viktig i Ruby gitt hvor mye det bruker mixins — å vite at Class.ancestors viser den nøyaktige slukk-rekkefølgen, og hvordan moduler passer inn i den, lar deg resonnere om og debugge metodeoversettelse.
Å forstå arv, super, og spesielt metodeslukk-stien (hvordan abstammingskjeden løser metoder på tvers av klasser og blandet inn moduler) er viktig, hyppig relevant kunnskap for å arbeide med Rubys klassesystem, for å debugge "hvilken metode blir kalt?"-spørsmål, og for å utforme klasse-/modulator-hierarkier — og det er et vanlig intervjuspørsmål som gjenspeiler dypere forståelse av Rubys objektmodell og dens karakteristiske kombinasjon av enkelt arv med kraftige mixins.