المصفوفات والصفوف في TypeScript

// الطريقة 1: النوع متبوعاً بـ []
let numbers: number[] = [1, 2, 3, 4, 5];
let names: string[] = ["Alice", "Bob", "Charlie"];
let flags: boolean[] = [true, false, true];

// الطريقة 2: نوع Array العام
let numbers: Array<number> = [1, 2, 3, 4, 5];
let names: Array<string> = ["Alice", "Bob", "Charlie"];
let flags: Array<boolean> = [true, false, true];

// يستنتج TypeScript هذه كمصفوفات مكتوبة
let numbers = [1, 2, 3];           // يُستنتج كـ number[]
let names = ["Alice", "Bob"];      // يُستنتج كـ string[]
let mixed = [1, "two", true];      // يُستنتج كـ (string | number | boolean)[]

// المصفوفات الفارغة تُعتبر افتراضياً any[]
let empty = [];                    // يُستنتج كـ any[]
empty.push(1);                     // OK
empty.push("hello");               // OK - ليس مثالياً!

// أفضل: اكتب المصفوفات الفارغة صراحةً
let numbers: number[] = [];        // مكتوب كـ number[]
numbers.push(1);                   // OK
numbers.push("hello");             // Error!

let numbers: number[] = [1, 2, 3];

// إضافة عناصر
numbers.push(4);           // OK
numbers.push("5");         // Error: Argument of type 'string' is not assignable to parameter of type 'number'

// الوصول إلى العناصر
let first = numbers[0];    // Type: number
let last = numbers[numbers.length - 1];  // Type: number

// أساليب المصفوفة تحافظ على سلامة النوع
let doubled = numbers.map(n => n * 2);        // Type: number[]
let strings = numbers.map(n => n.toString()); // Type: string[]
let evens = numbers.filter(n => n % 2 === 0); // Type: number[]

// التقليص
let sum = numbers.reduce((acc, n) => acc + n, 0);  // Type: number

// مصفوفة ثنائية الأبعاد (مصفوفة)
let matrix: number[][] = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

// الوصول إلى العناصر
let element = matrix[0][1];  // 2

// مصفوفة ثلاثية الأبعاد
let cube: number[][][] = [
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]]
];

// مصفوفة من الكائنات
interface User {
    name: string;
    age: number;
}

let users: User[] = [
    { name: "Alice", age: 30 },
    { name: "Bob", age: 25 }
];

// مصفوفة للقراءة فقط باستخدام نوع ReadonlyArray
let numbers: ReadonlyArray<number> = [1, 2, 3];

numbers[0] = 10;           // Error: Index signature in type 'readonly number[]' only permits reading
numbers.push(4);           // Error: Property 'push' does not exist on type 'readonly number[]'
numbers.pop();             // Error: Property 'pop' does not exist on type 'readonly number[]'

// مصفوفة للقراءة فقط باستخدام معدِّل readonly (مفضل)
let names: readonly string[] = ["Alice", "Bob"];

names[0] = "Charlie";      // Error
names.push("David");       // Error

// لا يزال بإمكانك القراءة من المصفوفات للقراءة فقط
console.log(numbers[0]);   // OK
console.log(numbers.length);  // OK
let copy = [...numbers];   // OK - ينشئ نسخة قابلة للتغيير

// دالة لا تعدل المصفوفة
function sum(numbers: readonly number[]): number {
    // numbers.push(0);  // Error - لا يمكن تعديل المصفوفة للقراءة فقط
    return numbers.reduce((acc, n) => acc + n, 0);
}

// يمكن استدعاؤها بكل من المصفوفات القابلة للتغيير وللقراءة فقط
let mutable = [1, 2, 3];
let immutable: readonly number[] = [4, 5, 6];

console.log(sum(mutable));    // OK
console.log(sum(immutable));  // OK

// صف بعنصرين
let person: [string, number] = ["Alice", 30];

// الوصول إلى عناصر الصف
let name = person[0];     // Type: string
let age = person[1];      // Type: number

// خطأ: أنواع خاطئة
let invalid: [string, number] = [30, "Alice"];  // Error: Type 'number' is not assignable to type 'string'

// خطأ: طول خاطئ
let tooShort: [string, number] = ["Alice"];     // Error: Type '[string]' is not assignable to type '[string, number]'
let tooLong: [string, number] = ["Alice", 30, "extra"];  // Error

// إحداثيات
type Point = [number, number];
let origin: Point = [0, 0];
let point: Point = [10, 20];

// لون RGB
type RGB = [number, number, number];
let red: RGB = [255, 0, 0];
let blue: RGB = [0, 0, 255];

// استجابة HTTP
type Response = [number, string];
let success: Response = [200, "OK"];
let notFound: Response = [404, "Not Found"];

// سجل قاعدة بيانات
type User = [number, string, string, boolean];  // [id, name, email, isActive]
let user: User = [1, "Alice", "alice@example.com", true];

