Skip to content

Classes and OOP — کلاسز اور آبجیکٹ پر مبنی پروگرامنگ

The Urdu Programming Language has full object-oriented programming support. Classes group data and behaviour together. This document covers the complete class system including inheritance, access modifiers, getters/setters, and polymorphism.

اردو: اردو پروگرامنگ لینگویج آبجیکٹ پر مبنی پروگرامنگ (OOP) کی مکمل حمایت کرتی ہے۔ کلاسیں ڈیٹا اور طرزِعمل کو ایک ساتھ جمع کرتی ہیں۔ یہ دستاویز مکمل کلاس نظام کا احاطہ کرتی ہے — وراثت، رسائی ترمیم کار، گیٹر/سیٹر اور کثیرالشکلی (polymorphism) سمیت۔

Table of Contents

  1. Basic Class Declaration
  2. Properties and Methods
  3. یہ — this reference
  4. نیا — Creating Instances
  5. Inheritance — توسیع
  6. سپر — super
  7. جامد — Static Methods and Properties
  8. Access Modifiers
  9. Getters and Setters
  10. Polymorphism
  11. Complete Bank Account Example
  12. Mixins

Basic Class Declaration — بنیادی کلاس اعلان

Syntax:

کلاس نام {
    تعمیر(پیرامیٹر) {
        // initialization
    }

    طریقہ() {
        // method body
    }
}

اردو: کلاس بنانے کے لیے کلاس کلیدی لفظ، پھر نام، پھر تعمیر (constructor) جو نئی مثال بناتے وقت چلتا ہے، اور پھر طریقے (methods)۔ یہ موجودہ مثال کا حوالہ ہے۔

کلاس حیوان {
    تعمیر(نام, آواز) {
        یہ.نام = نام;
        یہ.آواز = آواز;
    }

    بولو() {
        لکھو(`${یہ.نام} کہتا ہے: ${یہ.آواز}`);
    }

    تعارف() {
        واپس `میں ${یہ.نام} ہوں`;
    }
}

مستقل بلی = نیا حیوان("میو", "میاؤں");
بلی.بولو();            // میو کہتا ہے: میاؤں
لکھو(بلی.تعارف());    // میں میو ہوں

Properties and Methods — خاصیتیں اور طریقے

Properties are data attached to instances. Methods are functions attached to instances.

اردو: خاصیتیں (properties) مثال سے جڑا ڈیٹا ہیں۔ طریقے (methods) مثال سے جڑے فنکشن ہیں۔ تعمیر میں یہ.نام = قدر سے خاصیت بنائی جاتی ہے۔

کلاس مستطیل {
    تعمیر(چوڑائی, اونچائی) {
        یہ.چوڑائی = چوڑائی;
        یہ.اونچائی = اونچائی;
    }

    رقبہ() {
        واپس یہ.چوڑائی * یہ.اونچائی;
    }

    محیط() {
        واپس 2 * (یہ.چوڑائی + یہ.اونچائی);
    }

    تفصیل() {
        واپس `مستطیل ${یہ.چوڑائی}×${یہ.اونچائی} — رقبہ: ${یہ.رقبہ()}`;
    }
}

مستقل شکل = نیا مستطیل(8, 5);
لکھو(شکل.رقبہ());      // 40
لکھو(شکل.محیط());      // 26
لکھو(شکل.تفصیل());     // مستطیل 8×5 — رقبہ: 40

Class fields (direct property declaration):

کلاس گاڑی {
    برانڈ = "نامعلوم";
    رفتار = 0;
    چل_رہی = جھوٹ;

    تعمیر(برانڈ) {
        یہ.برانڈ = برانڈ;
    }

    چلاؤ(تیزی) {
        یہ.چل_رہی = سچ;
        یہ.رفتار = تیزی;
        لکھو(`${یہ.برانڈ} ${تیزی} km/h پر چل رہی ہے`);
    }

    روکو() {
        یہ.رفتار = 0;
        یہ.چل_رہی = جھوٹ;
        لکھو(`${یہ.برانڈ} رک گئی`);
    }
}

