ఈ రెండు ఆపరేటర్లు ఇప్పటికే ఉన్న టైప్ల నుండి మరియు విలువల నుండి టైప్లను పొందటానికి అనుమతిస్తాయి — ఇది టైప్-లెవెల్ ప్రోగ్రామింగ్ యొక్క ఆధారం.
keyof — ఒక ఆబ్జెక్ట్ టైప్ కీల యూనియన్
ts
interface User { id: number; name: ; }
= keyof ;
ఈ రెండు ఆపరేటర్లు ఇప్పటికే ఉన్న టైప్ల నుండి మరియు విలువల నుండి టైప్లను పొందటానికి అనుమతిస్తాయి — ఇది టైప్-లెవెల్ ప్రోగ్రామింగ్ యొక్క ఆధారం.
interface User { id: number; name: ; }
= keyof ;
const config = { host: "localhost", port: 3000 };
type Config = typeof config; // { host: string; port: number }
typeof (టైప్ పొజిషన్లో) ఒక runtime విలువ యొక్క ఇన్ఫర్డ్ టైప్ను క్యాప్చర్ చేస్తుంది, కాబట్టి మీరు టైప్ను విడిగా రాయవలసిన అవసరం లేదు.
function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const user = { id: 1, name: "Ann" };
getProp(user, "name"); // returns string
getProp(user, "age"); // ❌ Error: "age" is not a key of user
ఇక్కడ K extends keyof T key ను నిజమైన కీలకు పరిమితం చేస్తుంది, మరియు T[K] (ఒక indexed access type) ఆ కీ కోసం ఖచ్చితమైన విలువ టైప్ను తిరిగి ఇస్తుంది. అక్షర దోషాలు కంపైల్ ఎర్రర్ల్గా మారుతాయి.
const Roles = { Admin: "admin", User: "user" } as const;
type Role = typeof Roles[keyof typeof Roles]; // "admin" | "user"
keyof మరియు typeof విలువ ప్రపంచం మరియు టైప్ ప్రపంచాన్ని సংযుక్తం చేస్తాయి.
వారు టైప్-సేఫ్ ప్రాపర్టీ యాక్సెస్, config/constants నుండి టైప్లను పొందడం (సింగిల్ సోర్స్ ఆఫ్ ట్రూత్), మరియు mapped మరియు conditional types కోసం నిర్మాణ సూత్రాలను శక్తిసంపన్నం చేస్తాయి.
ఇవి సమాంతర టైప్ నిర్వచనాలను హస్తపూర్వకంగా నిర్వహించకుండా ఉండటానికి ఎలా.