تسلط بر انواع بازگشتی در تایپ‌اسکریپت: نگاهی عمیق به تعاریف خودارجاعی

در دنیای توسعه نرم‌افزار، ما اغلب با ساختارهای داده‌ای مواجه می‌شویم که به طور طبیعی تو در تو یا سلسله‌مراتبی هستند. به سیستم‌های فایل، چارت‌های سازمانی، نظرات رشته‌ای در یک پلتفرم رسانه اجتماعی، یا حتی ساختار یک شیء JSON فکر کنید. چگونه این ساختارهای پیچیده و خودارجاعی را به روشی ایمن از نظر نوع داده (type-safe) نمایش دهیم؟ پاسخ در یکی از قدرتمندترین ویژگی‌های تایپ‌اسکریپت نهفته است: انواع بازگشتی (recursive types).

این راهنمای جامع شما را در سفری از مفاهیم بنیادی انواع بازگشتی تا کاربردهای پیشرفته و بهترین شیوه‌ها همراهی می‌کند. چه یک توسعه‌دهنده باتجربه تایپ‌اسکریپت باشید که به دنبال تعمیق درک خود است و چه یک برنامه‌نویس متوسط که قصد دارد چالش‌های پیچیده‌تر مدل‌سازی داده را حل کند، این مقاله شما را به دانش لازم برای استفاده از انواع بازگشتی با اطمینان و دقت مجهز خواهد کرد.

انواع بازگشتی چیست؟ قدرت خودارجاعی

در هسته خود، یک نوع بازگشتی یک تعریف نوع است که به خودش ارجاع می‌دهد. این معادل سیستم نوع برای یک تابع بازگشتی است – تابعی که خودش را فراخوانی می‌کند. این قابلیت خودارجاعی به ما امکان می‌دهد تا انواع داده‌هایی را تعریف کنیم که عمق دلخواه یا نامعلومی دارند.

یک قیاس ساده در دنیای واقعی، مفهوم عروسک‌های تودرتوی روسی (ماتروشکا) است. هر عروسک حاوی یک عروسک کوچک‌تر و مشابه است که به نوبه خود حاوی دیگری است و الی آخر. یک نوع بازگشتی می‌تواند این را به طور کامل مدل‌سازی کند: یک `Doll` نوعی است که ویژگی‌هایی مانند `color` و `size` دارد و همچنین شامل یک ویژگی اختیاری است که یک `Doll` دیگر است.

بدون انواع بازگشتی، مجبور بودیم از جایگزین‌های کم‌خطرتری مانند `any` یا `unknown` استفاده کنیم، یا تلاش کنیم تعداد محدودی از سطوح تو در تو را تعریف کنیم (مثلاً `Category`, `SubCategory`, `SubSubCategory`) که شکننده است و به محض نیاز به سطح جدیدی از تو در تو، از کار می‌افتد. انواع بازگشتی یک راه‌حل زیبا، مقیاس‌پذیر و نوع‌امن (type-safe) ارائه می‌دهند.

تعریف یک نوع بازگشتی پایه: لیست پیوندی

اجازه دهید با یک ساختار داده کلاسیک علوم کامپیوتر شروع کنیم: لیست پیوندی. یک لیست پیوندی دنباله‌ای از گره‌ها است، که هر گره شامل یک مقدار و یک ارجاع (یا پیوند) به گره بعدی در دنباله است. آخرین گره به `null` یا `undefined` اشاره می‌کند که نشان‌دهنده پایان لیست است.

این ساختار ذاتاً بازگشتی است. یک `Node` بر اساس خودش تعریف می‌شود. در اینجا نحوه مدل‌سازی آن در تایپ‌اسکریپت آورده شده است:

            
interface LinkedListNode {
  value: number;
  next: LinkedListNode | null;
}

            

              
                Copy
              
            
          

در این مثال، واسط `LinkedListNode` دو ویژگی دارد:

• `value`: در این مورد، یک `number`. بعدها آن را جنریک خواهیم کرد.
• `next`: این بخش بازگشتی است. ویژگی `next` یا یک `LinkedListNode` دیگر است یا `null` در صورتی که پایان لیست باشد.