مستقل میری_گاڑی = نیا گاڑی("ٹویوٹا");
میری_گاڑی.چلاؤ(120);    // ٹویوٹا 120 km/h پر چل رہی ہے
میری_گاڑی.روکو();        // ٹویوٹا رک گئی

اردو: کلاس فیلڈز تعمیر سے باہر براہ راست ڈکلیئر کیے جا سکتے ہیں — پہلے سے طے قدریں دینے کے لیے مفید۔

یہ — this reference

یہ inside a method refers to the current instance.

اردو: یہ کسی طریقے کے اندر موجودہ مثال کا حوالہ دیتا ہے — جیسے انسان خود کو "میں" کہتا ہے، کلاس کا طریقہ یہ کہتا ہے۔

کلاس ٹائمر {
    تعمیر() {
        یہ.وقت = 0;
        یہ.چل_رہا = جھوٹ;
    }

    شروع_کرو() {
        یہ.چل_رہا = سچ;
        لکھو("ٹائمر شروع");
        واپس یہ;    // method chaining
    }

    آگے_بڑھاؤ(سیکنڈ) {
        اگر (یہ.چل_رہا) {
            یہ.وقت += سیکنڈ;
        }
        واپس یہ;
    }

    روکو() {
        یہ.چل_رہا = جھوٹ;
        لکھو(`ٹائمر رکا — کل وقت: ${یہ.وقت} سیکنڈ`);
        واپس یہ;
    }
}

// Method chaining
نیا ٹائمر()
    .شروع_کرو()
    .آگے_بڑھاؤ(5)
    .آگے_بڑھاؤ(10)
    .روکو();
// ٹائمر شروع
// ٹائمر رکا — کل وقت: 15 سیکنڈ

اردو: طریقے سے یہ واپس کر کے "طریقوں کی زنجیر" بنائی جا سکتی ہے — ایک کے بعد دوسرا طریقہ ایک لائن میں چلانا بہت پڑھنے میں آسان لگتا ہے۔

نیا — Creating Instances

نیا calls the constructor and returns a new object.

اردو: نیا تعمیر کنندہ کو بلاتا ہے اور ایک نئی شے واپس کرتا ہے۔ ہر نیا کلاس_نام() ایک الگ مثال بناتا ہے اپنی خاصیتوں کے ساتھ۔

کلاس نقطہ {
    تعمیر(x = 0, y = 0) {
        یہ.x = x;
        یہ.y = y;
    }

    فاصلہ(دوسرا) {
        واپس ریاضی.جذر((یہ.x - دوسرا.x) ** 2 + (یہ.y - دوسرا.y) ** 2);
    }

    جمع(دوسرا) {
        واپس نیا نقطہ(یہ.x + دوسرا.x, یہ.y + دوسرا.y);
    }

    toString() {
        واپس `(${یہ.x}, ${یہ.y})`;
    }
}

مستقل الف = نیا نقطہ(0, 0);
مستقل ب   = نیا نقطہ(3, 4);
مستقل ج   = الف.جمع(ب);

لکھو(الف.فاصلہ(ب));    // 5
لکھو(`${ج}`);          // (3, 4)

اردو: نقطے کے درمیان فاصلہ فیثاغورث کے اصول سے نکالا گیا۔ جمع طریقہ ایک نیا نقطہ واپس کرتا ہے — اصل نقطے تبدیل نہیں ہوتے۔

Inheritance — توسیع

توسیع creates a child class that inherits from a parent class.

اردو: توسیع بچہ کلاس بناتا ہے جو والدین کلاس سے وراثت لیتا ہے۔ بچہ کلاس والدین کے تمام طریقے اور خاصیتیں پاتا ہے، اور اپنے بھی شامل کر سکتا ہے یا موجودہ اوور رائیڈ کر سکتا ہے۔

کلاس شکل {
    تعمیر(رنگ = "کالا") {
        یہ.رنگ = رنگ;
    }

    بیان() {
        واپس `${یہ.رنگ} شکل`;
    }

    رقبہ() {
        واپس 0;
    }
}

