ਵੈਰੀਅਂਸ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਇੱਕ ਸੰਯੁਕਤ ਕਿਸਮ ਦੀ ਸਬਟਾਈਪਿੰਗ ਇਸਦੇ ਹਿੱਸਿਆਂ ਦੀ ਸਬਟਾਈਪਿੰਗ ਨਾਲ ਕਿਵੇਂ ਸੰਬੰਧਿਤ ਹੈ — ਯਾਨੀ Container<Sub> ਕਦੋਂ Container<Super> ਨੂੰ ਨਿਯੁਕਤ ਕਰਨ ਯੋਗ ਹੈ?
Dog ਨੂੰ Animal ਦਾ ਇੱਕ ਸਬਟਾਈਪ ਮੰਨੋ।
let dogs: Dog[] = [];
let animals: Animal[] = dogs; // ✅ Dog[] is assignable to Animal[]
ਰਿਟਰਨ ਕਿਸਮ ਅਤੇ ਐਰੇ ਕੋਵੇਰੀਐਂਟ ਹਨ: ਜੇ Dog ⊆ Animal, ਤਾਂ Dog[] ⊆ Animal[]। ਇੱਕ ਫੰਕਸ਼ਨ ਜੋ Dog ਵਾਪਸ ਕਰਦਾ ਹੈ ਉਹ ਉਸ ਥਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿੱਥੇ Animal ਵਾਪਸ ਕਰਨ ਵਾਲੇ ਦੀ ਆਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
type Handler<T> = (arg: T) => void;
let animalHandler: Handler<Animal> = (a) => {};
let dogHandler: Handler<Dog> = animalHandler; // ✅ (with strictFunctionTypes)
// a handler that accepts ANY Animal can safely handle a Dog
ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਕਾਂਟਰਾਵੇਰੀਐਂਟ ਹਨ: Handler<Animal> ਨੂੰ Handler<Dog> ਨਿਯੁਕਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਤੱਤ ਸੰਬੰਧ ਦਾ ਉਲਟ ਹੈ। ਇਹ ਸਮਝਦਾਰੀ ਭਰਾ ਹੈ — ਕਿਛ ਜੋ ਸਭ ਜਾਨਵਰਾਂ ਨੂੰ ਸਭਾਲਦਾ ਹੈ ਪਕੋ ਹੀ ਕੁੱਤਿਆਂ ਨੂੰ ਸਭਾਲਦਾ ਹੈ।
// Method parameters in TS are bivariant by default (a known unsound convenience)
interface Comparer<T> { compare(a: T): void; }
TypeScript ਸਤੰਤਰ ਫੰਕਸ਼ਨ ਕਿਸਮਾਂ ਨੂੰ ਕਾਂਟਰਾਵੇਰੀਐਂਟਲੀ ਹੀ ਚੇਕ ਕਰਦਾ ਹੈ strictFunctionTypes ਦੇ ਅਧੀਨ; ਢੰਗ ਪੈਰਾਮੀਟਰ ਜਾਣ-ਬੁੱਝ ਕੇ ਅਰਗਨਮਿਕਸ ਲਈ ਬਾਈਵੇਰੀਐਂਟ ਹਨ, ਜੋ ਤਕਨੀਕੀ ਤੌਰ ਤੇ ਗੈਰ-ਮੁਨਾਸਬ ਹੈ।
ਵੈਰੀਅਂਸ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਨਿਸ਼ਚਿਤ ਨਿਯੋਜਨ ਕਿਵੇਂ ਮਨਜ਼ੂਰ ਜਾਂ ਅਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ — ਕਿਉਂ Dog[] ਫਿੱਟ ਹੈ Animal[] ਵਿੱਚ ਪਰ (d: Dog) => void ਕਾਲਬੈਕ ਹਮੇਸ਼ਾ (a: Animal) => void ਦੀ ਥਾਂ ਨਹੀਂ ਲੈ ਸਕਦਾ।
ਇਸ ਨੂੰ ਸਮਝਣ ਨਾਲ ਤੁਹਾਨੂੰ ਜਥਾ API ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ (ਜਿਵੇਂ ਸਿਰਫ-ਪੜ੍ਹਨਯੋਗ ਬਨਾਮ ਲਿਖਣਯੋਗ ਸਥਿਤੀਆਂ) ਅਤੇ ਫੰਕਸ਼ਨ ਅਤੇ ਜਥਾ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਾਲੀ ਉਲਝਣ ਵਾਲੀ "not assignable" ਗਲਤੀਆਂ ਨੂੰ ਡੀਕੋਡ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ।
ਵਿਸਤ੍ਰਿਤ ਜਵਾਬਾਂ ਨਾਲ IT ਇੰਟਰਵਿਊ ਸਵਾਲਾਂ ਦੀ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ — ਜੂਨੀਅਰ ਤੋਂ ਸੀਨੀਅਰ ਤੱਕ।
ਦਾਨ ਕਰੋ