टाइपस्क्रिप्ट में डेटा प्रकार

यह लेख टाइपस्क्रिप्ट में डेटा प्रकारों को समझाता है।

YouTube Video

टाइपस्क्रिप्ट में डेटा प्रकार

टाइपस्क्रिप्ट विभिन्न प्रकार के डेटा प्रकार प्रदान करता है। यह आपको वेरिएबल, फ़ंक्शन के तर्कों और रिटर्न मानों के लिए सख्त प्रकार परिभाषित करने की अनुमति देता है। नीचे मुख्य डेटा प्रकार और उनका उपयोग दिया गया है।

प्राथमिक प्रकार (Primitive Types)

संख्या प्रकार (number Type)

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

• संख्या एक प्रकार है जिसका उपयोग संख्यात्मक मानों को संभालने के लिए किया जाता है, जिसमें पूर्णांक और फ्लोटिंग-पॉइंट नंबर (दशमलव) शामिल होते हैं। कुछ सीमाओं से अधिक मानों को संभालने पर Infinity या NaN (नॉट-अ-नंबर) का परिणाम होता है।

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• TypeScript में, संख्याओं को फ्लोटिंग पॉइंट नंबर के रूप में दर्शाया जाता है। इससे गणना के परिणामों में थोड़ी अशुद्धियां हो सकती हैं।

• जब सटीक गणनाएं आवश्यक हों, जैसे कि वित्तीय राशि, तो इस तरह की राउंडिंग त्रुटियों से बचना आवश्यक है। उदाहरण के लिए, आप BigInt या toFixed() का उपयोग कर सकते हैं, या decimal.js जैसी लाइब्रेरी का उपयोग करके दशमलव स्थानों को समायोजित कर सकते हैं।

स्ट्रिंग प्रकार (string Type)

string प्रकार पाठ्य डेटा को संभालता है।

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

बूलियन प्रकार (boolean प्रकार)

boolean प्रकार में दो मान होते हैं: true या false।

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null और undefined

null 'अस्तित्वहीन मान' को दर्शाता है, और undefined 'अपरिभाषित मान' को दर्शाता है।

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

टाइपस्क्रिप्ट में, आप ऐरे तत्वों के प्रकार निर्दिष्ट कर सकते हैं। number[] संख्याओं की एक ऐरे है, और string[] स्ट्रिंग्स की एक ऐरे है।

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

ट्यूपल (Tuple)

ट्यूपल एक ऐसा ऐरे है जिसमें विभिन्न प्रकार के तत्व होते हैं।

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

एनम (Enum)

enum नामांकित स्थिरांक का एक सेट परिभाषित करता है।

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

any प्रकार किसी भी प्रकार के मान को रख सकता है और इसे तब उपयोग किया जाता है जब आप प्रकार की जांच अक्षम करना चाहते हैं।

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

यूनियन प्रकार (Union Type)

यूनियन प्रकार का उपयोग करके, आप वेरिएबल्स को परिभाषित कर सकते हैं जो एक से अधिक प्रकारों में से किसी एक को रख सकते हैं।

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

सारांश

• number, string, boolean: प्राथमिक प्रकार।
• null, undefined: विशेष मान।
• Array: प्रकार एनोटेशन के साथ एक एरे।
• Tuple: विभिन्न प्रकार के तत्वों वाली एक सरणी।
• enum: एक क्रमांकित प्रकार।
• any: कोई भी प्रकार।
• Union: एक वेरिएबल जो कई प्रकारों में से एक ले सकता है।

इन डेटा प्रकारों का उपयोग करके, TypeScript प्रकार सुरक्षा को बढ़ाता है, जिससे विकास के दौरान त्रुटियों को रोकना आसान हो जाता है।

व्रैपर वस्तुएँ (Wrapper Objects)

TypeScript में Wrapper Objects ऐसी ऑब्जेक्ट्स होती हैं जो प्राथमिक डेटा प्रकारों को ऑब्जेक्ट्स के रूप में मानने के लिए स्वचालित रूप से बनाई जाती हैं। प्राथमिक प्रकार हल्के और तेज़ संचालन की अनुमति देते हैं, जबकि ऑब्जेक्ट प्रकारों में तरीकों और गुण होते हैं, जो समृद्ध संचालन को सक्षम करते हैं।

JavaScript (और TypeScript) में प्राथमिक प्रकारों जैसे string, number, और boolean के लिए संबंधित रैपर ऑब्जेक्ट्स होते हैं। इन्हें क्रमशः String, Number, और Boolean नामक कंस्ट्रक्टर फ़ंक्शनों का उपयोग करके बनाया जाता है।

