عرض مصدر TypeScript/classes

<noinclude>{{DISPLAYTITLE:الأصناف في TypeScript}}</noinclude>

==مقدمة==
تعتمد لغة JavaScript التقليدية على الدوال والوراثة المعتمدة على سلسلة Prototype لبناء مكونات قابلة لإعادة الاستعمال، وقد يجد بعض المبرمجين هذه الطريقة غريبة ومرهقة، خاصّة الذين ألِفوا البرمجة كائنيّة التوجه التي تعتمد على الأصناف التي ترث وظيفة (functionality) الأصناف الأساس (base classes) وتُبنَى فيها الكائنات من هذه الأصناف. بدايةً من الإصدار ECMAScript 2015 المعروف كذلك بالإصدار ECMAScript 6، يُمكن لمبرمجي JavaScript بناء التطبيقات باستخدام البرمجة كائنيّة التوجّه المعتمِدة على الأصناف. وتسمح TypeScript للمطورين باستعمال هذه التقنيات الآن، وتُترجِمها إلى لغة JavaScript تعمل على جميع المنصات المتصفحات المعروفة، دون الحاجة إلى انتظار دعم النسخة التالية من JavaScript.

==الأصناف==
لنلق نظرة على مثال صنف بسيط:
<syntaxhighlight lang="typescript">
class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter = new Greeter("world");
</syntaxhighlight>
يجب على البنية العامّة (syntax) أن تبدو مألوفة لك إن سبق وأن استعملت لغات مثل C#‎ أو Java. هنا نُصرّح عن صنف جديد باسم ‎<code>Greeter</code>‎. لهذا الصنف ثلاثة عناصر: خاصيّة باسم ‎<code>greeting</code>‎، ودالة بانيّة (constructor)، وتابع باسم ‎<code>greet</code>‎.

ستُلاحظ بأنّنا نستعمل السابقة ‎<code>this.‎</code>‎ للوصول إلى عناصر الصنف، وهذا يدلّ على أنّه وصول إلى العنصر (member access).

في السطر الأخير، نقوم ببناء نسخة من الصنف ‎<code>Greeter</code>‎ باستعمال الكلمة المفتاحية ‎<code>new</code>‎. هذا يستدعي الدالة البانيّة التي عرّفنا مسبقًا، ما يُنشئ كائنًا جديدًا على شكل الصنف ‎<code>Greeter</code>‎ مُنفّذًا الدالة البانيّة لتهيئته.

==الوراثة==
يُمكننا استعمال أنماط البرمجة كائنيّة التوجّه الشّائعة في لغة TypeScript. وأحد الأنماط الأساسية هو قابلية توسيع الأصناف لإنشاء أصناف جديدة باستخدام الوراثة (inheritance).

لنلقِ نظرةً على مثال بسيط:
<syntaxhighlight lang="typescript">
class Animal {
    move(distanceInMeters: number = 0) {
        console.log(`Animal moved ${distanceInMeters}m.`);
    }
}

class Dog extends Animal {
    bark() {
        console.log('Woof! Woof!');
    }
}

const dog = new Dog();
dog.bark();
dog.move(10);
dog.bark();
</syntaxhighlight>
يُوضّح هذا المثال ميزة الوراثة الأكثر مبدئيّةً: وهي أن الأصناف ترث الخاصيات والتوابع من الأصناف الأساس. هنا، الصنف ‎<code>Dog</code>‎ صنفٌ مُشتقٌّ يَشتقُّ من الصنف الأساس ‎<code>Animal</code>‎ بالكلمة المفتاحية ‎<code>extends</code>‎. عادةً ما يُطلق على الأصناف المُشتقَّة اسم "الأصناف الفرعيّة (subclasses)"، والأصناف الأساس يُطلق عليها اسم "الأصناف العليا (superclasses)".