با ارجاع به خود در تعریف خودش، `LinkedListNode` می‌تواند زنجیره‌ای از گره‌ها با هر طولی را توصیف کند. بیایید آن را در عمل ببینیم:

            
const node3: LinkedListNode = { value: 3, next: null };
const node2: LinkedListNode = { value: 2, next: node3 };
const node1: LinkedListNode = { value: 1, next: node2 };

// node1 is the head of the list: 1 -> 2 -> 3 -> null

function sumLinkedList(node: LinkedListNode | null): number {
  if (node === null) {
    return 0;
  }
  return node.value + sumLinkedList(node.next);
}

console.log(sumLinkedList(node1)); // Outputs: 6

            

              
                Copy
              
            
          

تابع `sumLinkedList` یک همراه عالی برای نوع بازگشتی ما است. این یک تابع بازگشتی است که ساختار داده بازگشتی را پردازش می‌کند. تایپ‌اسکریپت شکل `LinkedListNode` را درک می‌کند و تکمیل خودکار کامل و بررسی نوع را فراهم می‌آورد و از خطاهای رایج مانند تلاش برای دسترسی به `node.next.value` زمانی که `node.next` می‌تواند `null` باشد، جلوگیری می‌کند.

مدل‌سازی داده‌های سلسله‌مراتبی: ساختار درختی

در حالی که لیست‌های پیوندی خطی هستند، بسیاری از مجموعه‌داده‌های واقعی سلسله‌مراتبی‌اند. اینجاست که ساختارهای درختی می‌درخشند و انواع بازگشتی راه طبیعی برای مدل‌سازی آن‌ها هستند.

مثال ۱: چارت سازمانی دپارتمان

یک چارت سازمانی را در نظر بگیرید که در آن هر کارمند یک مدیر دارد و مدیران نیز خود کارمند هستند. یک کارمند همچنین می‌تواند تیمی از کارمندان دیگر را مدیریت کند.

            
interface Employee {
  id: number;
  name: string;
  role: string;
  reports: Employee[]; // The recursive part!
}

const ceo: Employee = {
  id: 1,
  name: 'Alina Sterling',
  role: 'CEO',
  reports: [
    {
      id: 2,
      name: 'Ben Carter',
      role: 'CTO',
      reports: [
        {
          id: 4,
          name: 'David Chen',
          role: 'Lead Engineer',
          reports: []
        }
      ]
    },
    {
      id: 3,
      name: 'Carla Rodriguez',
      role: 'CFO',
      reports: []
    }
  ]
};

            

              
                Copy
              
            
          

در اینجا، واسط `Employee` شامل یک ویژگی `reports` است که آرایه‌ای از اشیاء `Employee` دیگر است. این به طور زیبایی کل سلسله‌مراتب را مدل‌سازی می‌کند، صرف نظر از اینکه چند سطح مدیریتی وجود دارد. می‌توانیم توابعی برای پیمایش این درخت بنویسیم، مثلاً برای یافتن یک کارمند خاص یا محاسبه کل تعداد افراد در یک دپارتمان.

مثال ۲: یک سیستم فایل

یکی دیگر از ساختارهای درختی کلاسیک، سیستم فایل است که از فایل‌ها و دایرکتوری‌ها (پوشه‌ها) تشکیل شده است. یک دایرکتوری می‌تواند هم فایل‌ها و هم دایرکتوری‌های دیگر را در بر بگیرد.

            
interface File {
  type: 'file';
  name: string;
  size: number; // in bytes
}

interface Directory {
  type: 'directory';
  name: string;
  contents: FileSystemNode[]; // The recursive part!
}

// A discriminated union for type safety
type FileSystemNode = File | Directory;

const root: Directory = {
  type: 'directory',
  name: 'project',
  contents: [
    {
      type: 'file',
      name: 'package.json',
      size: 256
    },
    {
      type: 'directory',
      name: 'src',
      contents: [
        {
          type: 'file',
          name: 'index.ts',
          size: 1024
        },
        {
          type: 'directory',
          name: 'components',
          contents: []
        }
      ]
    }
  ]
};

            

              
                Copy
              
            
          