नीचे रैपर ऑब्जेक्ट्स के उदाहरण दिए गए हैं।

String ऑब्जेक्ट

String ऑब्जेक्ट स्ट्रिंग्स के लिए गुण और तरीके प्रदान करता है।

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

विशेषताएँ:

• प्राथमिक string से अलग, typeof द्वारा String ऑब्जेक्ट को object के रूप में माना जाता है।
• स्ट्रिंग्स को संशोधित करते समय या उन पर तरीके कॉल करते समय रैपर ऑब्जेक्ट्स उपयोगी होते हैं।

Number ऑब्जेक्ट

Number ऑब्जेक्ट नंबरों के लिए गुण और तरीके प्रदान करता है।

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

विशेषताएँ:

• Number ऑब्जेक्ट, नंबरों के लिए एक रैपर के रूप में, संख्यात्मक संचालन के तरीकों को शामिल करता है (जैसे toFixed)।

Boolean ऑब्जेक्ट

Boolean ऑब्जेक्ट बूलियन मानों के लिए गुण और तरीके प्रदान करता है।

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

विशेषताएँ:

• Boolean ऑब्जेक्ट प्राथमिक boolean प्रकार के लिए एक रैपर है और इसे object के रूप में माना जाता है।

Wrapper ऑब्जेक्ट्स और प्राथमिक प्रकारों के बीच अंतर

चूंकि रैपर ऑब्जेक्ट्स को ऑब्जेक्ट्स के रूप में माना जाता है, प्रदर्शन में थोड़ी गिरावट होती है, लेकिन अतिरिक्त गुणों और तरीकों के कारण अधिक कार्यात्मक संचालन संभव होते हैं। इसके अलावा, == और === का उपयोग करके तुलना में अंतर होता है।

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

विशेषताएँ:

• == मानों की तुलना करता है, जबकि === प्रकारों सहित सख्ती से तुलना करता है। === आवरण ऑब्जेक्ट्स की तुलना में मूल प्रकारों के साथ तुलना करते समय false लौटाता है।

प्रकार रूपांतरण

TypeScript में, अप्रत्यक्ष और स्पष्ट प्रकार रूपांतरणों का सही प्रबंधन करना महत्वपूर्ण है।

अप्रत्यक्ष प्रकार रूपांतरण

• TypeScript में, प्रकार सुरक्षा सुनिश्चित करने के लिए अप्रत्यक्ष प्रकार रूपांतरणों से जितना संभव हो सके बचना चाहिए।

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• इस उदाहरण में, संख्या 5 को अप्रत्यक्ष रूप से एक स्ट्रिंग में परिवर्तित किया गया है, जिसके परिणामस्वरूप स्ट्रिंग "55" बनती है।

स्पष्ट प्रकार रूपांतरण

• TypeScript में, प्रकार रूपांतरणों को सुरक्षित रूप से करने के लिए प्रकार एनोटेशन या प्रकार रूपांतरण फ़ंक्शंस का उपयोग करें।

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• इस उदाहरण में, Number() फ़ंक्शन का उपयोग स्ट्रिंग "123" को स्पष्ट रूप से संख्या 123 में परिवर्तित करने के लिए किया गया है।

प्रकार जाँच

TypeScript में, आप किसी वेरिएबल के डेटा प्रकार की जांच के लिए typeof ऑपरेटर का उपयोग कर सकते हैं।

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

• TypeScript में, आप प्रकारों की जांच के लिए typeof का उपयोग कर सकते हैं, लेकिन अधिक सटीक प्रकार जाँच के लिए, instanceof या is ऑपरेटर का उपयोग करने की भी सिफारिश की जाती है।

सारांश

• आवरण ऑब्जेक्ट्स को ऑब्जेक्ट्स के रूप में माना जाता है क्योंकि वे मूल प्रकारों के लिए अतिरिक्त विधियां और गुण प्रदान करते हैं।
• String, Number, और Boolean आवरण ऑब्जेक्ट्स के प्रतिनिधि उदाहरण हैं।
• मूल प्रकारों के विपरीत, आवरण ऑब्जेक्ट्स को typeof द्वारा object के रूप में पहचाना जाता है।

आप हमारे YouTube चैनल पर Visual Studio Code का उपयोग करके ऊपर दिए गए लेख के साथ आगे बढ़ सकते हैं। कृपया YouTube चैनल को भी देखें।

YouTube Video