ਵਿਰਸਾ ਅਤੇ ਮੈਥਡ ਲੁਕਅਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

Ruby **single inheritance** (`<`) ਨੂੰ ਸਮਰਥਨ ਦਿੰਦਾ ਹੈ — ਇੱਕ ਕਲਾਸ ਇੱਕ ਸੁਪਰਕਲਾਸ ਤੋਂ ਵਿਰਸਾ ਲੈਂਦੀ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਕਾਈ ਮੈਥਡ ਕਾਲ ਕਰਦੇ ਹੋ, Ruby ਇੱਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ **method lookup path** (ancestor chain, mixed-in modules ਸਮੇਤ) ਵਿੱਚ ਇਸ ਨੂੰ ਲੱਭਣ ਲਈ ਖੋਜ ਕਰਦਾ ਹੈ। ਇਸ ਪਾਥ ਨੂੰ ਸਮਝਣਾ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਉਂਧਰਜਾ ਅਤੇ mixins ਮੈਥਡ ਨੂੰ ਕਿਵੇਂ resolve ਕਰਦੇ ਹਨ। ## Single inheritance ```ruby class Animal def initialize(name) = @name = name def speak = "some sound" end class Dog < Animal # Dog inherits from Animal (single inheritance) def speak # override "Woof" end def fetch "#{@name} fetches" # @name inherited from Animal end end Dog.new("Rex").speak # "Woof" (overridden) Dog.new("Rex").fetch # uses inherited @name ``` ਇੱਕ subclass (`Dog < Animal`) superclass ਦੇ ਮੈਥਡ ਅਤੇ instance variables ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਮੈਥਡ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦਾ ਹੈ। `super` ਪੇਅਰੈਂਟ ਦੇ ਸੰਸਕਰਣ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ## super — parent method ਨੂੰ ਕਾਲ ਕਰਿਆ ```ruby 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 ``` ## The method lookup path (ancestor chain) ```ruby # Ruby searches for a method in this ORDER (the ancestors chain): Dog.ancestors # => [Dog, , Animal, , Object, Kernel, BasicObject] # lookup: the class itself → its included MODULES (last included first) → # the superclass → ITS modules → ... up to BasicObject ``` ਜਦੋਂ ਤੁਸੀਂ ਕਾਈ ਮੈਥਡ ਕਾਲ ਕਰਦੇ ਹੋ, Ruby **ancestor chain** (`Class.ancestors`) ਵਿਚ ਸਮੋ ਕਰਦਾ ਹੈ: ਕਲਾਸ ਆਪਣੇ ਆਪ, ਫਿਰ ਇਸ ਦੇ included **modules** (mixins — ਸਭ ਤੋਂ ਹਾਲ ਹੀ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਏ ਪਹਿਲੇ), ਫਿਰ superclass ਅਤੇ ਇਸ ਦੇ modules, `BasicObject` ਤੱਕ। ਪਹਿਲਾ ਮੈਚ ਜਿੱਤਦਾ ਹੈ। ਇਹ ਇੱਕਲੌਤੀ ਪਾਥ ਸਮਝਾਉਂਦੀ ਹੈ ਕਿ ਉਂਧਰਜਾ AND mixins ਕਿਵੇਂ ਇਕਠੇ resolve ਹੁੰਦੇ ਹਨ। ## Mixins lookup path ਵਿੱਚ ਫਿੱਟ ਹੋਣ ```ruby 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 ``` ## ਇਹ ਮਾਇਨੇ ਕਿਉ ਰੱਖਦਾ ਹੈ ਇਨਹਰਿਟੈਂਸ ਅਤੇ **method lookup path** ਨੂੰ ਸਮਝਣਾ ਕਲਾਸ hierarchies ਨੂੰ ਡਿਜਾਈਨ ਕਰਨ ਲਈ ਅਤੇ — ਖਾਸ ਤੌਰ ਤੇ — ਇਹ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ Ruby ਜਾਣਕਾਰੀ ਹੈ ਕਿ Ruby ਮੈਥਡ ਨੂੰ ਕਿਵੇਂ resolve ਕਰਦਾ ਹੈ ਜਦੋਂ ਇਨਹਰਿਟੈਂਸ ਅਤੇ mixins ਇਕਠੇ ਹੋਣ। Ruby ਦੀ **single inheritance** (`<`) "is-a" relationships ਦੁਆਰਾ ਕੋਡ reuse ਫਰਾਹਮ ਕਰਦੀ ਹੈ, parent implementations ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ `super` ਨਾਲ। ਪਰ ਵਧੇਰੇ distinctive ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਸੰਕਲਪ **method lookup path** ਹੈ (the ancestor chain): ਜਦੋਂ ਕਾਈ ਮੈਥਡ ਕਾਲ ਹੁੰਦਾ ਹੈ, Ruby ਇੱਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਗਣਨਾ ਵਿੱਚ ਖੋਜ ਕਰਦਾ ਹੈ — ਕਲਾਸ ਆਪਣੇ ਆਪ, ਇਸ ਦੇ included **modules** (mixins, most-recently-included ਪਹਿਲੇ), ਫਿਰ superclass ਅਤੇ ਇਸ ਦੇ modules, `BasicObject` ਤੱਕ — ਅਤੇ ਪਹਿਲਾ ਮੈਚ ਜਿੱਤਦਾ ਹੈ। ਇਸ ਇੱਕਲੌਤੀ, ਇਕਜੁੱਟ lookup path ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ **inheritance ਅਤੇ mixins ਇਕਠੇ ਕਿਵੇਂ resolve ਹੁੰਦੇ ਹਨ** (modules chain ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਉਨ੍ਹਾਂ ਦੇ ਮੈਥਡ superclass ਦੇ ਤੱਕ precedence ਲੈਂਦੇ ਹਨ), ਜੋ ਨਹੀਂ ਤਾਂ confusing ਵਿਹਾਰ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ ਕਿ ਜਦੋਂ ਤੁਹਾਡੇ ਕੋਲ ਇਨਹਰਿਟੈਂਸ ਅਤੇ ਮਲਟੀਪਲ mixins ਹਨ ਤਾ ਅਸਲ ਮੈਥਡ ਕਿਹੜਾ ਕਾਲ ਹੁੰਦਾ ਹੈ। ਇਹ Ruby ਵਿੱਚ ਖਾਸ ਤੌਰ ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ mixins ਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਰਤਦਾ ਹੈ — ਇਹ ਜਾਣਨਾ ਕਿ `Class.ancestors` ਸਹੀ lookup ਗਣਨਾ ਦਿਖਾਉਂਦਾ ਹੈ, ਅਤੇ ਮੋਡੀਉਲ ਇਸ ਵਿੱਚ ਕਿਵੇਂ ਫਿੱਟ ਹੁੰਦੇ ਹਨ, ਤੁਹਾਨੂੰ method resolution ਬਾਰੇ ਸੋਚਣ ਅਤੇ debug ਕਰਨ ਦਿੰਦਾ ਹੈ। Inheritance, `super`, ਅਤੇ ਖਾਸ ਤੌਰ ਤੇ method lookup path (how the ancestor chain resolves methods across classes ਅਤੇ mixed-in modules) ਨੂੰ ਸਮਝਣਾ Ruby ਦੇ ਕਲਾਸ system ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, "which method is being called?" ਸਵਾਲ debug ਕਰਨ ਲਈ, ਅਤੇ ਕਲਾਸ/module hierarchies ਨੂੰ ਡਿਜਾਈਨ ਕਰਨ ਲਈ ਮਹੱਤਵਪੂਰਨ, ਅਕਸਰ relevant ਜਾਣਕਾਰੀ ਹੈ — ਅਤੇ ਇਹ ਇੱਕ common interview ਟਾਪਿਕ ਹੈ ਜੋ Ruby ਦੇ object model ਦੀ ਡੂੰਘੀ ਸਮਝ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸ ਦੇ distinctive single inheritance ਨਾਲ powerful mixins ਦੇ ਸਮਨਵਯ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।