أنواع الأدوات المساعدة

<interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

// جميع الخصائص تصبح اختيارية
type PartialUser = Partial<User>;

const updateUser = (id: number, updates: Partial<User>) => {
  // يمكن تحديث خصائص محددة فقط
  console.log(`Updating user ${id}`, updates);
};

// استدعاءات صحيحة
updateUser(1, { name: 'John' });
updateUser(2, { email: 'jane@example.com', age: 30 });
updateUser(3, {}); // أيضًا صحيح
>

<interface UserProfile {
  username: string;
  bio?: string;
  avatar?: string;
  website?: string;
}

type CompleteProfile = Required<UserProfile>;

// خطأ: خصائص إلزامية مفقودة
const profile1: CompleteProfile = {
  username: 'johndoe'
  // خطأ: bio و avatar و website إلزامية
};

// صحيح
const profile2: CompleteProfile = {
  username: 'johndoe',
  bio: 'Developer',
  avatar: 'avatar.jpg',
  website: 'https://example.com'
};
>

<interface Config {
  apiUrl: string;
  timeout: number;
  retries: number;
}

const config: Readonly<Config> = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3
};

// خطأ: لا يمكن التعيين إلى 'apiUrl' لأنها خاصية للقراءة فقط
config.apiUrl = 'https://new-api.example.com';

// للقراءة فقط المتداخلة، استخدم نهجًا تكراريًا
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object
    ? DeepReadonly<T[P]>
    : T[P];
};
>

<type UserRole = 'admin' | 'editor' | 'viewer';

interface Permission {
  read: boolean;
  write: boolean;
  delete: boolean;
}

// إنشاء كائن بالأدوار كمفاتيح والأذونات كقيم
const rolePermissions: Record<UserRole, Permission> = {
  admin: { read: true, write: true, delete: true },
  editor: { read: true, write: true, delete: false },
  viewer: { read: true, write: false, delete: false }
};

// مثال آخر: إنشاء قاموس
type PageTitle = Record<string, string>;

const pageTitles: PageTitle = {
  home: 'الصفحة الرئيسية',
  about: 'من نحن',
  contact: 'اتصل بنا'
};
>

<interface Product {
  id: number;
  name: string;
  description: string;
  price: number;
  stock: number;
  category: string;
  createdAt: Date;
}

// اختر الخصائص المطلوبة للعرض فقط
type ProductPreview = Pick<Product, 'id' | 'name' | 'price'>;

const preview: ProductPreview = {
  id: 1,
  name: 'لابتوب',
  price: 999.99
  // الخصائص الأخرى غير مسموح بها
};

// مفيد لاستجابات API
type ProductListItem = Pick<Product, 'id' | 'name' | 'price' | 'stock'>;
>

<interface User {
  id: number;
  username: string;
  password: string;
  email: string;
  createdAt: Date;
}

// حذف البيانات الحساسة لاستجابات API
type PublicUser = Omit<User, 'password'>;

const publicUser: PublicUser = {
  id: 1,
  username: 'johndoe',
  email: 'john@example.com',
  createdAt: new Date()
  // كلمة المرور غير مضمنة
};

// حذف خصائص متعددة
type UserCreateDTO = Omit<User, 'id' | 'createdAt'>;

const newUser: UserCreateDTO = {
  username: 'janedoe',
  password: 'securepass123',
  email: 'jane@example.com'
};
>

<type AllStatus = 'pending' | 'approved' | 'rejected' | 'cancelled';

// استبعاد حالة الإلغاء
type ActiveStatus = Exclude<AllStatus, 'cancelled'>;
// النتيجة: 'pending' | 'approved' | 'rejected'

// استبعاد قيم متعددة
type PositiveStatus = Exclude<AllStatus, 'rejected' | 'cancelled'>;
// النتيجة: 'pending' | 'approved'

// يعمل مع الأنواع أيضًا
type Primitive = string | number | boolean | null | undefined;
type NonNullishPrimitive = Exclude<Primitive, null | undefined>;
// النتيجة: string | number | boolean
>

<type MixedType = string | number | boolean | null;

// استخرج string و number فقط
type StringOrNumber = Extract<MixedType, string | number>;
// النتيجة: string | number