کلاس دائرہ توسیع شکل {
    تعمیر(رداس, رنگ) {
        سپر(رنگ);           // call parent constructor
        یہ.رداس = رداس;
    }

    رقبہ() {
        واپس ریاضی.PI * یہ.رداس ** 2;
    }

    بیان() {
        واپس `${سپر.بیان()} — دائرہ (رداس: ${یہ.رداس})`;
    }
}

کلاس مثلث توسیع شکل {
    تعمیر(قاعدہ, اونچائی, رنگ) {
        سپر(رنگ);
        یہ.قاعدہ = قاعدہ;
        یہ.اونچائی = اونچائی;
    }

    رقبہ() {
        واپس 0.5 * یہ.قاعدہ * یہ.اونچائی;
    }
}

مستقل د = نیا دائرہ(7, "سرخ");
مستقل م = نیا مثلث(6, 4, "نیلا");

لکھو(د.بیان());              // سرخ شکل — دائرہ (رداس: 7)
لکھو(گول(د.رقبہ(), 2));      // 153.94
لکھو(م.رقبہ());              // 12
لکھو(م مثال شکل);            // true

اردو: مثال آپریٹر سے جانچ سکتے ہیں کہ کوئی شے کسی کلاس کی مثال ہے یا نہیں — م مثال شکل سچ ہے کیونکہ مثلث شکل سے وراثت لیتا ہے۔

سپر — super

سپر() calls the parent constructor. سپر.طریقہ() calls a parent method.

اردو: سپر() والدین کے تعمیر کنندہ کو بلاتا ہے۔ سپر.طریقہ() والدین کا طریقہ بلاتا ہے۔ بچہ کلاس کے تعمیر میں یہ استعمال کرنے سے پہلے سپر() ضرور بلانا پڑتا ہے۔

کلاس شخص {
    تعمیر(نام, عمر) {
        یہ.نام = نام;
        یہ.عمر = عمر;
    }

    تعارف() {
        واپس `میرا نام ${یہ.نام} ہے، عمر ${یہ.عمر}`;
    }
}

کلاس طالب_علم توسیع شخص {
    تعمیر(نام, عمر, جماعت) {
        سپر(نام, عمر);      // must call super before using یہ
        یہ.جماعت = جماعت;
    }

    تعارف() {
        واپس `${سپر.تعارف()}، جماعت ${یہ.جماعت}`;
    }
}

کلاس استاد توسیع شخص {
    تعمیر(نام, عمر, مضمون) {
        سپر(نام, عمر);
        یہ.مضمون = مضمون;
    }

    تعارف() {
        واپس `${سپر.تعارف()}، مضمون: ${یہ.مضمون}`;
    }
}

مستقل ط = نیا طالب_علم("احمد", 18, "دہم");
مستقل ا = نیا استاد("فاطمہ", 35, "ریاضی");

لکھو(ط.تعارف());
// میرا نام احمد ہے، عمر 18، جماعت دہم

لکھو(ا.تعارف());
// میرا نام فاطمہ ہے، عمر 35، مضمون: ریاضی

اردو: سپر.تعارف() والدین کا تعارف طریقہ بلاتا ہے اور بچہ کلاس اس میں اپنی معلومات شامل کرتا ہے — والدین کا کوڈ دوبارہ لکھنے کی ضرورت نہیں!

جامد — Static Methods and Properties

جامد members belong to the class itself, not to instances.

اردو: جامد ارکان کلاس سے تعلق رکھتے ہیں، مثالوں سے نہیں۔ انہیں کلاس_نام.طریقہ() سے بلاتے ہیں، کسی مثال کی ضرورت نہیں۔ یوٹیلیٹی فنکشن اور فیکٹری طریقوں کے لیے بہترین ہیں۔