لأنّ الصنف ‎<code>Dog</code>‎ يوسّع وظيفة الصنف ‎<code>Animal</code>‎، فقد استطعنا إنشاء نسخة من الصنف ‎<code>Dog</code>‎ لها كلا التابعين ‎<code>bark()‎</code>‎ و‎<code>move()‎</code>‎.

لننتقل الآن إلى مثال أعقد:
<syntaxhighlight lang="typescript">
class Animal {
    name: string;
    constructor(theName: string) { this.name = theName; }
    move(distanceInMeters: number = 0) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}

class Snake extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 5) {
        console.log("Slithering...");
        super.move(distanceInMeters);
    }
}

class Horse extends Animal {
    constructor(name: string) { super(name); }
    move(distanceInMeters = 45) {
        console.log("Galloping...");
        super.move(distanceInMeters);
    }
}

let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");

sam.move();
tom.move(34);
</syntaxhighlight>
يُغطّي هذا المثال بعض الميزات الأخرى التي لم نذكرها مسبقًا. نستخدم مُجدّدًا الكلمة المفتاحية ‎<code>extends</code>‎ لإنشاء صنفين فرعيّين من الصنف ‎<code>Animal</code>‎، وهُما ‎<code>Horse</code>‎ و‎<code>Snake</code>‎.

من الاختلافات الموجودة بين المثال أعلاه والذي يسبقه هو أن كل صنف مشتقّ يجب أن تحتوي دالته البانية على استدعاء ‎<code>super()‎</code>‎ الذي يُنفّذ الدالة البانيّة الخاصّة بالصنف الأساس. إضافةً إلى ذلك، لا بدّ من استدعاء ‎<code>super()‎</code>‎ قبل الوصول إلى خاصية باستعمال ‎<code>this‎</code>‎ في داخل دالة بانية. هذه قاعدة مهمّة تقضي بها TypeScript.

يوضح هذا المثال كذلك كيفيّة تجاوز (override) توابع الصنف الأساس واستبدالها بتوابع مُخصّصة للصنف الفرعي. إذ يقوم كل من الصنف ‎<code>Snake</code>‎ والصنف ‎<code>Horse</code>‎ بإنشاء تابع باسم ‎<code>move</code>‎ يتجاور ويغطّي على التابع ‎<code>move</code>‎ الموجود في الصنف ‎<code>Animal</code>‎، ما يمنح للتابع وظيفة خاصّة في كل صنف. لاحظ أن ‎<code>tom</code>‎ مصرحٌ عنه على أنّه من النوع ‎<code>Animal</code>‎، ولأن قيمته هي ‎<code>Horse</code>‎، فاستدعاء ‎<code>‎tom.‎move‎(34)‎</code>‎ سيستدعي التابع المُتجاوِز الموجود في الصنف ‎<code>Horse</code>‎:
<syntaxhighlight lang="typescript">
Slithering...
Sammy the Python moved 5m.
Galloping...
Tommy the Palomino moved 34m.
</syntaxhighlight>
==المحدّدات  ‎<code>public</code>‎، و‎<code>private</code>‎، و‎<code>protected</code>‎==
===كل شيء عام (public) افتراضيّا===
تمكنّا في الأمثلة أعلاه من الوصول بحريّة إلى العناصر التي صرّحنا عنها في البرامج في كل مكان منها. إن كانت لديك خبرة في التعامل مع الأصناف في اللغات الأخرى، فقد تلاحظ بأنّنا لم نحتج إلى استعمال الكلمة المفتاحيّة ‎<code>public</code>‎ في الأمثلة أعلاه لجعل العناصر عامة، إذ تتطلّب مثلًا لغة C#‎ أن تسبق الكلمة المفتاحيّةُ ‎<code>public</code>‎ العناصرَ بوضوح لكي تكون مرئيّة. أمّا في TypeScript، فجميع العناصر عامّة بشكل افتراضيّ.

