TypeScript में JSON प्रोसेसिंग: टाइपिंग, वैलिडेशन और पार्सिंग

TypeScript में JSON प्रोसेसिंग: बुनियादी संचालन से लेकर उन्नत टाइपिंग तक

JSON (JavaScript Object Notation) वेब डेवलपमेंट में डेटा आदान-प्रदान का मुख्य प्रारूप बना हुआ है। TypeScript JSON के साथ काम करने में एक शक्तिशाली टाइप सिस्टम जोड़ता है, जो कंपाइलेशन चरण में कई त्रुटियों से बचने में मदद करता है। इस लेख में, हम TypeScript में JSON प्रोसेसिंग के सभी पहलुओं को कवर करेंगे: सरल पार्सिंग से लेकर सख्ती से टाइप किए गए वैलिडेटर बनाने तक।

बुनियादी पार्सिंग और सीरियलाइज़ेशन

आइए मूलभूत संचालन से शुरू करते हैं। बिल्ट-इन विधियाँ JSON.parse() और JSON.stringify() TypeScript में उसी तरह काम करती हैं जैसे JavaScript में, लेकिन टाइपिंग में महत्वपूर्ण अंतर के साथ।

// सरल पार्सिंग — परिणाम any होगाconst data: any = JSON.parse('{"name": "Alice", "age": 30}');

// बेहतर होगा कि तुरंत टाइप निर्दिष्ट करेंinterface User {  name: string;  age: number;}

const user: User = JSON.parse('{"name": "Alice", "age": 30}') as User;console.log(user.name); // Alice

यह समझना महत्वपूर्ण है: as User एक टाइप एसर्शन (type assertion) है, न कि जाँच। यदि JSON में अमान्य डेटा है, तो TypeScript आपको त्रुटि के बारे में चेतावनी नहीं देगा। सुरक्षित कार्य के लिए वैलिडेशन आवश्यक है।

Generics के साथ सुरक्षित पार्सिंग

आइए संरचना जाँच के साथ सुरक्षित JSON पार्सिंग के लिए एक सार्वभौमिक फ़ंक्शन बनाएं:

function safeParse<T>(json: string, validator: (data: unknown) => data is T): T | null {  try {    const parsed: unknown = JSON.parse(json);    if (validator(parsed)) {      return parsed;    }    return null;  } catch {    return null;  }}

// टाइप और वैलिडेटर फ़ंक्शन परिभाषित करेंinterface Product {  id: number;  title: string;  price: number;}

function isProduct(data: unknown): data is Product {  if (typeof data !== 'object' || data === null) return false;  const obj = data as Record<string, unknown>;  return (    typeof obj.id === 'number' &&    typeof obj.title === 'string' &&    typeof obj.price === 'number'  );}

const jsonString = '{"id": 1, "title": "Book", "price": 19.99}';const product = safeParse<Product>(jsonString, isProduct);if (product) {  console.log(`उत्पाद: ${product.title}, मूल्य: ${product.price}`);} else {  console.log('अमान्य JSON प्रारूप');}

नेस्टेड संरचनाओं और ऐरे के साथ काम करना

वास्तविक JSON डेटा में अक्सर नेस्टेड ऑब्जेक्ट और ऐरे होते हैं। आइए एक जटिल संरचना के टाइपिंग के साथ एक उदाहरण देखें:

interface Order {  id: string;  customer: {    name: string;    email: string;  };  items: Array<{    productId: number;    quantity: number;  }>;  total: number;}

// पार्स करें और तुरंत संरचना जाँचेंfunction parseOrder(json: string): Order {  const raw = JSON.parse(json);    // सरलतम जाँच  if (!raw.id || !raw.customer || !Array.isArray(raw.items)) {    throw new Error('अमान्य ऑर्डर संरचना');  }    return raw as Order;}

const orderJson = `{  "id": "ORD-001",  "customer": {"name": "Bob", "email": "bob@example.com"},  "items": [{"productId": 42, "quantity": 2}],  "total": 59.98}`;

try {  const order = parseOrder(orderJson);  console.log(`ऑर्डर ${order.id} कुल राशि ${order.total}`);} catch (e) {  console.error('पार्सिंग त्रुटि:', e.message);}

कस्टम कन्वर्टर के साथ सीरियलाइज़ेशन

कभी-कभी यह नियंत्रित करना आवश्यक होता है कि ऑब्जेक्ट JSON में कैसे परिवर्तित होते हैं। TypeScript आपको कस्टम सीरियलाइज़र बनाने की अनुमति देता है:

interface Config {  host: string;  port: number;  timeout: number; // मिलीसेकंड में}

function serializeConfig(config: Config): string {  return JSON.stringify({    host: config.host,    port: config.port,    timeout: config.timeout / 1000 // सेकंड में कन्वर्ट करें  }, null, 2); // इंडेंटेशन के साथ फ़ॉर्मेटिंग}

const myConfig: Config = {  host: 'localhost'