کلاس درجہ_حرارت {
    جامد مطلق_صفر = -273.15;

    تعمیر(قدر, اکائی = "C") {
        یہ.قدر = قدر;
        یہ.اکائی = اکائی;
    }

    جامد سیلسیس_سے_فارنہائٹ(c) {
        واپس c * 9 / 5 + 32;
    }

    جامد فارنہائٹ_سے_سیلسیس(f) {
        واپس (f - 32) * 5 / 9;
    }

    جامد سیلسیس_سے_کیلون(c) {
        واپس c - درجہ_حرارت.مطلق_صفر;
    }

    تبدیل_کرو(ہدف) {
        اگر (یہ.اکائی === "C" اور ہدف === "F") {
            واپس نیا درجہ_حرارت(درجہ_حرارت.سیلسیس_سے_فارنہائٹ(یہ.قدر), "F");
        }
        واپس یہ;
    }

    toString() {
        واپس `${یہ.قدر}°${یہ.اکائی}`;
    }
}

لکھو(درجہ_حرارت.مطلق_صفر);                            // -273.15
لکھو(درجہ_حرارت.سیلسیس_سے_فارنہائٹ(100));            // 212
لکھو(درجہ_حرارت.فارنہائٹ_سے_سیلسیس(32));             // 0

مستقل گرم = نیا درجہ_حرارت(37);
لکھو(`${گرم.تبدیل_کرو("F")}`);    // 98.6°F

// Static factory methods
کلاس رنگ {
    تعمیر(سرخ, سبز, نیلا) {
        یہ.سرخ = سرخ;
        یہ.سبز = سبز;
        یہ.نیلا = نیلا;
    }

    جامد سے_ہیکس(ہیکس) {
        مستقل n = عدد("0x" + ہیکس.بدلو("#", ""));
        واپس نیا رنگ((n >> 16) & 255, (n >> 8) & 255, n & 255);
    }

    ہیکس_میں() {
        واپس "#" + [یہ.سرخ, یہ.سبز, یہ.نیلا]
            .تبدیل(v => متن(v).padStart(2, "0"))
            .جوڑو("");
    }
}

مستقل نیلا = رنگ.سے_ہیکس("#0000FF");
لکھو(نیلا.سرخ, نیلا.سبز, نیلا.نیلا);    // 0 0 255

اردو: جامد فیکٹری طریقے کلاس کی مثال بنانے کے مختلف طریقے فراہم کرتے ہیں — رنگ.سے_ہیکس("#0000FF") ہیکس کوڈ سے رنگ بناتا ہے۔

Access Modifiers — رسائی ترمیم کار

Keyword Meaning Access
عوامی public Accessible everywhere (default)
نجی private Only within the class
محفوظ protected Class and subclasses

اردو: رسائی ترمیم کار یہ طے کرتے ہیں کہ کلاس کے ارکان کہاں سے قابلِ رسائی ہیں: عوامی ہر جگہ، نجی صرف اس کلاس کے اندر، محفوظ اس کلاس اور اس کے بچوں میں۔

کلاس صارف {
    عوامی نام;
    محفوظ ای_میل;
    نجی #پاس_ورڈ;     // private fields use # prefix

    تعمیر(نام, ای_میل, پاس_ورڈ) {
        یہ.نام = نام;
        یہ.ای_میل = ای_میل;
        یہ.#پاس_ورڈ = پاس_ورڈ;
    }

    عوامی پاس_ورڈ_چیک(آزمائش) {
        واپس یہ.#پاس_ورڈ === آزمائش;
    }

    نجی #ہیش_کرو(قدر) {
        // internal utility
        واپس `hashed_${قدر}`;
    }
}

مستقل u = نیا صارف("احمد", "a@b.com", "راز123");
لکھو(u.نام);                       // احمد
لکھو(u.پاس_ورڈ_چیک("راز123"));    // true
// لکھو(u.#پاس_ورڈ);               // غلطی — private

اردو: نجی فیلڈز # سے شروع ہوتی ہیں — #پاس_ورڈ باہر سے قابلِ رسائی نہیں۔ صرف پاس_ورڈ_چیک طریقے سے جانچ سکتے ہیں۔ یہ ڈیٹا چھپانے (encapsulation) کا بنیادی طریقہ ہے۔