لكنّك لا تزال تستطيع تعليم (mark) عنصر بالكلمة ‎<code>public</code>‎ صراحةً (explicitly). إذ كان يُمكن كتابة الصنف ‎<code>Animal</code>‎ السابق كما يلي:
<syntaxhighlight lang="typescript">
class Animal {
    public name: string;
    public constructor(theName: string) { this.name = theName; }
    public move(distanceInMeters: number) {
        console.log(`${this.name} moved ${distanceInMeters}m.`);
    }
}
</syntaxhighlight>
===المُحدّد ‎<code>private</code>‎ ===
عندما يُحدَّد عنصر بالمُحدِّد ‎<code>private</code>‎‎، فهذا يعني بأنّه عنصر خاصّ لا يُمكن الوصول إليه من خارج الصنف الذي يحتوي عليه. مثلًا:
<syntaxhighlight lang="typescript">
class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name;
// خطأ، العنصر
// 'name'
// عنصرٌ خاصّ
</syntaxhighlight>
تعتمد لغة TypeScript على نظام أنواع هيكلي (structural type system). عندما نقارن بين نوعين مختلفين، فسنقول بأنّهما متوافقان إذا كانت أنواع جميع العناصر متوافقة، وذلك بغضّ النظر عن مصدر هاذين النوعين.

لكن عند المقارنة بين نوعين يحتويان على عناصر خاصّة (<code>private</code>) وعناصر محميّة (<code>protected</code>)، فإنّنا نتعامل مع هاذين النوعين على أنّهما مختلفان. ولكي يتوافق نوعان لدى أحدهما عنصر خاص، فعلى الآخر أن يحتوي على عنصر خاص تأصّل من نفس التصريح. ونفس المبدأ ينطبق على العناصر المحميّة.

بالمثال يتّضح المقال:
<syntaxhighlight lang="typescript">
class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

class Rhino extends Animal {
    constructor() { super("Rhino"); }
}

class Employee {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino;
animal = employee; // Error
// خطأ النوعان
// 'Animal'و 'Employee'
// ليسا متوافقين
</syntaxhighlight>
في هذا المثال، لدينا الصنف ‎<code>Animal</code>‎ والصّنف ‎<code>Rhino</code>‎، مع كون الصنف ‎<code>Rhino</code>‎ صنفًا فرعيًّا من الصنف ‎<code>Animal</code>‎. لدينا كذلك صنف جديد باسم ‎<code>Employee</code>‎ مُشابهٍ للصنف ‎<code>Animal</code>‎ في شكله. نُنشئُ نسخًا من هذه الأصناف ونحاول إسنادها لبعضها البعض لنرى ما سيحدث. ولأنّ ‎<code>Animal</code>‎ و‎<code>Rhino</code>‎ يتشاركان في الجانب الخاص (private side) من شكلهما من نفس التصريح ‎<code>‎private‎ name:‎ string‎‎</code>‎ الموجود داخل الصنف ‎<code>Animal</code>‎، فهُما متوافقان. لكن الصنف ‎<code>Employee</code>‎ لا يوجد في نفس الحالة. ونحصل على خطأ عندما نحاول تعيين نسخة من الصنف ‎<code>Employee</code>‎ إلى نسخة من الصنف ‎<code>Animal</code>‎، يُخبرنا هذا الخطأ بأنّ النوعين ليسا متوافقين. ورغم أنّ للصنف ‎<code>Employee</code>‎ عنصرًا خاصًّا باسم ‎<code>name</code>‎، إلّا أنّ هذا العنصر ليس هو نفسه ذلك الموجود في الصنف ‎<code>Animal</code>‎.

===المُحدّد ‎<code>protected</code>‎ ===
يتصرّف المُحدّد ‎<code>protected</code>‎ مثل المُحدّد ‎<code>private</code>‎ باستثناء أنّ العناصر التي يُصرّح عنها على أنّها محميّة بالمُحدّد ‎<code>protected</code>‎ قابلة للوصول إليها من الأصناف المشتقّة. مثلًا:
<syntaxhighlight lang="typescript">
class Person {
    protected name: string;
    constructor(name: string) { this.name = name; }
}

class Employee extends Person {
    private department: string;

