TypeScript
टाइपस्क्रिप्ट कोर प्रकार

वाक्य - विन्यास

• परिवर्तनशील नाम दें: VariableType;
• function फ़ंक्शन नाम (पैरामीटर नाम: VariableType, पैरामीटरWithDefault: VariableType = ParameterDefault, वैकल्पिकParameter ;: VariableType, ... varardicParameter: VariableType []): ReturnType {/*...//}};

बूलियन

एक बूलियन टाइपस्क्रिप्ट में सबसे बुनियादी डेटाटाइप का प्रतिनिधित्व करता है, सच / गलत मूल्यों को निर्दिष्ट करने के उद्देश्य से।

// set with initial value (either true or false)
let isTrue: boolean = true;        

// defaults to 'undefined', when not explicitely set
let unsetBool: boolean;             

// can also be set to 'null' as well
let nullableBool: boolean = null;

संख्या

जावास्क्रिप्ट की तरह, संख्याएं अस्थायी मान हैं।

let pi: number = 3.14;           // base 10 decimal by default
let hexadecimal: number = 0xFF;  // 255 in decimal

ECMAScript 2015 बाइनरी और ऑक्टल की अनुमति देता है।

let binary: number = 0b10;   // 2 in decimal
let octal: number = 0o755;   // 493 in decimal

तार

पाठ डेटा प्रकार:

let singleQuotes: string = 'single';
let doubleQuotes: string = "double";
let templateString: string = `I am ${ singleQuotes }`; // I am single

सरणी

मूल्यों की एक सरणी:

let threePigs: number[] = [1, 2, 3];
let genericStringArray: Array<string> = ['first', '2nd', '3rd'];

enum

सांख्यिक मानों के समूह को नाम देने का एक प्रकार:

संख्या मान डिफ़ॉल्ट 0:

enum Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };
let bestDay: Day = Day.Saturday;

डिफ़ॉल्ट प्रारंभिक संख्या सेट करें:

enum TenPlus { Ten = 10, Eleven, Twelve }

या मान निर्दिष्ट करें:

enum MyOddSet { Three = 3, Five = 5, Seven = 7, Nine = 9 } 

कोई भी

जब एक प्रकार का अनिश्चित, any उपलब्ध है:

let anything: any = 'I am a string';
anything = 5; // but now I am the number 5

शून्य

यदि आपके पास कोई प्रकार नहीं है, तो आमतौर पर उन कार्यों के लिए उपयोग किया जाता है जो कुछ भी वापस नहीं करते हैं:

function log(): void {
    console.log('I return nothing');
}

void प्रकार केवल null या undefined ।

टपल

ज्ञात और संभवतः विभिन्न प्रकारों के साथ सरणी प्रकार:

let day: [number, string];
day = [0, 'Monday'];      // valid
day = ['zero', 'Monday']; // invalid: 'zero' is not numeric
console.log(day[0]); // 0
console.log(day[1]); // Monday

day[2] = 'Saturday'; // valid: [0, 'Saturday']
day[3] = false;      // invalid: must be union type of 'number | string'

फ़ंक्शन तर्क और वापसी मान में प्रकार। संख्या

जब आप टाइपस्क्रिप्ट में एक फ़ंक्शन बनाते हैं तो आप फ़ंक्शन के तर्कों के डेटा प्रकार और रिटर्न मान के लिए डेटा प्रकार निर्दिष्ट कर सकते हैं

उदाहरण:

function sum(x: number, y: number): number {
    return x + y;
}

यहाँ सिंटैक्स x: number, y: number अर्थ है कि फ़ंक्शन दो तर्क x और y को स्वीकार कर सकता है और वे केवल संख्याएँ और (...): number { अर्थात वापसी मान केवल एक संख्या हो सकती है

उपयोग:

sum(84 + 76) // will be return 160

ध्यान दें:

आप ऐसा नहीं कर सकते

function sum(x: string, y: string): number {
    return x + y;
}

या

function sum(x: number, y: number): string {
    return x + y;
}

इसे निम्नलिखित त्रुटियां प्राप्त होंगी:

error TS2322: Type 'string' is not assignable to type 'number' और error TS2322: Type 'number' is not assignable to type 'string' क्रमशः error TS2322: Type 'number' is not assignable to type 'string' है

फ़ंक्शन तर्क और वापसी मान में प्रकार। तार

उदाहरण:

function hello(name: string): string {
    return `Hello ${name}!`;
}

यहां सिंटैक्स name: string अर्थ है कि फ़ंक्शन एक name तर्क को स्वीकार कर सकता है और यह तर्क केवल स्ट्रिंग हो सकता है और (...): string { मतलब है कि रिटर्न मान केवल एक स्ट्रिंग हो सकता है

उपयोग:

hello('StackOverflow Documentation') // will be return Hello StackOverflow Documentation!

स्ट्रिंग लिटरल टाइप्स

स्ट्रिंग शाब्दिक प्रकार आपको सटीक मान निर्दिष्ट करने की अनुमति देता है जो एक स्ट्रिंग में हो सकता है।

let myFavoritePet: "dog";
myFavoritePet = "dog";

कोई अन्य स्ट्रिंग त्रुटि देगा।

// Error: Type '"rock"' is not assignable to type '"dog"'.
// myFavoritePet = "rock";

टाइप अलायस और यूनियन टाइप्स के साथ आपको एक एनुम जैसा व्यवहार मिलता है।

type Species = "cat" | "dog" | "bird";

function buyPet(pet: Species, name: string) : Pet { /*...*/ }