در این مثال پیشرفته‌تر، ما از یک نوع اتحادیه (union type) به نام `FileSystemNode` استفاده می‌کنیم تا نشان دهیم که یک موجودیت می‌تواند یا یک `File` باشد یا یک `Directory`. واسط `Directory` سپس به صورت بازگشتی از `FileSystemNode` برای `contents` خود استفاده می‌کند. ویژگی `type` به عنوان یک ممیز عمل می‌کند و به تایپ‌اسکریپت اجازه می‌دهد تا نوع را به درستی در دستورات `if` یا `switch` محدود کند.

کار با JSON: یک کاربرد جهانی و عملی

شاید رایج‌ترین مورد استفاده برای انواع بازگشتی در توسعه وب مدرن، مدل‌سازی JSON (JavaScript Object Notation) باشد. یک مقدار JSON می‌تواند یک رشته، عدد، بولین، null، آرایه‌ای از مقادیر JSON، یا یک شیء باشد که مقادیر آن مقادیر JSON هستند.

متوجه بازگشت شدید؟ عناصر یک آرایه مقادیر JSON هستند. ویژگی‌های یک شیء مقادیر JSON هستند. این نیاز به یک تعریف نوع خودارجاعی دارد.

تعریف نوعی برای JSON دلخواه

در اینجا نحوه تعریف یک نوع قوی برای هر ساختار JSON معتبر آورده شده است. این الگو هنگام کار با APIهایی که بارهای JSON پویا یا غیرقابل پیش‌بینی برمی‌گردانند، فوق‌العاده مفید است.

            
type JsonValue =
  | string
  | number
  | boolean
  | null
  | JsonValue[] // Recursive reference to an array of itself
  | { [key: string]: JsonValue }; // Recursive reference to an object of itself

// It's also common to define JsonObject separately for clarity:
type JsonObject = { [key: string]: JsonValue };

// And then redefine JsonValue like this:
type JsonValue = 
  | string
  | number
  | boolean
  | null
  | JsonValue[]
  | JsonObject;


            

              
                Copy
              
            
          

این نمونه‌ای از بازگشت متقابل (mutual recursion) است. `JsonValue` بر اساس `JsonObject` (یا یک شیء درون‌خطی) تعریف می‌شود، و `JsonObject` بر اساس `JsonValue` تعریف می‌شود. تایپ‌اسکریپت این ارجاع دایره‌ای را به خوبی مدیریت می‌کند.

مثال: یک تابع Type-Safe برای Stringify کردن JSON

با نوع `JsonValue` ما، می‌توانیم توابعی ایجاد کنیم که تضمین شده است فقط بر روی ساختارهای داده‌ای سازگار با JSON عمل می‌کنند و از خطاهای زمان اجرا قبل از وقوع آن‌ها جلوگیری می‌کنند.

            
function processJson(data: JsonValue): void {
  if (typeof data === 'string') {
    console.log(`Found a string: ${data}`);
  } else if (Array.isArray(data)) {
    console.log('Processing an array...');
    data.forEach(processJson); // Recursive call
  } else if (typeof data === 'object' && data !== null) {
    console.log('Processing an object...');
    for (const key in data) {
      processJson(data[key]); // Recursive call
    }
  }
  // ... handle other primitive types
}

const myData: JsonValue = {
  user: 'Alex',
  is_active: true,
  session_data: {
    id: 12345,
    tokens: ['A', 'B', 'C']
  }
};

processJson(myData);

            

              
                Copy
              
            
          

با تعیین نوع پارامتر `data` به عنوان `JsonValue`، اطمینان حاصل می‌کنیم که هر تلاشی برای ارسال یک تابع، یک شیء `Date`، `undefined`، یا هر مقدار غیرقابل سریال‌سازی دیگری به `processJson` منجر به خطای زمان کامپایل خواهد شد. این یک بهبود عظیم در استحکام کد است.

مفاهیم پیشرفته و مشکلات احتمالی

همانطور که عمیق‌تر به انواع بازگشتی می‌پردازید، با الگوهای پیشرفته‌تر و چند چالش رایج مواجه خواهید شد.

انواع بازگشتی جنریک

واسط `LinkedListNode` اولیه ما برای مقدار خود به سختی کدگذاری شده بود که از یک `number` استفاده کند. این زیاد قابل استفاده مجدد نیست. می‌توانیم آن را جنریک کنیم تا از هر نوع داده‌ای پشتیبانی کند.

            
interface GenericNode<T> {
  value: T;
  next: GenericNode<T> | null;
}

