Ruby ஒற்றை பரம்பரை (<) ஆதரிக்கிறது — ஒரு வகுப்பு ஒரு மேல்வர்க்கத்திலிருந்து பரம்பரையாக பெறுகிறது. நீங்கள் ஒரு முறையை அழைக்கும்போது, Ruby நன்கு வரையறுக்கப்பட்ட முறை தேடல் பாதை (மூல சங்கிலி, கலந்த தொகுதிகள் உட்பட) தேடுகிறது. இந்த பாதையைப் புரிந்துகொள்வது பரம்பரை மற்றும் மிக்சின்களை எவ்வாறு தீர்க்கிறது என்பதை விளக்குகிறது.
() = = name
=
<
.new().speak
.new().fetch
ஒரு உபவகுப்பு (Dog < Animal) மேல்வர்க்கத்தின் முறைகளையும் நிகழ்வு மாறிகளையும் பரம்பரையாக பெறுகிறது, மேலும் முறைகளை மேலெழுதலாம். super பெற்றோরின் பதிப்பை அழைக்கிறது.
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
நீங்கள் ஒரு முறையை அழைக்கும்போது, Ruby மூல சங்கிலி (Class.ancestors) நடந்து செல்கிறது: வகுப்பு தன்னை, பின்னர் அதன் சேர்க்கப்பட்ட தொகுதிகள் (மிக்சின்கள் — சமீபத்தில் சேர்க்கப்பட்டவை முதலில்), பின்னர் மேல்வர்க்கம் மற்றும் அதன் தொகுதிகள், BasicObject வரை. முதல் பொருத்தம் வெற்றி பெறுகிறது. இந்த ஒற்றை பாதை பரம்பரை மற்றும் மிக்சின்கள் எவ்வாறு ஒன்றாக தீர்க்கப்படுகின்றன என்பதை விளக்குகிறது.
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
பரம்பரை மற்றும் முறை தேடல் பாதை ஐ புரிந்துகொள்வது வகுப்பு வரிசைமுறைகளை வடிவமைக்க மற்றும் — குறிப்பாக — Ruby பரம்பரை மற்றும் மிக்சின்கள் இணைந்தபோது முறைகளை எவ்வாறு தீர்க்கிறது என்பதை புரிந்துகொள்ள महत्वपूर्ण Ruby அறிவு.
Ruby இன் ஒற்றை பரம்பரை (<) "ஆ-அ" உறவுகளின் மூலம் குறியீட்டு மறுபயன்பாடு வழங்குகிறது, super உடன் பெற்றோர் செயல்பாடுகளை அழைக்க.
ஆனால் மிகவும் தனித்துவமான மற்றும் முக்கியமான கருத்து முறை தேடல் பாதை (மூல சங்கிலி): ஒரு முறை அழைக்கப்படும்போது, Ruby நன்கு வரையறுக்கப்பட்ட வரிசையில் தேடுகிறது — வகுப்பு தன்னை, அதன் சேர்க்கப்பட்ட தொகுதிகள் (மிக்சின்கள், சமீபத்தில் சேர்க்கப்பட்டவை முதலில்), பின்னர் மேல்வர்க்கம் மற்றும் அதன் தொகுதிகள், BasicObject வரை — மற்றும் முதல் பொருத்தம் வெற்றி பெறுகிறது.
இந்த ஒற்றை, ஒருங்கிணைந்த தேடல் பாதையைப் புரிந்துகொள்வது முக்கியமாகும் பரம்பரை மற்றும் மிக்சின்கள் எவ்வாறு ஒன்றாக தீர்க்கப்படுகின்றன (தொகுதிகள் சங்கிலியில் செருகப்பட்டுள்ளன, அவற்றின் முறைகள் மேல்வர்க்கத்ின் நிலைமதிப்பில் வெல்கின்றன), இது இரண்டு பரம்பரை மற்றும் பல மிக்சின்கள் இருக்கும்போது எந்த முறை உண்மையில் அழைக்கப்படுகிறது என்பதைப் பற்றிய இதர குழப்பமான நடத்தையை தெளிவுபடுத்துகிறது.
Ruby மிக்சின்களைப் பயன்படுத்துவதால் இது குறிப்பாக முக்கியமாகும் — Class.ancestors சரியான தேடல் வரிசையைக் காட்டுகிறது, மேலும் தொகுதிகள் அதிலிருந்து எவ்வாறு பொருந்துகின்றன என்பதை அறிவது, முறை தீர்மானத்தைப் பற்றி சிந்திக்க மற்றும் பிழைத்திருத்த உங்களை அனுமதிக்கிறது.
பரம்பரை, super, மற்றும் குறிப்பாக முறை தேடல் பாதை (மூல சங்கிலி வகுப்புகள் மற்றும் கலந்த தொகுதிகள் முழுவதும் முறைகளை எவ்வாறு தீர்க்கிறது) ஐ புரிந்துகொள்வது Ruby இன் வகுப்பு அமைப்புடன் வேலை செய்ய, "எந்த முறை அழைக்கப்படுகிறது?" கேள்விகளை பிழைத்திருத்த, மற்றும் வகுப்பு/தொகுதி வரிசைமுறைகளை வடிவமைக்க முக்கியமான, அடிக்கடி-பொருத்தமான அறிவு — மற்றும் இது ஒரு பொதுவான நேர்காணல் தலைப்பு ஆகும், இது Ruby இன் பொருள் மாதிரி மற்றும் ஒற்றை பரம்பரை மற்றும் சக்திशালی மிக்சின்களின் அதன் தனித்துவமான கலவை பற்றிய ஆழமான புரிதலை பிரதिबिंবित করுகிறது.