// استخراج قيم محددة
type Status = 'success' | 'error' | 'pending' | 'idle';
type CompletedStatus = Extract<Status, 'success' | 'error'>;
// النتيجة: 'success' | 'error'

// مثال عملي
type EventType = 'click' | 'scroll' | 'keydown' | 'keyup';
type KeyboardEvent = Extract<EventType, `key${string}`>;
// النتيجة: 'keydown' | 'keyup'
>

<type MaybeString = string | null | undefined;

// إزالة null و undefined
type DefiniteString = NonNullable<MaybeString>;
// النتيجة: string

// مثال عملي
interface User {
  id: number;
  name: string;
  email: string | null;
}

const getEmail = (user: User): NonNullable<User['email']> => {
  if (user.email === null) {
    throw new Error('البريد الإلكتروني مطلوب');
  }
  return user.email; // TypeScript يعرف أن هذا string
};

// مع إرجاع الدالة
type FunctionReturn = string | number | null | undefined;
type ValidReturn = NonNullable<FunctionReturn>;
// النتيجة: string | number
>

<function createUser(name: string, email: string) {
  return {
    id: Math.random(),
    name,
    email,
    createdAt: new Date()
  };
}

// استخراج نوع الإرجاع
type User = ReturnType<typeof createUser>;
// النتيجة: { id: number; name: string; email: string; createdAt: Date; }

// مع الدوال غير المتزامنة
async function fetchData() {
  return {
    data: [1, 2, 3],
    status: 'success' as const
  };
}

type FetchResult = ReturnType<typeof fetchData>;
// النتيجة: Promise<{ data: number[]; status: 'success'; }>

// فك Promise مع Awaited
type UnwrappedResult = Awaited<ReturnType<typeof fetchData>>;
// النتيجة: { data: number[]; status: 'success'; }
>

<interface Article {
  id: number;
  title: string;
  content: string;
  author: string;
  publishedAt: Date;
  updatedAt: Date;
  tags: string[];
}

// إنشاء نوع لتحديثات المقالات (حقول اختيارية، بدون id)
type ArticleUpdate = Partial<Omit<Article, 'id' | 'publishedAt'>>;

// إنشاء نسخة للقراءة فقط من حقول محددة
type ArticleDisplay = Readonly<Pick<Article, 'title' | 'content' | 'author'>>;

// إنشاء نوع لإنشاء المقالات (بدون id أو طوابع زمنية)
type ArticleCreate = Omit<Article, 'id' | 'publishedAt' | 'updatedAt'>;

// إنشاء نسخة مطلوبة من نوع جزئي
type RequiredUpdate = Required<Partial<Article>>;
// نفس Article، لكن يوضح المفهوم
>

<// جعل خصائص محددة اختيارية
type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type ProductWithOptionalDescription = PartialBy<Product, 'description'>;

// جعل خصائص محددة إلزامية
type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;

// أداة Nullable
type Nullable<T> = { [K in keyof T]: T[K] | null };

// جزئي عميق
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
>

<// تعريف الكيان الأساسي
interface BaseEntity {
  id: number;
  createdAt: Date;
  updatedAt: Date;
}

interface User extends BaseEntity {
  username: string;
  email: string;
  password: string;
  isActive: boolean;
}

// أنواع لعمليات مختلفة
type UserCreate = Omit<User, keyof BaseEntity>;
type UserUpdate = Partial<Omit<User, keyof BaseEntity | 'password'>>;
type UserPublic = Omit<User, 'password'>;
type UserResponse = Readonly<UserPublic>;

class UserService {
  create(data: UserCreate): Promise<UserResponse> {
    // التنفيذ
    return Promise.resolve({} as UserResponse);
  }

  update(id: number, data: UserUpdate): Promise<UserResponse> {
    // التنفيذ
    return Promise.resolve({} as UserResponse);
  }

  findById(id: number): Promise<UserResponse | null> {
    // التنفيذ
    return Promise.resolve(null);
  }
}

// الاستخدام
const service = new UserService();

service.create({
  username: 'johndoe',
  email: 'john@example.com',
  password: 'secure123',
  isActive: true
});

service.update(1, {
  email: 'newemail@example.com'
  // لا يمكن تحديث كلمة المرور هنا
});
>