    constructor(name: string, department: string) {
        super(name);
        this.department = department;
    }

    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // خطأ
</syntaxhighlight>
لاحظ أنّه رغم أنّنا لا نستطيع الوصول إلى العنصر ‎<code>name</code>‎ من خارج الصنف ‎<code>Person</code>‎، إلا أنّه لا يزال بإمكاننا استعمالها من داخل تابع نسخة (instance method) في الصنف ‎<code>Employee</code>‎ لأن الصنف ‎<code>Employee</code>‎ يرث من الصنف ‎<code>Person</code>‎.

يُمكن كذلك تعليم الدالة البانية بالمُحدّد ‎<code>protected</code>‎. هذا يعني بأنّ الصنف لا يُمكن أن يُهيّأ (instantiated) أي لا يمكن أن تُنشأ نسخة منه خارج الصنف الذي يحتويه، لكنّ توسيعه (أي الوراثة منه) ممكن. مثلًا:
<syntaxhighlight lang="typescript">
class Person {
    protected name: string;
    protected constructor(theName: string) { this.name = theName; }
}

// يُمكن للصنف
// Employee
// أن يُوسِّعَ الصنف
// Person

class Employee extends Person {
    private department: string;

    constructor(name: string, department: string) {
        super(name);
        this.department = department;
    }

    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // خطأ، لا يُمكن إنشاء نسخة من الصنف لأنّ دالّته البانيّة محميّة
</syntaxhighlight>
==محدد قابلية القراءة فقط (Readonly modifier)==
يُمكنك تحديد خاصيةٍ على أنها قابلة للقراءة فقط باستعمال الكلمة المفتاحية ‎<code>readonly</code>‎. يجب على الخاصيات القابلة للقراءة فقط أن تُهيأ (initialized) عند التصريح عنها أو داخل الدالة البانيّة.
<syntaxhighlight lang="typescript">
class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // خطأ، الخاصية قابلة للقراءة فقط، لا يمكن إسناد قيمة لها
</syntaxhighlight>
===خاصيات المعاملات (Parameter properties)===
في المثال أعلاه، توجّب علينا التصريح عن عنصر قابل للقراءة فقط باسم ‎<code>name</code>‎ ومعامل للدالة البانيّة باسم ‎<code>theName</code>‎ في الصنف ‎<code>Octopus</code>‎، وبعدها فورًا نُعيّن قيمة ‎<code>theName</code>‎ للخاصية ‎<code>name</code>‎. طريقة العمل هذه شائعة جدًا. لذا فخاصيات المعاملات ميّزة تسمح لنا بإنشاء وتهيئة عنصر في مكان واحد. ما يلي مراجعة للصنف ‎<code>Octopus</code>‎ باستخدام خاصية معامل:
<syntaxhighlight lang="typescript">
class Octopus {
    readonly numberOfLegs: number = 8;
    constructor(readonly name: string) {
    }
}
</syntaxhighlight>
لاحظ كيف أنّنا تخلّينا عن استخدام ‎<code>theName</code>‎ كليًّا واستعملنا العبارة المختصرة ‎<code>‎readonly‎ name:‎ string‎ ‎</code>‎ كمعامل للدالة البانية لإنشاء وتهيئة العنصر ‎<code>name</code>‎. وقد جمعنا التصريحات مع التعيين في مكان واحد.

يُصرَّح عن خاصيات المعاملات عبر سَبْقِ معاملات الدالة البانية بمُحدّد وصول أو الكلمة المفتاحية ‎<code>readonly</code>‎، أو كليهما معًا. استخدام ‎<code>private</code>‎ مع خاصية معامل يُصرّح عن عنصر خاص ويهيئُه؛ ونفس المبدأ ينطبق مع كل من ‎<code>public</code>‎، و‎<code>protected</code>‎، و‎<code>readonly</code>‎.

==توابع الوصول (Accessors)==
تدعم TypeScript توابع الجلب (getters) التي تحصل على قيم الخاصيات، وتوابع الضبط (setters) التي تضبط قيمًا للخاصيات، وهذه ميزة تُستخدم لتعديل طريقة عمل البرامج عند الوصول إلى عناصر كائن معيّن. وهذا يُعطيك طريقة أفضل للتحكم في كيفية الوصول إلى العناصر على كل كائن.

لنُحوِّل صنفًا بسيطًا ليستعمل الكلمتين المفتاحيتين ‎<code>get</code>‎ و‎<code>set</code>‎. أولًا، لنبدأ بمثال خالٍ من توابع الجلب وتوابع الضبط:
<syntaxhighlight lang="typescript">
class Employee {
    fullName: string;
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    console.log(employee.fullName);
}
</syntaxhighlight>
السماح للناس بضبط قيمة للخاصية ‎ <code>fullName</code>‎التي تُمثّل الاسم الكامل للموظّف يُسهّل المأمورية، إلا أن السماح للناس بتغيير الأسماء بهذه البساطة قد يجلب لنا المشاكل.

في النسخة أدناه، نتحقّق من أن هناك جملة سرية (المتغيّر ‎<code>passcode</code>‎) قبل السماح بتعديل بيانات الموظف. نقوم بهذا عبر استبدال الوصول المباشر (direct access) إلى الخاصية ‎<code>fullName</code>‎ بتابع ‎<code>set</code>‎ يتحقق من وجود الجملة السرية وصحّتها قبل تغيير الاسم. ونُضيف تابع ‎<code>get</code>‎ للسماح بالمثال السابق بالعمل كما كان:
<syntaxhighlight lang="typescript">
let passcode = "secret passcode";

class Employee {
    private _fullName: string;

