عرض مصدر TypeScript/basic types

<noinclude>{{DISPLAYTITLE: الأنواع الأساسية في TypeScript}}</noinclude>علينا أن نتمكن من العمل مع أنواع بسيطة من البيانات لتكون برامجنا مُفيدة، مثل الأعداد (numbers)، والسلاسل النصية (strings)، الهياكل (structures)، القيم المنطقية (boolean values)، وغيرها من أنواع البيانات. تدعم TypeScript تقريبًا نفس الأنواع التي تدعمها لغة JavaScript، إضافة إلى نوعٍ جديدٍ للثوابت المتعددة (enumeration type) للمساعدة على بناء تطبيقات أفضل.

==القيم المنطقية (boolean)==

القيمتان ‎<code>true</code>‎ و‎<code>false</code>‎ من أكثر أنواع البيانات بساطة، وتُسمى في JavaScript  وTypeScript بالقيمة المنطقية، أو النوع ‎<code>boolean</code>‎.
<syntaxhighlight lang="typescript">
let isDone: boolean = false;
</syntaxhighlight>

==الأعداد (number)==
كما هو الحال مع JavaScript، فجميع الأعداد في TypeScript قيم نقطة عائمة (floating point values). وهذه الأعداد العشرية ذات النقطة العائمة ترتبط بالنوع ‎<code>number</code>‎. وتدعم TypeScript كذلك البيانات الثنائية (binary) والبيانات الثمانية (octal) التي قدّمتها نسخة ECMAScript 2015، إضافةً إلى الأعداد الست عشرية (Hexadecimal) والبيانات الحرفية العشرية (decimal literals).
<syntaxhighlight lang="typescript">
let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;
</syntaxhighlight>
==السلاسل النصية (string)==
العمل مع البيانات النصية من الأجزاء الأساسية في برامج JavaScript كذلك. وكما في اللغات الأخرى، فلغة TypeScript تعتمد على النوع ‎<code>string</code>‎ للإشارة إلى أنواع البيانات النصية هذه. وكما في JavaScript، فلغة TypeScript تعتمد كذلك على علامات التنصيص المزدوجة (<code>"</code>‎) أو المفردة ‎(<code>'</code>) لإحاطة بيانات السلسلة النصية.
<syntaxhighlight lang="typescript">
let color: string = "blue";
color = 'red';
</syntaxhighlight>
يُمكنك كذلك استعمال سلاسل القوالب النصيّة (template strings)، والتي يُمكن لها تخزين عدّة أسطر والاحتواء على تعابير مُضمّنة. هذه السلاسل النصية مُحاطة بالمحرف (‎<code>`</code>‎)، ويُمكن تضمين التعابير فيها على شكل ‎<code>‎${ expr }‎</code>‎.

<syntaxhighlight lang="typescript">
let fullName: string = `Bob Bobbington`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ fullName }.

I'll be ${ age + 1 } years old next month.`;
</syntaxhighlight>
هذا مُكافئ للتصريح عن المتغيّر ‎<code>sentence</code>‎ كما يلي:
<syntaxhighlight lang="typescript">
let sentence: string = "Hello, my name is " + fullName + ".\n\n" +
    "I'll be " + (age + 1) + " years old next month.";
</syntaxhighlight>

== المصفوفات (Array) ==
تسمح TypeScript بالعمل مع مصفوفات من القيم كما في JavaScript. يُمكن كتابة أنواع المصفوفات بطريقتين. إما عبر استعمال نوع عناصر المصفوفة متبوعًا بالقوسين ‎<code>[]</code>‎ لتعريف مصفوفةٍ بنوع العناصر المُعطى، في المثال التالي نُعرّف مصفوفة أعداد باستخدام النوع ‎‎‎<code>number</code>:
<syntaxhighlight lang="typescript">
let list: number[] = [1, 2, 3];
</syntaxhighlight>
الطريقة الأخرى هي باستخدام نوع مصفوفة عمومي (generic array type) على الشكل ‎<code>‎Array‎<elemType>‎</code>‎ مع استبدال <code>elemType‎</code> بالنوع المرغوب:
<syntaxhighlight lang="typescript">
let list: Array<number> = [1, 2, 3];
</syntaxhighlight>
==الصفوف (Tuple)==
تسمح الصفوف بالتعبير عن مصفوفة يكون فيها عدد أنواع العناصر معروفًا، دون أن تكون ذات نفس النوع. على سبيل المثال، قد ترغب بتمثيل قيمة كزوج سلسلة نصيّة ‎<code>string</code>‎ وعدد ‎<code>number</code>‎:

<syntaxhighlight lang="typescript">
// تعريف نوع صفّ
let x: [string, number];
// تخزين البيانات في الصف
x = ["hello", 10]; // عبارة صحيحة
// تخزين البيانات في الصف بطريقة خاطئة
x = [10, "hello"]; // خطأ
</syntaxhighlight>
عند الوصول إلى عنصر يكون فهرسه (index) معروفًا، فسيُجلب النوع المناسب:
<syntaxhighlight lang="typescript">
console.log(x[0].substr(1)); // OK
console.log(x[1].substr(1)); // خطأ لأن العدد لا يملك هذا التابع / 'number' does not have 'substr'
</syntaxhighlight>
عند الوصول إلى عنصر خارج مجموعة الفهارس المعروفة، فسيُستعمل نوع اتحاد (union type) عوضًا عن ذلك:
<syntaxhighlight lang="typescript">
// يُمكن تعيين سلسلة نصية لأنها عنصر من المجموعة (سلسلة نصية أو عدد)
x[3] = "world"; // OK, 'string' can be assigned to 'string | number'

// التابع موجود في كلا النوعين
console.log(x[5].toString()); // OK, 'string' and 'number' both have 'toString'

// (سلسلة نصية أو عدد) خطأ، القيمة المنطقية ليست من المجموعة
x[6] = true; // Error, 'boolean' isn't 'string | number'
</syntaxhighlight>
أنواع الاتحاد من المواضيع المتقدمة التي سنتطرق إليها في فصل آخر.
==الثوابت المتعددة (enum)==
النوع ‎<code>enum</code>‎ من أنواع البيانات المفيدة المُضافة على الأنواع القياسية الموجودة في JavaScript. ويمثل هذا النوعُ نوعَ الثوابت المتعددة الذي يعمل بطريقة مشابهة لما في لغات أخرى مثل C#‎، وهو نوع يسمح بتسمية مجموعات القيم العددية (sets of numeric values) بتسميات واضحة.
<syntaxhighlight lang="typescript">
enum Color {Red, Green, Blue}
let c: Color = Color.Green;
</syntaxhighlight>
افتراضيًا، يبدأ عدّ عناصر الثوابت المتعددة من ‎<code>0</code>‎. يُمكنك تغيير ذلك عبر ضبط قيمة أحد العناصر. على سبيل المثال، يُمكننا أن نبدأ المثال السابق من العدد ‎<code>1</code>‎ عوضًا عن ‎<code>0</code>‎:
<syntaxhighlight lang="typescript">
enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;
</syntaxhighlight>
أو يُمكن ضبط جميع قيم الثوابت المتعددة يدويا:
<syntaxhighlight lang="typescript">
enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;
</syntaxhighlight>
توفّر الثوابت المتعددة ميّزة تُمكنك من الوصول إلى اسم القيمة من قيمتها العددية. مثلًا، إن كانت لدينا القيمة ‎<code>2</code>‎ ولم نعرف بماذا هي مُرتبطة في الثابتة المتعددة ‎<code>Color</code>‎ أعلاه، فيُمكننا البحث عن اسم القيمة كما يلي:
<syntaxhighlight lang="typescript">
enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];

alert(colorName); // 'Green'
</syntaxhighlight>
لاحظ أن الاسم الذي يُعرض هو <code>Green</code>، وذلك لأن قيمته هي ‎<code>2</code>‎ في  الثابتة المتعددة ‎<code>Color</code>‎ أعلاه.
==النوع Any==
قد نحتاج إلى وصف نوع مُتغيّرات نَجهَلُ نوعها عند كتابة التطبيق. يُمكن لهذه القيم أن تأتي من محتوى ديناميكي، كمُستخدم أو مكتبة طرف ثالث (3rd party library). في هذه الحالات،  نُريد أن نُلغي التحقق من الأنواع ونسمح للقيم بالمرور عبر نقاط التفتيش في زمن الترجمة (compile-time checks). للقيام بذلك، نستعمل النوع ‎<code>any</code>‎ لوصف هذه المتغيّرات:
<syntaxhighlight lang="typescript">
let notSure: any = 4;
notSure = "ربما القيمةُ سلسلة نصيّةٌ وليست عددًا";
notSure = false; // بل هي قيمة منطقية
</syntaxhighlight>
يُعدّ النوع ‎<code>any</code>‎ طريقة فعّالة للعمل مع شيفرات JavaScript الموجودة مُسبقًا، ما يسمح لك بالتدرج في استخدام التحقق من الأنواع عند الترجمة. قد تتوقّع للنوع ‎<code>Object</code>‎ أن يعمل بشكل مُشابه كما في لغات البرمجة الأخرى. لكن المتغيرات من النوع  <code>Object</code> تسمح فقط بتعيين أي نوع من القيم لها، ولا يُمكنك استدعاء توابع اعتباطية (arbitrary methods) عليها، حتى ولو كانت هذه التوابع موجودة بالفعل:
<syntaxhighlight lang="typescript">
let notSure: any = 4;
// يُمكن للتابع
// ifItExists
// أن يكون موجودًا عند زمن التشغيل
// (runtime)
notSure.ifItExists();
notSure.toFixed(); // التابع موجود، لكن المُترجم لا يتحقق من ذلك

let prettySure: Object = 4;
// خطأ التابع ليس موجودًا
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.
</syntaxhighlight>

النّوع ‎<code>any</code>‎ مُفيد كذلك عندما تعرف جزءًا من نوع المتغيّر، لكن ليس بشكل كامل. مثلًا، يُمكن أن تمتلك مصفوفةً أنواع عناصرها مُختلفة كما يلي:
<syntaxhighlight lang="typescript">
let list: any[] = [1, true, "free"];

list[1] = 100;
</syntaxhighlight>

==النوع Void==
النوع ‎<code>void</code>‎ هو المقابل للنوع ‎<code>any</code>‎ نوعًا ما، ويشير إلى غياب النوع. وستراه عادةً كنوعٍ للقيمة المُعادة (return type) للدوال التي لا تُعيد أية قيمة:
<syntaxhighlight lang="typescript">
function warnUser(): void {
    alert("This is my warning message");
}
</syntaxhighlight>
تصريح مُتغيّر بالنوع ‎<code>void</code>‎ غير مُفيد لأن المتغير لن يقبل سوى تعيين القيمة ‎<code>undefined</code>‎ أو القيمة ‎<code>null</code>‎ له.
<syntaxhighlight lang="typescript">
// هذا المتغير لا قيمة له
let unusable: void = undefined;
</syntaxhighlight>
==النوعان Null وUndefined==
في لغة TypeScript، يكون للقيمتان ‎<code>undefined</code>‎ و‎<code>null</code>‎ نوعان خاصان بهما يُسميان بنفس الاسم ‎<code>undefined</code>‎ و‎<code>null</code>‎. وكما الحال مع النوع ‎<code>void</code>‎، فهما نوعان غير مفيدان كثيرًا عندما يكونان مُنفردين:
<syntaxhighlight lang="typescript">
// لا يُمكننا تعيين أية قيمة مُغايرة للمتغيرين التاليين
let u: undefined = undefined;
let n: null = null;
</syntaxhighlight>
افتراضيا، يُعتبر النوعان ‎<code>undefined</code>‎ و‎<code>null</code>‎ أنواعًا فرعيّة لجميع الأنواع الأخرى. ما يعني بأنك تستطيع تعيين ‎<code>undefined</code>‎ و‎<code>null</code>‎ للنوع <code>number</code> على سبيل المثال.

لكن عند استخدام الراية (flag) ‎<code>‎‎--‎strictNullChecks‎</code>‎ مع المُترجم (compiler)، ستتمكن من تعيين ‎<code>undefined</code>‎ و‎<code>null</code>‎ للنوع <code>void</code> فقط إضافةً إلى نوعيهما المناسبين. ويُساعد هذا على تجنّب الكثير من الأخطاء الشائعة. وفي حالة أردت تمرير قيمة من النوع <code>string</code> أو النوع ‎<code>undefined</code>‎ أو النوع ‎<code>null</code>‎، فيُمكنك استخدام نوع الاتّحاد (union type) <code>string | null | undefined</code>. وللمزيد عن أنواع الاتّحاد، انظر صفحة الأنواع المتقدمة.

'''مُلاحظة:''' من المستحسن استخدام الخيار ‎<code>‎‎--‎strictNullChecks‎</code>‎ كلما أمكن ذلك، لكنّ هذا التوثيق يعتبر الخيار مُعطّلًا عندك.
==النوع Never==
يُمثّل النوع ‎<code>never</code>‎ نوع القيم التي لا تظهر أبدًا. مثلًا، تُعاد قيمة من النوع <code>never</code> من طرف تعبير دالة أو تعبير دالة سهميّة (arrow function expression) التي تُطلق دائمًا استثناءًا (exception) أو دالّة لا تُعيد أيّ شيء أبدًا؛ وقد تحمل المتغيراتُ النوعَ <code>never</code> عندما يُحدّ بأي حارس أنواع (type guard) لا يُمكن له أن يكون ذا قيمة منطقية صحيحة أبدًا.

النوع <code>never</code> نوع فرعي لجميع الأنواع ويُمكن تعيينه لجميع الأنواع كذلك؛ لكن لا يوجد نوع فرعي له، ولا يُمكن تعيين أي نوعٍ للنوع <code>never</code> (إلا هو ذاته). وحتى النوع <code>any</code> غير قابل لتعيينه للنوع <code>never</code>.

بعض الأمثلة على دوال تُعيد النوع <code>never</code>:
<syntaxhighlight lang="typescript">
// الدالة التي تُعيد النوع لا تكون ذات نقطة نهاية يُمكن الوصول إليها
// Function returning never must have unreachable end point
function error(message: string): never {
    throw new Error(message);
}

// لأن الدالة تستدعي دالةً ترمي استثناءً، ومن ذلك يُستنتج النوع
// Inferred return type is never
function fail() {
    return error("Something failed");
}

// دالة تعمل لا نهائيًّا ولا تُعيد أي شيء أبدًا
function infiniteLoop(): never {
    while (true) {
    }
}
</syntaxhighlight>
== النوع Object ==
يُمثّل النوع ‎<code>object</code>‎ الأنواع غير الأوليّة (non-primitive). أي كلّ نوعٍ مُغايرٍ لأحد الأنواع التالية: ‎<code>number</code>‎، و ‎<code>string</code>‎، و ‎<code>boolean</code>‎، و ‎<code>symbol</code>‎، و ‎<code>null</code>‎، و ‎<code>undefined</code>‎.

يُوفّر النوع <code>object</code> طريقةً جيدةً لتمثيل واجهات برمجيّة (APIs) مثل <code>Object.create</code>. على سبيل المثال:
<syntaxhighlight lang="typescript">
declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error
</syntaxhighlight>
== إثباتات الأنواع (Type assertions)==
قد تقع أحيانًا في حالة تعرف فيها معلومات عن قيمة ما أكثر من معرفة TypeScript بها. هذا يحدث عادةً عندما تعلم أن نوع كائن يُمكن أن يكون أكثر تحديدًا من نوعه الحالي.

إثباتات الأنواع طريقة لإخبار المُترجم (compiler) بأنّك تعرف ما تفعله وأنّك أدرى بنوع الكائن منه. وإثبات النوع شبيه بجبائر الأنواع (type cast) في لغات البرمجة الأخرى، لكنه لا يقوم بأي تحقّق خاصّ أو إعادة هيكلة للبيانات. ولا تأثير له في زمن التشغيل (no runtime impact)، ويُستعمل من طرف المُترجم فقط. ولغة TypeScript تعتبر أنّكَ -بصفتك المُبرمج- قد تحقّقت من البيانات كما يجب.

لإثباتات الأنواع شكلان. الشكل الأول يكون باستعمال أقواس الزاوية (angle-bracket):

<syntaxhighlight lang="typescript">
let someValue: any = "this is a string";

let strLength: number = (<string>someValue).length;
</syntaxhighlight>
والشكل الآخر يكون باستعمال الكلمة المفتاحية ‎<code>as</code>‎:
<syntaxhighlight lang="typescript">
let someValue: any = "this is a string";

let strLength: number = (someValue as string).length;
</syntaxhighlight>
المثالان أعلاه مُتكافئان. واستعمال شكل دون آخر مجرّد اختيار يختاره المبرمج؛ لكن عند استخدام JSX مع TypeScript، فطريقة الكلمة المفتاحية <code>as</code> هي المسموح بها فقط.

==ملاحظة حول الكلمة المفتاحية let==
قد تُلاحظ بأنّنا نستخدم الكلمة المفتاحيّة ‎<code>let</code>‎ عوضًا عن الكلمة المفتاحيّة ‎<code>var</code>‎ المعروفة في لغة JavaScript. الكلمة المفتاحيّة <code>let</code> من مزايا لغة JavaScript الجديدة، والتي تُتيحها لغة TypeScript. يُمكن حل العديد من مشاكل  JavaScript عبر استخدام الكلمة المفتاحيّة <code>let</code>، لذا من المستحسن استعمالها عوضًا عن <code>var</code> متى أمكن ذلك.
== مصادر ==
* [https://www.typescriptlang.org/docs/handbook/basic-types.html صفحة Basic Types في توثيق TypeScript الرسمي.]
[[تصنيف:TypeScript]]