TypeScript structurally టైప్ చేయబడినందున, UserId మరియు OrderId రెండూ string ఉన్నప్పుడు వాటిని పరస్పరం మార్చుకోవచ్చు — కంపైలర్ వాటిని కలపడం నుండి మిమ్మల్ని ఆపలేరు. బ్రాండెడ్ రకాలు ఒక ప్రత్యేక,幻影 "brand" ని జతచేయడం ద్వారా టైపింగ్ను అనుకరిస్తాయి కాబట్టి ఇతర విధంగా సారూప్య రకాలు విభిన్నమవుతాయి.
// the brand is a property that exists only in the type system, never at runtime
type Brand<T, B> = T & { readonly __brand: B };
type UserId = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
function getUser(id: UserId) { return id; }
const uid = "u1" as UserId;
const oid = "o1" as OrderId;
getUser(uid); // ✅
getUser(oid); // ❌ Error: OrderId is not assignable to UserId
getUser("u1"); // ❌ Error: plain string is not a UserId
__brand ఆస్తి రన్టైమ్లో ఎప్పుడూ ఉనికిలో ఉండదు (విలువ కేవలం స్ట్రింగ్), కానీ టైప్ సిస్టమ్లో ఇది UserId మరియు OrderIdను అసంగతమైనవిగా చేస్తుంది — మిశ్రమ బగ్ల సమ్మిళిత తరగతిని నిరోధిస్తుంది.
function toUserId(s: string): UserId {
if (!s.startsWith("u")) throw new Error("invalid UserId");
return s as UserId; // validation happens here, once
}
సరిహద్దులో ఒకసారి ధృవీకరించండి; మిగిలిన కోడ్ బ్రాండెడ్ రకంపై విశ్వాస్యత కలిగి ఉంటుంది.
IDs (UserId vs OrderId), validated/sanitized strings (Email, SafeHtml), units (Meters vs Feet), PositiveNumber — ఏ స్థానంలోనైనా రెండు విలువలు ఒక primitive రకాన్ని భాగస్వామ్యం చేసుకుంటాయి కానీ గందరగోళానికి గురి కాకూడదు.
బ్రాండెడ్ రకాలు structural టైపింగ్ చాలా ఉదారంగా ఉన్న చోట nominal సుരక్షను కలుపుతాయి.
వాటి argument-order మిశ్రమాలు మరియు "unvalidated vs validated" గందరగోళాన్ని కంపైల్ సమయంలో పట్టుకుంటాయి, సున్నా runtime ఖర్చు లేకుండా — పెద్ద, సరిత్వ-సందర్భమైన codebases లో domain మోడలింగ్ కోసం ఒక శక్తిశాలి నమూనా.