    get fullName(): string {
        return this._fullName;
    }

    set fullName(newName: string) {
        if (passcode && passcode == "secret passcode") {
            this._fullName = newName;
        }
        else {
            console.log("Error: Unauthorized update of employee!");
        }
    }
}

let employee = new Employee();
employee.fullName = "Bob Smith";
if (employee.fullName) {
    console.log(employee.fullName);
}
</syntaxhighlight>
للتحقق من أن تابع الوصول يتحقق الآن من الجملة السرية، يُمكن تغييرها والنظر فيما إذا كانت هناك رسالة تُنبّهنا إلى أنّنا لا نملك امتيازات تسمح لنا بتحديث بيانات الموظف.

هناك بعض الأمور المتعلقة بتوابع الوصول لأخذها بعين الاعتبار:

* تتطلّب توابع الوصول ضبطَ المُترجم (compiler) لإخراج شيفرة تدعم النسخة ECMAScript 5 من JavaScript أو النسخ الأحدث منها. وتخفيض المستوى إلى ECMAScript 3 لا يُمكن.
* عند استعمال تابع الوصول ‎<code>get</code>‎ دون تابع الوصول ‎<code>set</code>‎ فهذا يعني بأن الخاصية قابلة للقراءة فقط ‎<code>readonly</code>‎ تلقائيًّا. هذا مُفيد عند توليد ملفّ ‎<code>‎.d.ts‎</code>‎ من شيفرتك، لأن مستخدمي الخاصية سيُلاحظون بأنهم لا يستطيعون تغيير قيمتها.

==الخاصيات الساكنة (Static Properties)==
إلى الآن، تحدثنا فقط عن عناصر ''النسخة'' في الصنف، وهي العناصر التي تظهر عندما يُهيّئ الكائن. لكن يُمكننا إنشاء عناصر ''ساكنة'' كذلك، وهي العناصر التي تكون ظاهرة على الصنف ذاته عوضًا عن ظهورها على النسخ. في هذا المثال، نستعمل الكلمة المفتاحية ‎<code>static</code>‎ على نقطة الأصل ‎<code>origin</code>‎، وذلك لأنها قيمة عامة لجميع الشبكات (grids). بحيث تصل كل نسخة إلى هذه القيمة عبر وضع اسم الصنف قبلها كسابقة. وكما نستعمل السابقة <code>‎this.‎</code> عند الوصول إلى بيانات النسخ، فإنّنا نستعمل السابقة ‎<code>‎Grid.‎</code>‎ للوصول إلى البيانات الساكنة.

<syntaxhighlight lang="typescript">
class Grid {
    static origin = {x: 0, y: 0};
    calculateDistanceFromOrigin(point: {x: number; y: number;}) {
        let xDist = (point.x - Grid.origin.x);
        let yDist = (point.y - Grid.origin.y);
        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
    }
    constructor (public scale: number) { }
}

let grid1 = new Grid(1.0);  // 1x scale
let grid2 = new Grid(5.0);  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
</syntaxhighlight>

==الأصناف المجرَّدة (Abstract Classes)==
الأصناف المجرَّدة هي أصناف أساس (base classes) قد تُشتَقّ منها أصناف أخرى. ويُمكن ألا تُهيّأ مباشرة. وعلى النقيض من الواجهات، يُمكن للأصناف المجرَّدة أن تحتوي على تفاصيل تطبيق (implementation details) لعناصرها. تُستعمل الكلمة المفتاحية ‎<code>abstract</code>‎ لتعريف الأصناف المُجرّدة وتعريف التوابع المجرّدة داخل صنف مجرّد:
<syntaxhighlight lang="typescript">
abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log("roaming the earth...");
    }
}
</syntaxhighlight>
التوابع المجردة الموجودة داخل صنف مُجرد لا تحتوي أي تطبيق (implementation) ويجب أن تُطبَّق على الصنف المشتَق. بنية التوابع المجردة مشابهة لتوابع الواجهات، إذ كلاهما يُعرِّف توقيع التابع دون جسمه (أي الشيفرة التي تكون داخل التابع). لكن على التوابع المجرّدة  أن تُسبَق بالكلمة المفتاحية ‎<code>abstract</code>‎ ويُمكن أن تحتوي على محدّدات وصول (access modifiers) اختياريًّا:
<syntaxhighlight lang="typescript">
abstract class Department {

