TypeScript में ऑब्जेक्ट सीरियलाइज़ेशन: लाइब्रेरी, विधियाँ और उदाहरण

TypeScript में ऑब्जेक्ट सीरियलाइज़ेशन: पूरी गाइड

सीरियलाइज़ेशन एक ऑब्जेक्ट को बाइट स्ट्रीम या स्ट्रिंग में बदलने की प्रक्रिया है, ताकि इसे नेटवर्क पर भेजा जा सके या सेव किया जा सके। TypeScript में यह काम इसलिए मुश्किल हो जाता है क्योंकि हमें टाइप्स को बनाए रखना, पॉलीमॉर्फिज़्म को सपोर्ट करना और क्लासेस के साथ काम करना होता है। आइए मुख्य टूल्स और तरीकों को समझते हैं।

1. बिल्ट-इन सीरियलाइज़ेशन: JSON.stringify / JSON.parse

JavaScript/TypeScript में बेसिक मैकेनिज़्म ग्लोबल JSON ऑब्जेक्ट है। यह केवल सरल टाइप्स को सीरियलाइज़ करता है: स्ट्रिंग्स, नंबर्स, बूलियन वैल्यूज़, एरे और फ्लैट ऑब्जेक्ट्स। मेथड्स, सिंबल्स, undefined, Date और क्लास इंस्टेंस खो जाते हैं।

// उदाहरण: क्लास का सीरियलाइज़ेशन
class User {
  constructor(
    public name: string,
    private password: string,
    public createdAt: Date = new Date()
  ) {}
}

const user = new User('Ravi', 'secret123');
const json = JSON.stringify(user);
// परिणाम: {"name":"Ravi","createdAt":"2025-03-24T10:00:00.000Z"}
// password JSON में नहीं आया (private), लेकिन Date स्ट्रिंग बन गया
// डी-सीरियलाइज़ेशन पर हमें एक सामान्य ऑब्जेक्ट मिलेगा, User का इंस्टेंस नहीं

const parsed: User = JSON.parse(json) as User;
console.log(parsed instanceof User); // false

समस्याएँ:

• टाइप का नुकसान (क्लास इंस्टेंस object बन जाता है)।
• प्राइवेट फील्ड्स, मेथड्स, गेटर्स सीरियलाइज़ नहीं होते।
• डेट्स, Map, Set, BigInt को मैन्युअल रूपांतरण चाहिए।
• पॉलीमॉर्फिज़्म सपोर्ट नहीं है — टाइप मैन्युअल रिस्टोर करना पड़ता है।

2. class-transformer लाइब्रेरी

class-transformer TypeScript में क्लासेस के सीरियलाइज़ेशन/डी-सीरियलाइज़ेशन के लिए सबसे लोकप्रिय समाधान है। यह रूपांतरण नियमों को परिभाषित करने के लिए डेकोरेटर्स का उपयोग करता है।

इंस्टॉलेशन

npm install class-transformer reflect-metadata

उपयोग का उदाहरण

import { plainToClass, classToPlain, Expose, Transform, Type } from 'class-transformer';
import 'reflect-metadata';

class Address {
  @Expose()
  city!: string;

  @Expose()
  street!: string;
}

class Employee {
  @Expose()
  id!: number;

  @Expose()
  name!: string;

  @Expose()
  @Type(() => Address) // नेस्टेड ट्रांसफॉर्मेशन
  address!: Address;

  @Expose()
  @Transform(({ value }) => new Date(value)) // कस्टम रूपांतरण
  hireDate!: Date;

  // मेथड सीरियलाइज़ नहीं होता
  get displayName(): string {
    return `${this.name} (ID: ${this.id})`;
  }
}

// plain object से डी-सीरियलाइज़ेशन
const plainData = {
  id: 1,
  name: 'Sita',
  address: { city: 'Delhi', street: 'Chandni Chowk' },
  hireDate: '2024-01-15T00:00:00.000Z'
};

const employee = plainToClass(Employee, plainData);
console.log(employee instanceof Employee);          // true
console.log(employee.hireDate instanceof Date);     // true

// वापस सीरियलाइज़ेशन
const plain = classToPlain(employee);
console.log(plain); // { id: 1, name: 'Sita', address: { city: 'Delhi', street: 'Chandni Chowk' }, hireDate: '2024-01-15T00:00:00.000Z' }

लाभ:

• टाइप्स का ऑटोमैटिक रिस्टोरेशन (नेस्टेड ऑब्जेक्ट्स, एरे)।
• डिस्क्रिमिनेटर के साथ @Type के ज़रिए पॉलीमॉर्फिज़्म सपोर्ट।
• वैल्यू ट्रांसफॉर्मेशन (डेट्स, नंबर्स, कस्टम फॉर्मेट)।
• @Expose के ज़रिए प्राइवेट फील्ड्स के साथ काम।

कमियाँ:

• डेकोरेटर्स पर निर्भरता (tsconfig में experimentalDecorators ज़रूरी)।
• हाई-लोड सिस्टम के लिए उपयुक्त नहीं (रिफ्लेक्शन धीमा करता है)।
• बंडल साइज़ ~15KB (gzip)।

3. प्रोटोकॉल बफ़र्स (Protocol Buffers) protobuf-ts के साथ

माइक्रोसर्विस आर्किटेक्चर और gRPC के लिए अक्सर Protocol Buffers का उपयोग होता है। TypeScript इम्प्लीमेंटेशन protobuf-ts .proto फ़ाइलों से टाइपिफ़ाइड कोड जनरेट करता है।

.proto फ़ाइल का उदाहरण

syntax = "proto3";

m