آموزش تایپ اسکریپت از صفر با کامپایلر واقعی

// هر سفارش فقط در یکی از این حالت‌هاست و هر حالت فیلدهای خودش را دارد
type Order =
  | { status: 'pending'; id: number }
  | { status: 'shipped'; id: number; tracking: string }
  | { status: 'delivered'; id: number; days: number }
  | { status: 'cancelled'; id: number; reason: string };
 
function describe(order: Order): string {
  switch (order.status) {
    case 'pending':
      return `#${order.id}  waiting for payment`;
    case 'shipped':
      return `#${order.id}  on the way, tracking ${order.tracking}`;
    case 'delivered':
      return `#${order.id}  delivered in ${order.days} days`;
    case 'cancelled':
      return `#${order.id}  cancelled: ${order.reason}`;
    default: {
      // اگر حالت تازه‌ای اضافه شود و اینجا جا بماند، tsc این خط را رد می‌کند
      const missed: never = order;
      return missed;
    }
  }
}
 
const orders: Order[] = [
  { status: 'pending', id: 101 },
  { status: 'shipped', id: 102, tracking: 'IR-58213' },
  { status: 'delivered', id: 103, days: 3 },
  { status: 'cancelled', id: 104, reason: 'out of stock' },
];
orders.forEach((o) => console.log(describe(o)));
 
// @ts-expect-error: «shiped» یکی از حالت‌ها نیست و tsc آن را نمی‌پذیرد
const typo: Order = { status: 'shiped', id: 105 };

interface User {
  name: string;
  age: number;
}
 
// گارد نوع: اگر true برگرداند، tsc از آن به بعد value را User می‌داند
function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' && value !== null &&
    'name' in value && typeof value.name === 'string' &&
    'age' in value && typeof value.age === 'number'
  );
}
 
// داده‌ای که از بیرون می‌رسد. JSON.parse شکل آن را تضمین نمی‌کند
const raw = '[{"name":"Sara","age":28},{"name":"Reza"},{"name":"Mina","age":"31"},null,{"name":"Ali","age":40}]';
const data: unknown = JSON.parse(raw);
 
if (Array.isArray(data)) {
  for (const item of data) {
    if (isUser(item)) {
      // بدون گارد، سن مینا که رشته است به‌جای 32 متن "311" می‌شد
      console.log(`OK    ${item.name.padEnd(6)}${item.age + 1} next year`);
    } else {
      console.log(`SKIP  ${JSON.stringify(item)}`);
    }
  }
}

// یک تابع جنریک برای هر نوع آرایه؛ نوع خروجی هم از ورودی ساخته می‌شود
function groupBy<T, K extends string>(items: T[], keyOf: (item: T) => K): Record<K, T[]> {
  const groups = {} as Record<K, T[]>;
  for (const item of items) {
    const key = keyOf(item);
    (groups[key] ??= []).push(item);
  }
  return groups;
}
 
interface Book {
  title: string;
  level: 'beginner' | 'advanced';
}
 
const books: Book[] = [
  { title: 'First Steps', level: 'beginner' },
  { title: 'Deep Types', level: 'advanced' },
  { title: 'Hello Code', level: 'beginner' },
  { title: 'Compilers', level: 'advanced' },
];
 
// نوع byLevel را tsc خودش می‌فهمد: Record<'beginner' | 'advanced', Book[]>
const byLevel = groupBy(books, (b) => b.level);
console.log('beginner:', byLevel.beginner.map((b) => b.title).join(', '));
console.log('advanced:', byLevel.advanced.map((b) => b.title).join(', '));
 
// همان تابع، این بار روی عدد
const parity = groupBy([3, 8, 1, 6, 5], (n) => (n % 2 === 0 ? 'even' : 'odd'));
console.log(parity);
 
// @ts-expect-error: «expert» یکی از کلیدهای این گروه‌ها نیست
byLevel.expert;

// از نام فیلدهای یک نوع، نام متدها را در سطح نوع می‌سازد: title → getTitle
type Getters<T> = {
  [K in keyof T & string as `get${Capitalize<K>}`]: () => T[K];
};
 
function makeGetters<T extends object>(obj: T): Getters<T> {
  const out: Record<string, () => unknown> = {};
  for (const key of Object.keys(obj) as (keyof T & string)[]) {
    out[`get${key[0].toUpperCase()}${key.slice(1)}`] = () => obj[key];
  }
  return out as Getters<T>;
}
 
const book = { title: 'Deep Types', pages: 320, available: true };
const g = makeGetters(book);
// tsc نوع g را می‌داند: { getTitle(): string; getPages(): number; getAvailable(): boolean }
 
console.log(Object.keys(g));
console.log(g.getTitle().toUpperCase());
console.log(g.getPages() + 10);
console.log(g.getAvailable());
 
// @ts-expect-error: book فیلد author ندارد، پس getAuthor هم ساخته نمی‌شود
type Missing = Getters<typeof book>['getAuthor'];

const wait = (ms: number) => new Promise<void>((done) => setTimeout(done, ms));
 
async function loadUser(id: number): Promise<{ id: number; name: string }> {
  await wait(30);
  console.log('user ready');
  return { id, name: 'Sara' };
}
 
async function loadOrders(userId: number): Promise<number[]> {
  await wait(20);
  console.log('orders ready');
  return [120_000, 85_000, 240_000];
}
 
async function loadPoints(userId: number): Promise<number> {
  await wait(10);
  console.log('points ready');
  return 1200;
}
 
async function main() {
  // هر سه درخواست با هم شروع می‌شوند؛ tsc نوع هر خانه را جدا می‌داند
  const [user, orders, points] = await Promise.all([loadUser(7), loadOrders(7), loadPoints(7)]);
  const total = orders.reduce((sum, x) => sum + x, 0);
  console.log(`${user.name}: ${orders.length} orders, total ${total}, ${points} points`);
}
 
main();