// صف مع عنصر اختياري
type User = [string, number, string?];  // name, age, email (اختياري)

let user1: User = ["Alice", 30, "alice@example.com"];  // OK
let user2: User = ["Bob", 25];                         // OK - البريد الإلكتروني اختياري
let user3: User = ["Charlie"];                         // Error - العمر مطلوب

// يجب أن تأتي العناصر الاختيارية بعد المطلوبة
type Invalid = [string?, number];  // Error: A required element cannot follow an optional element

// صف مع عنصر راحة
type StringNumberBooleans = [string, number, ...boolean[]];

let valid1: StringNumberBooleans = ["hello", 42];
let valid2: StringNumberBooleans = ["hello", 42, true];
let valid3: StringNumberBooleans = ["hello", 42, true, false, true];

// يمكن أن يكون عنصر الراحة في المنتصف
type Numbers = [number, ...number[], number];
let nums: Numbers = [1, 2, 3, 4, 5];  // الأول والأخير يجب أن يكونا أرقاماً

// أنواع متعددة في الراحة
type Mixed = [string, ...(number | boolean)[]];
let mixed: Mixed = ["start", 1, true, 2, false];

// بدون تسميات
type Point = [number, number];

// مع التسميات (أكثر وصفاً)
type Point = [x: number, y: number];

// مثال معقد
type User = [
    id: number,
    name: string,
    email: string,
    isActive: boolean
];

let user: User = [1, "Alice", "alice@example.com", true];

// التسميات لا تغير سلوك وقت التشغيل، فقط تحسّن القراءة
// لا تزال تصل عن طريق الفهرس
console.log(user[0]);  // 1
console.log(user[1]);  // "Alice"

// صف للقراءة فقط
let point: readonly [number, number] = [10, 20];

point[0] = 5;  // Error: Cannot assign to '0' because it is a read-only property

// للقراءة فقط مع التسميات
type Point = readonly [x: number, y: number];
let origin: Point = [0, 0];
// origin[0] = 1;  // Error

// دالة تقبل صفاً للقراءة فقط
function distance(point: readonly [number, number]): number {
    return Math.sqrt(point[0] ** 2 + point[1] ** 2);
}

// تفكيك المصفوفة
let numbers = [1, 2, 3, 4, 5];
let [first, second, ...rest] = numbers;
// first: number, second: number, rest: number[]

// تفكيك الصف
type Point = [number, number];
let point: Point = [10, 20];
let [x, y] = point;
// x: number, y: number

// تفكيك الصف المسمى
type User = [id: number, name: string, email: string];
let user: User = [1, "Alice", "alice@example.com"];
let [id, name, email] = user;
// id: number, name: string, email: string

// تخطي العناصر
let [, , third] = numbers;  // third: number

// القيم الافتراضية
let [a, b, c = 0] = [1, 2];
// a: number, b: number, c: number (افتراضياً 0)

// نشر المصفوفات
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let combined = [...arr1, ...arr2];  // Type: number[]

// نشر الصفوف
type Point2D = [number, number];
type Point3D = [number, number, number];

let point2D: Point2D = [10, 20];
let point3D: Point3D = [...point2D, 30];  // OK

// خلط الأنواع
let mixed = [...arr1, "hello", ...arr2];  // Type: (string | number)[]

// الانتشار في استدعاءات الدوال
function sum(a: number, b: number, c: number): number {
    return a + b + c;
}

let numbers: [number, number, number] = [1, 2, 3];
sum(...numbers);  // OK - انتشار الصف يطابق عدد المعلمات

// استخدام الصف لإرجاع قيم متعددة
function getMinMax(numbers: number[]): [number, number] {
    let min = Math.min(...numbers);
    let max = Math.max(...numbers);
    return [min, max];
}

let [min, max] = getMinMax([5, 2, 8, 1, 9]);
console.log(`Min: ${min}, Max: ${max}`);

// مشابه لـ useState في React
type State<T> = [T, (newValue: T) => void];

function useState<T>(initialValue: T): State<T> {
    let value = initialValue;

    function setValue(newValue: T) {
        value = newValue;
    }

    return [value, setValue];
}

let [count, setCount] = useState(0);
setCount(5);  // OK
// setCount("5");  // Error: Argument of type 'string' is not assignable to parameter of type 'number'

// صف قاعدة بيانات مكتوب
type UserRow = [
    id: number,
    username: string,
    email: string,
    createdAt: Date,
    isActive: boolean
];

function getUserById(id: number): UserRow | null {
    // استعلام قاعدة بيانات محاكى
    return [1, "alice", "alice@example.com", new Date(), true];
}

let user = getUserById(1);
if (user) {
    let [id, username, email, createdAt, isActive] = user;
    console.log(`${username} (${email})`);
}