let stringNode: GenericNode<string> = { value: 'hello', next: null };
let numberNode: GenericNode<number> = { value: 123, next: null };

interface User { id: number; name: string; }
let userNode: GenericNode<User> = { value: { id: 1, name: 'Alex' }, next: null };

            

              
                Copy
              
            
          

با معرفی یک پارامتر نوع <T>، `GenericNode` ما اکنون می‌تواند برای ایجاد یک لیست پیوندی از رشته‌ها، اعداد، اشیاء، یا هر نوع دیگری استفاده شود و قابلیت استفاده مجدد را در سراسر کد شما افزایش می‌دهد.

خطای وحشتناک: "Type instantiation is excessively deep and possibly infinite"

گاهی اوقات، هنگام تعریف یک نوع بازگشتی پیچیده، ممکن است با این خطای بدنام تایپ‌اسکریپت مواجه شوید. این اتفاق می‌افتد زیرا کامپایلر تایپ‌اسکریپت یک محدودیت عمق داخلی دارد تا از گیر افتادن خود در یک حلقه بی‌نهایت هنگام حل انواع محافظت کند. اگر تعریف نوع شما بیش از حد مستقیم یا پیچیده باشد، می‌تواند به این محدودیت برسد.

این مثال مشکل‌ساز را در نظر بگیرید:

            
// This can cause issues
type BadTuple = [string, BadTuple] | [];

            

              
                Copy
              
            
          

در حالی که این ممکن است معتبر به نظر برسد، نحوه گسترش (expands) مستعارهای نوع (type aliases) توسط تایپ‌اسکریپت گاهی اوقات می‌تواند منجر به این خطا شود. یکی از موثرترین راه‌ها برای حل این مشکل استفاده از یک `interface` است. واسط‌ها یک نوع نام‌گذاری شده در سیستم نوع ایجاد می‌کنند که می‌توان بدون گسترش فوری به آن ارجاع داد، که معمولاً بازگشت را با ظرافت بیشتری مدیریت می‌کند.

            
// This is much safer
interface GoodTuple {
  head: string;
  tail: GoodTuple | null;
}

            

              
                Copy
              
            
          

اگر مجبور به استفاده از یک مستعار نوع هستید، گاهی اوقات می‌توانید با معرفی یک نوع واسطه‌ای یا استفاده از ساختار متفاوت، بازگشت مستقیم را بشکنید. با این حال، قانون کلی این است: برای شکل‌های پیچیده شیء، به خصوص انواع بازگشتی، `interface` را بر `type` ترجیح دهید.

انواع شرطی و نگاشت شده بازگشتی

قدرت واقعی سیستم نوع تایپ‌اسکریپت زمانی آشکار می‌شود که ویژگی‌ها را با هم ترکیب کنید. انواع بازگشتی می‌توانند در انواع ابزاری پیشرفته، مانند انواع نگاشت شده (mapped types) و شرطی (conditional types)، برای انجام تبدیل‌های عمیق بر روی ساختارهای شیء استفاده شوند.

یک مثال کلاسیک `DeepReadonly<T>` است که به صورت بازگشتی تمام ویژگی‌های یک شیء و زیرشاخه‌های آن را `readonly` می‌کند.

            
type DeepReadonly<T> = T extends (...args: any[]) => any
  ? T
  : T extends object
  ? { readonly [P in keyof T]: DeepReadonly<T[P]> }
  : T;

interface UserProfile {
  id: number;
  details: {
    name: string;
    address: {
      city: string;
    };
  };
}

type ReadonlyUserProfile = DeepReadonly<UserProfile>;

// const profile: ReadonlyUserProfile = ...
// profile.id = 2; // Error!
// profile.details.name = 'New Name'; // Error!
// profile.details.address.city = 'New City'; // Error!

            

              
                Copy
              
            
          

بیایید این نوع ابزاری قدرتمند را تحلیل کنیم:

• ابتدا بررسی می‌کند که آیا `T` یک تابع است و آن را به همان شکل رها می‌کند.
• سپس بررسی می‌کند که آیا `T` یک شیء است.
• اگر شیء باشد، بر روی هر ویژگی `P` در `T` نگاشت (map) می‌کند.
• برای هر ویژگی، `readonly` را اعمال می‌کند و سپس – این نکته کلیدی است – به صورت بازگشتی `DeepReadonly` را فراخوانی می‌کند بر روی نوع ویژگی `T[P]`.
• اگر `T` یک شیء نباشد (یعنی یک نوع اولیه)، `T` را به همان شکل برمی‌گرداند.

