Type inference என்பது TypeScript சூழ்நிலையிலிருந்து சரியாக வகைகளை தீர்மானிக்கிறது, எனவே நீங்கள் எல்லாவற்றையும்주석 செய்ய தேவையில்லை. இது ஆரம்ப மதிப்புகள், return அறிக்கைகள் மற்றும் பயன்பாட்டிலிருந்து தீர்மானிக்கிறது.
x = ;
s = ;
arr = [, ];
obj = { : , : };
function double(n: number) { return n * 2; } // return inferred as number
[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
இந்த contextual typing callbacks வெகுவாக parameter annotations தேவைப்படாத காரணம் — TypeScript number[] மீது map ஒரு number கடிக்கிறது என்று அறியும்.
let a = "hello"; // widened to string (let can be reassigned)
const b = "hello"; // narrowed to the literal type "hello"
const literal வகையை தீர்மானிக்கிறது ஏனெனில் இது ஒருபோதும் மாற முடியாது; let பொதுவான வகைக்கு விரிவுபடுத்துகிறது. இது unions க்கு முக்கியமாகும்:
const dir = "up"; // type "up"
let dir2 = "up"; // type string
string விரும்புகிறீர்கள் literal அல்ல).const xs = [] any[] தீர்மானிக்கிறது — number[] என annotate செய்யுங்கள்.Inference TypeScript code ஐ JavaScript ஐப்போல் எளிமையாக வைத்திருந்து, முழுவதுமாக typed ஆக இருக்க வைக்கிறது.
এটি எப்போது செயல்படுகிறது (மற்றும் எப்போது விரிவுபடுகிறது) என்பதைப் புரிந்துகொள்ள, நீங்கள் உண்மையில் உதவும் இடங்களில் மட்டுமே annotation செய்ய முடியும்.
விரிவான பதில்களுடன் கூடிய IT நேர்காணல் கேள்விகளின் நூலகம் — Junior முதல் Senior வரை.
நன்கொடை