चूँकि प्रकार रन-टाइम में अज्ञात है, इसलिए मैंने अज्ञात ऑब्जेक्ट की तुलना करने के लिए कोड इस प्रकार लिखा था, न कि किसी प्रकार के विरुद्ध, लेकिन ज्ञात प्रकार की वस्तु के विरुद्ध:
- सही प्रकार का एक नमूना ऑब्जेक्ट बनाएं
- निर्दिष्ट करें कि इसके कौन से तत्व वैकल्पिक हैं
- इस नमूना वस्तु के खिलाफ अपनी अज्ञात वस्तु की गहरी तुलना करें
यहाँ मैं (इंटरफ़ेस-अज्ञेयवादी) कोड का उपयोग करता हूँ जिसकी गहरी तुलना की जाती है:
function assertTypeT<T>(loaded: any, wanted: T, optional?: Set<string>): T {
// this is called recursively to compare each element
function assertType(found: any, wanted: any, keyNames?: string): void {
if (typeof wanted !== typeof found) {
throw new Error(`assertType expected ${typeof wanted} but found ${typeof found}`);
}
switch (typeof wanted) {
case "boolean":
case "number":
case "string":
return; // primitive value type -- done checking
case "object":
break; // more to check
case "undefined":
case "symbol":
case "function":
default:
throw new Error(`assertType does not support ${typeof wanted}`);
}
if (Array.isArray(wanted)) {
if (!Array.isArray(found)) {
throw new Error(`assertType expected an array but found ${found}`);
}
if (wanted.length === 1) {
// assume we want a homogenous array with all elements the same type
for (const element of found) {
assertType(element, wanted[0]);
}
} else {
// assume we want a tuple
if (found.length !== wanted.length) {
throw new Error(
`assertType expected tuple length ${wanted.length} found ${found.length}`);
}
for (let i = 0; i < wanted.length; ++i) {
assertType(found[i], wanted[i]);
}
}
return;
}
for (const key in wanted) {
const expectedKey = keyNames ? keyNames + "." + key : key;
if (typeof found[key] === 'undefined') {
if (!optional || !optional.has(expectedKey)) {
throw new Error(`assertType expected key ${expectedKey}`);
}
} else {
assertType(found[key], wanted[key], expectedKey);
}
}
}
assertType(loaded, wanted);
return loaded as T;
}
नीचे एक उदाहरण है कि मैं इसका उपयोग कैसे करता हूं।
इस उदाहरण में, मुझे उम्मीद है कि JSON में टुपल्स की एक सरणी है, जिनमें से दूसरा तत्व एक इंटरफ़ेस का एक उदाहरण है User (जिसे दो वैकल्पिक तत्व हैं)।
टाइपस्क्रिप्ट की टाइप-चेकिंग यह सुनिश्चित करेगी कि मेरा नमूना ऑब्जेक्ट सही है, फिर assertTypeT फ़ंक्शन जाँचता है कि अज्ञात (JSON से लोड) ऑब्जेक्ट नमूना ऑब्जेक्ट से मेल खाता है।
export function loadUsers(): Map<number, User> {
const found = require("./users.json");
const sample: [number, User] = [
49942,
{
"name": "ChrisW",
"email": "example@example.com",
"gravatarHash": "75bfdecf63c3495489123fe9c0b833e1",
"profile": {
"location": "Normandy",
"aboutMe": "I wrote this!\n\nFurther details are to be supplied ..."
},
"favourites": []
}
];
const optional: Set<string> = new Set<string>(["profile.aboutMe", "profile.location"]);
const loaded: [number, User][] = assertTypeT(found, [sample], optional);
return new Map<number, User>(loaded);
}
आप उपयोगकर्ता-परिभाषित प्रकार के गार्ड के कार्यान्वयन में इस तरह से एक चेक लगा सकते हैं।