    constructor(public name: string) {
    }

    printName(): void {
        console.log("Department name: " + this.name);
    }

    abstract printMeeting(): void; // يجب تطبيقها في الأصناف المشتقّة
}

class AccountingDepartment extends Department {

    constructor() {
        // يجب على الدوال البانيّة داخل الأصناف المشتقّة استدعاء الدالة
        // super()
        super("Accounting and Auditing");
    }

    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10am.");
    }

    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}

let department: Department; // إنشاء مرجع يشير إلى نوع مجرَّدٍ أمرٌ مسموح به
department = new Department(); // خطأ، لا يمكن إنشاء نسخة من صنف مجرّد
department = new AccountingDepartment(); // إنشاء نسخة من صنف فرعي غير مجرّد وإسنادها إلى متغيّر مسموح به
department.printName();
department.printMeeting();
department.generateReports(); // خطأ، التابع غير موجود في التصريح عن النوع المجرّد
</syntaxhighlight>
==تقنيات متقدمة==
===الدوال البانية (Constructor functions)===
عند التصريح عن صنف في TypeScript، فإنّك في الواقع تُنشئ عدة تصريحات في نفس الوقت. الأول هو نوع نُسخةِ الصّنف (the instance of the class).
<syntaxhighlight lang="typescript">
class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter: Greeter;
greeter = new Greeter("world");
console.log(greeter.greet());
</syntaxhighlight>
نستعمل في التصريح ‎<code>‎let greeter: Greeter‎</code>‎  في المثال أعلاه الصنف ‎<code>Greeter</code>‎ ليكون نوع نسخ الصنف ‎<code>Greeter</code>‎. هذا الأمر مألوف جدا للمبرمجين المعتادين على لغات أخرى كائنيّة التوجه.

