మాడ్యూల్ 6 · 2లో పాఠం 2కోర్సులో 12/14~15 min

మాడ్యూల్ పాఠాలు (2/2)

మ్యాప్ చేయబడిన రకాలు

మ్యాప్ చేయబడిన రకాలు ఇప్పటికే ఉన్న వాటి లక్షణాలను ఒక్కొక్కటిగా మార్చడం ద్వారా కొత్త రకాలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి. అవి keyof ఆపరేటర్‌ని ఉపయోగించి కీలపై లూప్ సింటాక్స్ పైన నిర్మించబడ్డాయి.

type Mapped<T> = {
  [P in keyof T]: T[P];
};

ఈ ఉదాహరణ అసలైన దానికి సమానమైన మ్యాప్ చేయబడిన రకాన్ని చూపుతుంది: ఇది keyof Tలో P ప్రతి కీపై మళ్ళిస్తుంది మరియు అదే రకాన్ని T[P]ని కేటాయించింది.

మ్యుటబిలిటీ మరియు ఆప్షనల్ మాడిఫైయర్స్

మేము readonly మరియు ? (ఐచ్ఛికం) వంటి మాడిఫైయర్‌లను + (జోడించు, డిఫాల్ట్) లేదా - (తొలగించు)తో జోడించవచ్చు లేదా తీసివేయవచ్చు.

ఉదాహరణకు, ఒక రకమైన అన్ని లక్షణాల నుండి ఐచ్ఛికతను తీసివేయడానికి (వాటిని అవసరం చేయడం):

type Concrete<T> = {
  [P in keyof T]-?: T[P];
};

-? మాడిఫైయర్ ప్రతి ప్రాపర్టీ నుండి ఐచ్ఛిక ఫ్లాగ్‌ను తీసివేస్తుంది.

`as`తో కీ రీమాపింగ్

టైప్‌స్క్రిప్ట్ 4.1+లో, మీరు as నిబంధన మరియు టెంప్లేట్ లిటరల్ రకాలను ఉపయోగించి మ్యాప్ చేసిన రకంలో కీలను రీమాప్ చేయవచ్చు.

type WriteSetters<T> = {
  [K in keyof T as `set${Capitalize<string & K>}`]: (value: T[K]) => void;
};

ఇక్కడ మేము ప్రతి ప్రాపర్టీ పేరును Kకి set[CapitalizedKey]కి మారుస్తున్నాము మరియు దాని రకాన్ని సెట్టర్ ఫంక్షన్‌కి మారుస్తున్నాము.

మీరే ప్రయత్నించండి

వ్యాయామం 1: లక్షణాలను రద్దు చేయడం

వ్యాయామం#ts.m6.l2.e1

ప్రయత్నాలు: 0లోడ్ అవుతోంది...

ఆబ్జెక్ట్ Tని తీసుకుని, ప్రతి ప్రాపర్టీని రూపాంతరం చేసే జెనరిక్ మ్యాప్ చేయబడిన రకం Nullable<T>ని ప్రకటించండి, తద్వారా అది విలువ శూన్యతను కూడా అంగీకరించగలదు (ఉదా. T[K] | శూన్యం).

ఎడిటర్ లోడ్ అవుతోంది…

సూచనను చూపించు

సింటాక్స్‌ని ఉపయోగించండి [కీ ఆఫ్ T]: T[K] | శూన్యం; మ్యాప్ చేయబడిన రకం వస్తువు లోపల.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం 2: `as`తో డైనమిక్ గెటర్‌లను రూపొందించడం

వ్యాయామం#ts.m6.l2.e2