Getters and Setters — حاصل کنندہ اور مقرر کنندہ

حاصل_کرو defines a computed read property. مقرر_کرو defines a property setter with validation.

اردو: حاصل_کرو ایک محسوب خاصیت بناتا ہے جو فنکشن کی طرح کام کرتی ہے لیکن خاصیت کی طرح پڑھی جاتی ہے۔ مقرر_کرو سیٹر بناتا ہے جہاں قدر سیٹ کرتے وقت تصدیق کی جا سکتی ہے۔

کلاس دائرہ {
    تعمیر(رداس) {
        یہ._رداس = رداس;
    }

    حاصل_کرو رداس() {
        واپس یہ._رداس;
    }

    مقرر_کرو رداس(قدر) {
        اگر (قدر < 0) پھینکو نیا RangeError("رداس منفی نہیں ہو سکتا");
        یہ._رداس = قدر;
    }

    حاصل_کرو قطر() {
        واپس یہ._رداس * 2;
    }

    حاصل_کرو رقبہ() {
        واپس ریاضی.PI * یہ._رداس ** 2;
    }

    حاصل_کرو محیط() {
        واپس 2 * ریاضی.PI * یہ._رداس;
    }
}

مستقل د = نیا دائرہ(5);
لکھو(د.رداس);              // 5
لکھو(د.قطر);               // 10
لکھو(گول(د.رقبہ, 2));      // 78.54
لکھو(گول(د.محیط, 2));      // 31.42

د.رداس = 10;
لکھو(د.قطر);               // 20

اردو: حاصل_کرو خاصیتیں فنکشن کال بغیر () کے استعمال ہوتی ہیں — د.رقبہ پڑھنے سے حساب خودبخود ہوتا ہے۔ مقرر_کرو میں تصدیق سے منفی رداس کی غلطی روکی گئی۔

کلاس درجہ_حرارت_گیج {
    تعمیر() {
        یہ._سیلسیس = 0;
    }

    حاصل_کرو سیلسیس() { واپس یہ._سیلسیس; }
    مقرر_کرو سیلسیس(قدر) { یہ._سیلسیس = قدر; }

    حاصل_کرو فارنہائٹ() { واپس یہ._سیلسیس * 9 / 5 + 32; }
    مقرر_کرو فارنہائٹ(قدر) { یہ._سیلسیس = (قدر - 32) * 5 / 9; }

    حاصل_کرو کیلون() { واپس یہ._سیلسیس + 273.15; }
}

مستقل گیج = نیا درجہ_حرارت_گیج();
گیج.سیلسیس = 100;
لکھو(گیج.فارنہائٹ);    // 212
لکھو(گیج.کیلون);       // 373.15

گیج.فارنہائٹ = 32;
لکھو(گیج.سیلسیس);      // 0

اردو: درجہ حرارت کی مثال بہت خوبصورت ہے — ایک کسی بھی اکائی میں سیٹ کریں، باقی سب خودبخود تبدیل ہو جاتے ہیں!

Polymorphism — کثیرالشکلی

Subclasses override methods. Code that calls the method gets the right behaviour at runtime.

اردو: کثیرالشکلی (polymorphism) کا مطلب ہے کہ مختلف کلاسیں ایک ہی نام کا طریقہ مختلف طریقے سے چلاتی ہیں۔ کوڈ طریقہ بلاتا ہے، چلتے وقت صحیح برتاؤ ملتا ہے — یہ OOP کی طاقت ہے۔

کلاس شکل {
    رقبہ() { واپس 0; }
    محیط() { واپس 0; }
    toString() { واپس `شکل (رقبہ: ${گول(یہ.رقبہ(), 2)})`; }
}

کلاس دائرہ توسیع شکل {
    تعمیر(r) { سپر(); یہ.r = r; }
    رقبہ() { واپس ریاضی.PI * یہ.r ** 2; }
    محیط() { واپس 2 * ریاضی.PI * یہ.r; }
    toString() { واپس `دائرہ r=${یہ.r} — ${سپر.toString()}`; }
}