این الگوی دستکاری نوع بازگشتی برای بسیاری از کتابخانه‌های پیشرفته تایپ‌اسکریپت اساسی است و امکان ایجاد انواع ابزاری فوق‌العاده مستحکم و گویا را فراهم می‌کند.

بهترین شیوه‌ها برای استفاده از انواع بازگشتی

برای استفاده موثر از انواع بازگشتی و حفظ یک کدبیس تمیز و قابل فهم، این بهترین شیوه‌ها را در نظر بگیرید:

1. واسط‌ها را برای APIهای عمومی ترجیح دهید: هنگام تعریف یک نوع بازگشتی که بخشی از API عمومی یک کتابخانه یا یک ماژول مشترک خواهد بود، `interface` اغلب انتخاب بهتری است. بازگشت را با اطمینان بیشتری مدیریت می‌کند و پیام‌های خطای بهتری ارائه می‌دهد.
2. از مستعارهای نوع برای موارد ساده‌تر استفاده کنید: برای انواع بازگشتی ساده، محلی یا مبتنی بر اتحادیه (مانند مثال `JsonValue` ما)، یک مستعار `type` کاملاً قابل قبول و اغلب مختصرتر است.
3. ساختارهای داده خود را مستندسازی کنید: درک یک نوع بازگشتی پیچیده در یک نگاه دشوار است. از توضیحات TSDoc برای توضیح ساختار، هدف آن و ارائه یک مثال استفاده کنید.
4. همیشه یک مورد پایه تعریف کنید: درست مانند یک تابع بازگشتی که برای توقف اجرای خود به یک مورد پایه نیاز دارد، یک نوع بازگشتی نیز به راهی برای پایان یافتن نیاز دارد. این معمولاً `null`، `undefined`، یا یک آرایه خالی (`[]`) است که زنجیره خودارجاعی را متوقف می‌کند. در `LinkedListNode` ما، مورد پایه `| null` بود.
5. از اتحادیه‌های ممیزی‌شده (Discriminated Unions) بهره ببرید: هنگامی که یک ساختار بازگشتی می‌تواند شامل انواع مختلفی از گره‌ها باشد (مانند مثال `FileSystemNode` ما با `File` و `Directory`)، از یک اتحادیه ممیزی‌شده استفاده کنید. این به طور قابل توجهی ایمنی نوع را هنگام کار با داده‌ها بهبود می‌بخشد.
6. انواع و توابع خود را آزمایش کنید: تست‌های واحد برای توابعی که ساختارهای داده بازگشتی را مصرف یا تولید می‌کنند، بنویسید. اطمینان حاصل کنید که موارد مرزی مانند یک لیست/درخت خالی، یک ساختار تک گره‌ای، و یک ساختار عمیقاً تودرتو را پوشش می‌دهید.

نتیجه‌گیری: پذیرش پیچیدگی با ظرافت

انواع بازگشتی تنها یک ویژگی اسرارآمیز برای نویسندگان کتابخانه نیستند؛ آن‌ها ابزاری بنیادی برای هر توسعه‌دهنده تایپ‌اسکریپت هستند که نیاز به مدل‌سازی دنیای واقعی دارد. از لیست‌های ساده تا درختان JSON پیچیده و داده‌های سلسله‌مراتبی خاص دامنه، تعاریف خودارجاعی نقشه‌ای برای ایجاد برنامه‌های کاربردی مستحکم، خود مستندساز و نوع‌امن فراهم می‌کنند.

با درک نحوه تعریف، استفاده و ترکیب انواع بازگشتی با سایر ویژگی‌های پیشرفته مانند جنریک‌ها و انواع شرطی، می‌توانید مهارت‌های تایپ‌اسکریپت خود را ارتقا داده و نرم‌افزاری بسازید که هم مقاوم‌تر و هم قابل درک‌تر باشد. دفعه بعد که با یک ساختار داده تو در تو مواجه می‌شوید، ابزار عالی برای مدل‌سازی آن با ظرافت و دقت را خواهید داشت.