buyPet(myFavoritePet /* "dog" as defined above */, "Rocky");

// Error: Argument of type '"rock"' is not assignable to parameter of type "'cat' | "dog" | "bird". Type '"rock"' is not assignable to type '"bird"'.
// buyPet("rock", "Rocky");

स्ट्रिंग लिटरल टाइप्स का इस्तेमाल ओवरलोड को अलग करने के लिए किया जा सकता है।

function buyPet(pet: Species, name: string) : Pet;
function buyPet(pet: "cat", name: string): Cat;
function buyPet(pet: "dog", name: string): Dog;
function buyPet(pet: "bird", name: string): Bird;
function buyPet(pet: Species, name: string) : Pet { /*...*/ }

let dog = buyPet(myFavoritePet /* "dog" as defined above */, "Rocky");
// dog is from type Dog (dog: Dog)

वे यूज़र-डिफ़ाइंड टाइप गार्ड्स के लिए अच्छा काम करते हैं।

interface Pet {
    species: Species;
    eat();
    sleep();
}

interface Cat extends Pet {
    species: "cat";
}

interface Bird extends Pet {
    species: "bird";
    sing();
}

function petIsCat(pet: Pet): pet is Cat {
    return pet.species === "cat";
}

function petIsBird(pet: Pet): pet is Bird {
    return pet.species === "bird";
}

function playWithPet(pet: Pet){
    if(petIsCat(pet)) {
        // pet is now from type Cat (pet: Cat)
        pet.eat();
        pet.sleep();
    } else if(petIsBird(pet)) {
        // pet is now from type Bird (pet: Bird)
        pet.eat();
        pet.sing();
        pet.sleep();
    }
}

पूर्ण उदाहरण कोड

let myFavoritePet: "dog";
myFavoritePet = "dog";

// Error: Type '"rock"' is not assignable to type '"dog"'.
// myFavoritePet = "rock";

type Species = "cat" | "dog" | "bird";

interface Pet {
    species: Species;
    name: string;
    eat();
    walk();
    sleep();
}

interface Cat extends Pet {
    species: "cat";
}

interface Dog extends Pet {
    species: "dog";
}

interface Bird extends Pet {
    species: "bird";
    sing();
}

// Error: Interface 'Rock' incorrectly extends interface 'Pet'. Types of property 'species' are incompatible. Type '"rock"' is not assignable to type '"cat" | "dog" | "bird"'. Type '"rock"' is not assignable to type '"bird"'.
// interface Rock extends Pet { 
//      type: "rock"; 
// }

function buyPet(pet: Species, name: string) : Pet;
function buyPet(pet: "cat", name: string): Cat;
function buyPet(pet: "dog", name: string): Dog;
function buyPet(pet: "bird", name: string): Bird;
function buyPet(pet: Species, name: string) : Pet {
    if(pet === "cat") { 
        return {
            species: "cat",
            name: name,
            eat: function () {
                console.log(`${this.name} eats.`);
            }, walk: function () {
                console.log(`${this.name} walks.`);
            }, sleep: function () {
                console.log(`${this.name} sleeps.`);
            }
        } as Cat;
    } else if(pet === "dog") { 
        return {
            species: "dog",
            name: name,
            eat: function () {
                console.log(`${this.name} eats.`);
            }, walk: function () {
                console.log(`${this.name} walks.`);
            }, sleep: function () {
                console.log(`${this.name} sleeps.`);
            }
        } as Dog;
    } else if(pet === "bird") { 
        return {
            species: "bird",
            name: name,
            eat: function () {
                console.log(`${this.name} eats.`);
            }, walk: function () {
                console.log(`${this.name} walks.`);
            }, sleep: function () {
                console.log(`${this.name} sleeps.`);
            }, sing: function () {
                console.log(`${this.name} sings.`);
            }
        } as Bird;
    } else {
        throw `Sorry we don't have a ${pet}. Would you like to buy a dog?`;
    }
}