وننشئ كذلك قيمة أخرى نُسميها بالدالة البانيّة. هذه الدالة هي التي تُستدعَى عند إنشاء نُسخ من الصنف بالكلمة المفتاحية ‎<code>new</code>‎. لنُلقِ نظرة على شيفرة JavaScript التي يُولدها المثال أعلاه لمعرفة كيف يعمل هذا عمليًّا:
<syntaxhighlight lang="typescript">
let Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();

let greeter;
greeter = new Greeter("world");
console.log(greeter.greet());
</syntaxhighlight>
سيُعيَّن التصريح ‎<code>let Greeter</code>‎ هنا للدالة البانية. نحصل على نسخة من الصنف عند استدعاء هذه الدالة وتنفيذها بالكلمة المفتاحية ‎<code>new</code>‎. تحتوي الدالة البانية كذلك على جميع عناصر الصنف الساكنة. يُمكن النظر إلى كل صنف على أنّ له جانبَ نسخة (instance side) وجانبًا ساكنًا (static side).

لنُعدّل المثال قليلًا لإظهار الفرق:
<syntaxhighlight lang="typescript">
class Greeter {
    static standardGreeting = "Hello, there";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello, " + this.greeting;
        }
        else {
            return Greeter.standardGreeting;
        }
    }
}

let greeter1: Greeter;
greeter1 = new Greeter();
console.log(greeter1.greet());

let greeterMaker: typeof Greeter = Greeter;
greeterMaker.standardGreeting = "Hey there!";

let greeter2: Greeter = new greeterMaker();
console.log(greeter2.greet());
</syntaxhighlight>
في هذا المثال، يعمل ‎<code>greeter1</code>‎ كما سبق. إذ نُنشئ نسخة من الصنف ‎<code>Greeter</code>‎، ونستعمل هذا الكائن. وقد رأينا هذا من قبل.

ثمّ بعدها نستعمل الصنف مباشرة. وننشئ هنا متغيّرًا جديدًا باسم ‎<code>greeterMaker</code>‎. سيحمل هذا المتغيّر الصنف نفسه، أو بالأحرى، دالّتَه البانيّة. نستعمل هنا  ‎<code>typeof Greeter</code>‎ وكأنّنا نقول "أعطني نوع الصنف ‎<code>Greeter</code>‎ نفسه" عوضًا عن نوع النسخة. أو بدقّة أكثر، وكأنّنا نقول "أعطني نوع الرمز (symbol) المُسمّى بالاسم ‎<code>Greeter</code>‎" وهو نوع الدالة البانيّة. يحتوي هذا النوع على جميع العناصر الساكنة للصنف ‎<code>Greeter</code>‎ إضافة إلى الدالة البانيّة التي تُنشئ نسخًا من الصنف ‎<code>Greeter</code>‎. ونُظهر هذا عبر استخدام الكلمة المفتاحية ‎<code>new</code>‎ على ‎<code>greeterMaker</code>‎، مُنشئين نسخًا جديدة من ‎<code>Greeter</code>‎  مع استعمالها كما سبق.

===استعمال صنف كواجهة (interface)===
يُنشئ التصريح عن صنف كما قلنا سابقًا شيئين اثنين: نوع يُمثّل نسخ الصنف، ودالة بانيّة. ولأن الأصناف تُنشِئ أنواعًا، فيُمكن استعمالها في نفس الأماكن التي يُمكن استعمال الواجهات فيها.
<syntaxhighlight lang="typescript">
class Point {
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

let point3d: Point3d = {x: 1, y: 2, z: 3};
</syntaxhighlight>

== مصادر ==
* [https://www.typescriptlang.org/docs/handbook/classes.html صفحة Classes في توثيق TypeScript الرسمي.]
[[تصنيف:TypeScript]]