کلاس مربع توسیع شکل {
    تعمیر(a) { سپر(); یہ.a = a; }
    رقبہ() { واپس یہ.a ** 2; }
    محیط() { واپس 4 * یہ.a; }
    toString() { واپس `مربع a=${یہ.a} — ${سپر.toString()}`; }
}

کلاس مستطیل توسیع شکل {
    تعمیر(w, h) { سپر(); یہ.w = w; یہ.h = h; }
    رقبہ() { واپس یہ.w * یہ.h; }
    محیط() { واپس 2 * (یہ.w + یہ.h); }
}

// Polymorphic usage — same call, different result
مستقل شکلیں = [
    نیا دائرہ(5),
    نیا مربع(4),
    نیا مستطیل(3, 6)
];

مستقل کل_رقبہ = شکلیں.کم_کرو((جمع, ش) => جمع + ش.رقبہ(), 0);

کے_لیے (مستقل ش کا شکلیں) {
    لکھو(`${ش} | محیط: ${گول(ش.محیط(), 2)}`);
}

لکھو(`کل رقبہ: ${گول(کل_رقبہ, 2)}`);

اردو: شکلیں فہرست میں مختلف شکلیں ہیں — دائرہ، مربع، مستطیل۔ ش.رقبہ() سب کے لیے ایک ہی کوڈ لیکن ہر شکل اپنا حساب کرتی ہے۔ یہی کثیرالشکلی کی خوبصورتی ہے!

Complete Bank Account Example — مکمل بینک کھاتے کی مثال

A full example combining constructor, private fields, getters, methods, and inheritance.

اردو: یہ مکمل مثال تعمیر کنندہ، نجی فیلڈز، گیٹرز، طریقوں اور وراثت سب کو ملا کر دکھاتی ہے۔ ایک حقیقی بینک نظام کا سادہ ورژن!

