الأنواع الأساسية في TypeScript

let firstName: string = "John";
let lastName: string = 'Doe';
let fullName: string = `${firstName} ${lastName}`;

// استنتاج النوع - يمكن لـ TypeScript استنتاج النوع
let city = "New York";  // النوع يُستنتج كـ string

// أمثلة على الأخطاء
let age: string = 25;  // Error: Type 'number' is not assignable to type 'string'

let age: number = 30;
let price: number = 99.99;
let hex: number = 0xf00d;       // سداسي عشري
let binary: number = 0b1010;    // ثنائي
let octal: number = 0o744;      // ثماني

// قيم رقمية خاصة
let notANumber: number = NaN;
let infinite: number = Infinity;
let negInfinite: number = -Infinity;

// فواصل رقمية للقراءة (ES2020+)
let million: number = 1_000_000;
let billion: number = 1_000_000_000;

let isActive: boolean = true;
let hasPermission: boolean = false;

// تعبيرات منطقية
let isAdult: boolean = age >= 18;
let canVote: boolean = isAdult && hasPermission;

// مثال على خطأ
let isValid: boolean = "true";  // Error: Type 'string' is not assignable to type 'boolean'

let data: any = "hello";
data = 42;              // OK
data = true;            // OK
data = { x: 10 };       // OK

// يمكن استدعاء أي أسلوب دون فحص النوع
data.toUpperCase();     // لا خطأ، حتى لو لم يكن data سلسلة نصية
data.nonExistent();     // لا خطأ في وقت التجميع

// any معدٍ - العمليات مع any تُرجع any
let result = data + 5;  // result هو أيضاً نوع any

let userInput: unknown = getUserInput();

// لا يمكن استخدام قيم unknown دون فحص النوع
userInput.toUpperCase();  // Error: Object is of type 'unknown'

// يجب فحص النوع أولاً
if (typeof userInput === "string") {
    console.log(userInput.toUpperCase());  // OK - يعرف TypeScript أنها سلسلة نصية
}

// تأكيدات النوع (استخدم بحذر)
let strInput = userInput as string;

// أفضل: دالة حارس النوع
function isString(value: unknown): value is string {
    return typeof value === "string";
}

if (isString(userInput)) {
    console.log(userInput.toUpperCase());  // OK
}

function logMessage(message: string): void {
    console.log(message);
    // لا عبارة إرجاع
}

function saveData(data: any): void {
    localStorage.setItem("data", JSON.stringify(data));
    return;  // OK - يمكن الإرجاع بدون قيمة
}

// نادراً ما يُستخدم للمتغيرات
let unusable: void = undefined;  // OK
let alsoUnusable: void = null;   // OK فقط مع إيقاف --strictNullChecks

let nothing: null = null;
let notDefined: undefined = undefined;

// مع strictNullChecks: false (غير موصى به)
let name: string = null;       // OK
let age: number = undefined;   // OK

// مع strictNullChecks: true (موصى به)
let name: string = null;       // Error
let age: number = undefined;   // Error

// السماح صراحةً بـ null/undefined
let name: string | null = null;              // OK
let age: number | undefined = undefined;     // OK
let data: string | null | undefined = null;  // OK

// دالة ترمي خطأ
function throwError(message: string): never {
    throw new Error(message);
}

// دالة مع حلقة لا نهائية
function infiniteLoop(): never {
    while (true) {
        // هذا لا ينتهي أبداً
    }
}

// never هو نوع الإرجاع للدوال التي لا يمكنها الاكتمال
function fail(msg: string): never {
    throw new Error(msg);
}

// never مفيد في فحص النوع الشامل
type Shape = "circle" | "square";

function getArea(shape: Shape): number {
    switch (shape) {
        case "circle":
            return Math.PI * 10 * 10;
        case "square":
            return 10 * 10;
        default:
            // إذا أضفنا شكلاً جديداً ونسينا معالجته،
            // سيخطئ TypeScript هنا
            const exhaustiveCheck: never = shape;
            return exhaustiveCheck;
    }
}

// استنتاج النوع يعمل بشكل جيد
let name = "John";           // يُستنتج كـ string
let age = 30;                // يُستنتج كـ number
let isActive = true;         // يُستنتج كـ boolean

// عندما لا يعمل الاستنتاج أو ليس واضحاً
let numbers;                 // يُستنتج كـ any - سيء
let numbers: number[];       // مكتوب صراحةً - جيد

// معلمات الدالة تحتاج دائماً إلى أنواع
function greet(name: string) {  // يجب كتابة المعلمة
    return `Hello, ${name}`;    // نوع الإرجاع يُستنتج كـ string
}

// أحياناً أنواع الإرجاع الصريحة تحسّن القراءة
function add(a: number, b: number): number {
    return a + b;
}

// توسيع النوع
let x = "hello";     // النوع هو 'string'، وليس الحرفي "hello"
const y = "hello";   // النوع هو الحرفي "hello" (const لا يمكن إعادة تعيينه)

// تضييق النوع مع حراس النوع
function processValue(value: string | number) {
    // value هو string | number هنا

    if (typeof value === "string") {
        // value مُضيّق إلى string هنا
        console.log(value.toUpperCase());
    } else {
        // value مُضيّق إلى number هنا
        console.log(value.toFixed(2));
    }
}

// تضييق الصدق
function printLength(str: string | null) {
    if (str) {
        // str مُضيّق إلى string (ليس null)
        console.log(str.length);
    } else {
        console.log("No string provided");
    }
}

// بناء جملة القوس الزاوي (غير قابل للاستخدام في ملفات JSX/TSX)
let someValue: unknown = "this is a string";
let strLength: number = (<string>someValue).length;

// بناء جملة as (مفضل، يعمل في كل مكان)
let someValue: unknown = "this is a string";
let strLength: number = (someValue as string).length;

// مثال من العالم الحقيقي: معالجة DOM
const canvas = document.getElementById("myCanvas");  // Type: HTMLElement | null
const ctx = (canvas as HTMLCanvasElement).getContext("2d");

// تأكيد مزدوج (تجنب ما لم يكن ضرورياً للغاية)
const value = "hello" as any as number;  // سيء - يبطل سلامة النوع

// حرفيات سلسلة نصية
let direction: "up" | "down" | "left" | "right";
direction = "up";      // OK
direction = "north";   // Error

// حرفيات رقمية
let diceRoll: 1 | 2 | 3 | 4 | 5 | 6;
diceRoll = 3;   // OK
diceRoll = 7;   // Error

// حرفيات منطقية (أقل شيوعاً)
let isTrue: true = true;
let isFalse: false = false;

// الجمع مع أنواع الاتحاد
type Status = "success" | "error" | "pending";
type Level = 1 | 2 | 3 | 4 | 5;

function setStatus(status: Status): void {
    console.log(`Status: ${status}`);
}

setStatus("success");  // OK
setStatus("failed");   // Error

// اسم نوع مستعار أساسي
type UserID = string | number;

let id1: UserID = "abc123";
let id2: UserID = 456;

// اسم نوع مستعار معقد
type Point = {
    x: number;
    y: number;
};

let point: Point = { x: 10, y: 20 };

// اسم نوع دالة مستعار
type MathOperation = (a: number, b: number) => number;

const add: MathOperation = (a, b) => a + b;
const subtract: MathOperation = (a, b) => a - b;

// اسم نوع اتحاد مستعار
type StringOrNumber = string | number;
type SuccessResponse = { success: true; data: any };
type ErrorResponse = { success: false; error: string };
type ApiResponse = SuccessResponse | ErrorResponse;