function petIsCat(pet: Pet): pet is Cat {
    return pet.species === "cat";
}

function petIsDog(pet: Pet): pet is Dog {
    return pet.species === "dog";
}

function petIsBird(pet: Pet): pet is Bird {
    return pet.species === "bird";
}

function playWithPet(pet: Pet) {
    console.log(`Hey ${pet.name}, let's play.`);
    
    if(petIsCat(pet)) {
        // pet is now from type Cat (pet: Cat)
        
        pet.eat();
        pet.sleep();
        
        // Error: Type '"bird"' is not assignable to type '"cat"'.
        // pet.type = "bird";
        
        // Error: Property 'sing' does not exist on type 'Cat'.
        // pet.sing();
        
    } else if(petIsDog(pet)) {
        // pet is now from type Dog (pet: Dog)
        
        pet.eat();
        pet.walk();
        pet.sleep();
        
    } else if(petIsBird(pet)) {
        // pet is now from type Bird (pet: Bird)
    
        pet.eat();
        pet.sing();
        pet.sleep();
    } else {
        throw "An unknown pet. Did you buy a rock?";
    }
}

let dog = buyPet(myFavoritePet /* "dog" as defined above */, "Rocky");
// dog is from type Dog (dog: Dog)

// Error: Argument of type '"rock"' is not assignable to parameter of type "'cat' | "dog" | "bird". Type '"rock"' is not assignable to type '"bird"'.
// buyPet("rock", "Rocky");

playWithPet(dog);
// Output: Hey Rocky, let's play.
//         Rocky eats.
//         Rocky walks.
//         Rocky sleeps.

अंतःक्रिया के प्रकार

एक अंतर्ग्रहण प्रकार दो या अधिक प्रकार के सदस्य को जोड़ता है।

interface Knife {
    cut();
}

interface BottleOpener{
    openBottle();
}

interface Screwdriver{
    turnScrew();
}

type SwissArmyKnife = Knife & BottleOpener & Screwdriver;

function use(tool: SwissArmyKnife){
    console.log("I can do anything!");
    
    tool.cut();
    tool.openBottle();
    tool.turnScrew();
}

const Enum

एक कॉन एनम सामान्य एनम के समान है। सिवाय इसके कि कोई वस्तु संकलित समय पर उत्पन्न न हो। इसके बजाय, शाब्दिक मूल्यों को प्रतिस्थापित किया जाता है जहां कॉन्स्ट्यूम एनम का उपयोग किया जाता है।

// Typescript: A const Enum can be defined like a normal Enum (with start value, specifig values, etc.)
const enum NinjaActivity {
    Espionage, 
    Sabotage, 
    Assassination
}

// Javascript: But nothing is generated    

// Typescript: Except if you use it
let myFavoriteNinjaActivity = NinjaActivity.Espionage;
console.log(myFavoritePirateActivity); // 0

// Javascript: Then only the number of the value is compiled into the code
// var myFavoriteNinjaActivity = 0 /* Espionage */;
// console.log(myFavoritePirateActivity); // 0

// Typescript: The same for the other constant example
console.log(NinjaActivity["Sabotage"]); // 1   

// Javascript: Just the number and in a comment the name of the value
// console.log(1 /* "Sabotage" */); // 1

// Typescript: But without the object none runtime access is possible
// Error: A const enum member can only be accessed using a string literal.
// console.log(NinjaActivity[myFavoriteNinjaActivity]);

तुलना के लिए, एक सामान्य एनम

// Typescript: A normal Enum
enum PirateActivity {
    Boarding,
    Drinking, 
    Fencing 
} 

// Javascript: The Enum after the compiling
// var PirateActivity;
// (function (PirateActivity) {
//     PirateActivity[PirateActivity["Boarding"] = 0] = "Boarding";
//     PirateActivity[PirateActivity["Drinking"] = 1] = "Drinking";
//     PirateActivity[PirateActivity["Fencing"] = 2] = "Fencing";
// })(PirateActivity || (PirateActivity = {}));

// Typescript: A normale use of this Enum
let myFavoritePirateActivity = PirateActivity.Boarding;
console.log(myFavoritePirateActivity); // 0

// Javascript: Looks quite similar in Javascript
// var myFavoritePirateActivity = PirateActivity.Boarding;
// console.log(myFavoritePirateActivity); // 0

// Typescript: And some other normale use
console.log(PirateActivity["Drinking"]); // 1

// Javascript: Looks quite similar in Javascript
// console.log(PirateActivity["Drinking"]); // 1

// Typescript: At runtime, you can access an normal enum
console.log(PirateActivity[myFavoritePirateActivity]); // "Boarding"

// Javascript: And it will be resolved at runtime
// console.log(PirateActivity[myFavoritePirateActivity]); // "Boarding"