کلاس بینک_کھاتہ {
    #بقیہ;
    #لین_دین = [];

    تعمیر(مالک, ابتدائی_رقم = 0) {
        یہ.مالک = مالک;
        یہ.#بقیہ = ابتدائی_رقم;
        یہ.کھاتہ_نمبر = "PKT-" + ریاضی.فرش(اتفاقی() * 1e9);
    }

    حاصل_کرو بقیہ() {
        واپس یہ.#بقیہ;
    }

    جمع_کرو(رقم, وضاحت = "جمع") {
        اگر (رقم <= 0) پھینکو نیا Error("رقم صفر سے زیادہ ہونی چاہیے");
        یہ.#بقیہ += رقم;
        یہ.#لین_دین.شامل({ نوع: "جمع", رقم, وضاحت, وقت: نیا Date() });
        واپس یہ;
    }

    نکالو(رقم, وضاحت = "نکلوائی") {
        اگر (رقم <= 0) پھینکو نیا Error("رقم صفر سے زیادہ ہونی چاہیے");
        اگر (رقم > یہ.#بقیہ) پھینکو نیا Error("ناکافی بقیہ");
        یہ.#بقیہ -= رقم;
        یہ.#لین_دین.شامل({ نوع: "نکلوائی", رقم, وضاحت, وقت: نیا Date() });
        واپس یہ;
    }

    منتقل_کرو(ہدف_کھاتہ, رقم) {
        یہ.نکالو(رقم, `منتقلی → ${ہدف_کھاتہ.کھاتہ_نمبر}`);
        ہدف_کھاتہ.جمع_کرو(رقم, `منتقلی ← ${یہ.کھاتہ_نمبر}`);
        واپس یہ;
    }

    تاریخچہ() {
        لکھو(`\n=== ${یہ.مالک} — ${یہ.کھاتہ_نمبر} ===`);
        کے_لیے (مستقل [i, ل] کا گنو(یہ.#لین_دین, 1)) {
            مستقل علامت = ل.نوع === "جمع" ? "+" : "-";
            لکھو(`${i}. ${علامت}${ل.رقم} — ${ل.وضاحت}`);
        }
        لکھو(`موجودہ بقیہ: ${یہ.#بقیہ}`);
    }
}

کلاس بچت_کھاتہ توسیع بینک_کھاتہ {
    تعمیر(مالک, ابتدائی_رقم, سود_شرح = 0.05) {
        سپر(مالک, ابتدائی_رقم);
        یہ.سود_شرح = سود_شرح;
    }

    سود_لگاؤ() {
        مستقل سود = ریاضی.فرش(یہ.بقیہ * یہ.سود_شرح);
        یہ.جمع_کرو(سود, "سالانہ سود");
        واپس سود;
    }
}

// Usage
مستقل احمد_کا = نیا بینک_کھاتہ("احمد", 5000);
مستقل فاطمہ_کا = نیا بچت_کھاتہ("فاطمہ", 10000, 0.08);

احمد_کا
    .جمع_کرو(3000, "تنخواہ")
    .جمع_کرو(500, "فری لانس")
    .نکالو(1000, "کرایہ");

احمد_کا.منتقل_کرو(فاطمہ_کا, 2000);

لکھو(`فاطمہ کا بقیہ: ${فاطمہ_کا.بقیہ}`);    // 12000

مستقل سود = فاطمہ_کا.سود_لگاؤ();
لکھو(`سود: ${سود}`);                         // 960

احمد_کا.تاریخچہ();
فاطمہ_کا.تاریخچہ();

اردو: اس مکمل مثال میں: نجی فیلڈز #بقیہ اور #لین_دین باہر سے قابلِ رسائی نہیں، بقیہ گیٹر سے پڑھا جاتا ہے، طریقے یہ واپس کر کے زنجیر بنانے دیتے ہیں، اور بچت_کھاتہ وراثت سے سود_لگاؤ کا اضافہ کرتا ہے۔

Mixins — ملاوٹ

Mixins add reusable behaviour to classes without deep inheritance hierarchies.

اردو: ملاوٹ (mixins) گہری وراثتی درجہ بندی کے بغیر کلاسوں میں دوبارہ قابلِ استعمال طرزِعمل شامل کرتے ہیں۔ جب ایک کلاس کو کئی مختلف صلاحیتیں چاہیے ہوں تو ملاوٹ بہترین ہیں۔

// Mixin functions
مستقل سیریل_مکسن = (بنیاد) => کلاس توسیع بنیاد {
    JSON_میں() {
        واپس JSON_لکھو(یہ);
    }

    جامد JSON_سے(متن_شے) {
        واپس Object.assign(نیا یہ(), JSON_پڑھو(متن_شے));
    }
};

مستقل قابل_مقایسہ_مکسن = (بنیاد) => کلاس توسیع بنیاد {
    برابر_ہے(دوسرا) {
        واپس یہ.toString() === دوسرا.toString();
    }
};

// Apply mixins
کلاس بنیادی_شخص {
    تعمیر(نام, عمر) {
        یہ.نام = نام;
        یہ.عمر = عمر;
    }
    toString() { واپس `${یہ.نام}(${یہ.عمر})`; }
}

کلاس شخص توسیع قابل_مقایسہ_مکسن(سیریل_مکسن(بنیادی_شخص)) {}

مستقل ا = نیا شخص("احمد", 25);
مستقل ب = نیا شخص("احمد", 25);

لکھو(ا.JSON_میں());           // {"نام":"احمد","عمر":25}
لکھو(ا.برابر_ہے(ب));          // true

اردو: ملاوٹ فنکشن ایک کلاس لیتا ہے اور اس میں اضافی طریقے شامل کر کے نئی کلاس واپس کرتا ہے۔ شخص کلاس نے دو ملاوٹیں لگائیں: سیریل_مکسن (JSON میں تبدیلی) اور قابل_مقایسہ_مکسن (برابری جانچ)۔ یہ لچکدار اور صاف کوڈ کا طریقہ ہے!