TypeScript தயாரிப்பு நிலையை (production) அடைவதற்கு முன்பே முட்டாள்தனமான பிழைகளைக் கண்டறிகிறது. தவறாகப் பெயரிடப்பட்ட property, நீங்கள் மறந்த argument, மற்றும் தவறான வடிவத்தைத் தரும் branch ஆகியவற்றிற்காக அது உங்களைத் தண்டிக்கும். நீங்கள் அதைச் சரிசெய்கிறீர்கள், build வெற்றிகரமாகிறது, பிறகு நீங்கள் அதை வெளியிடுகிறீர்கள். ஆனால் static types-களுக்கு ஒரு வரம்பு உண்டு. Compiler வேலையை முடித்தவுடன், ஒவ்வொரு annotation-உம் நீக்கப்பட்டுவிடும். உங்கள் குறியீட்டை இயக்கும் JavaScript engine-க்கு உங்கள் interfaces, branded types அல்லது நீங்கள் கவனமாக வரையறுத்துள்ள string literals பற்றி எதுவும் தெரியாது. அதற்கு மதிப்புகள் (values) மற்றும் மொழியின் உண்மையான விதிகள் மட்டுமே தெரியும்.

Build வெற்றி பெறுவது என்பது runtime பாதுகாப்பானது என்று அர்த்தமல்ல. Tests வெற்றிகரமாக முடிவது (green) என்பது பயனர்கள் ஒரு நிலையான செயலியைப் பார்ப்பார்கள் என்று அர்த்தமல்ல. உங்கள் புரிதல் TypeScript எல்லைடன் நின்றுவிட்டால், செயலி செயலிழக்கும் (crash) இடத்திலேயே நீங்கள் எதையும் அறியாமல் செயல்படுகிறீர்கள் என்று அர்த்தம்.

Compile-Time மாயை

TypeScript-ன் முழு type system-உம் compilation செய்யும்போது நீக்கப்பட்டுவிடுகிறது. எந்தவொரு திட்டத்தின் (project) compiled JavaScript வெளியீட்டையும் பார்த்தால், அங்கு interface, type, அல்லது generic constraints ஆகியவற்றின் எந்தத் தடயமும் இருக்காது. அவை design-time-க்கான கட்டமைப்புகள் (scaffolding) மட்டுமே. Browser அல்லது Node.js செயல்முறை சாதாரண JavaScript-ஐயே இயக்குகிறது, மேலும் உங்கள் functions வழியாகப் பாயும் மதிப்புகள் நீங்கள் ஆவணப்படுத்திய (declared) types-உடன் ஒத்துப்போகும் என்பதற்கு எந்த உத்தரவாதமும் இல்லை.

இந்த இடைவெளி உங்கள் அமைப்பின் (system) எல்லைகளில் மிக முக்கியமானது. Network responses, பயனர் உள்ளீடு (user input) மற்றும் மூன்றாம் தரப்பு நூலகங்கள் (third-party libraries) உங்கள் types-களை மீறும் மதிப்புகளை உள்ளே அனுப்பலாம். நீங்கள் strictEmail: string என்று அறிவித்த ஒரு variable, நம்பகத்தன்மையற்ற API மூலம் தவறான தரவு வந்தால், runtime-ல் ஒரு எண்ணாக (number) இருக்கலாம். எதையும் கட்டாயப்படுத்த (enforce) TypeScript உங்கள் குறியீட்டைத் தயாரிப்பு நிலைக்கு (production) பின்தொடர முடியாது. Runtime முற்றிலும் மாறுபட்ட ஒரு தளத்தில் இயங்குகிறது, இந்த இரண்டு தளங்களையும் ஒன்றாகக் கருதுவது static analysis-ஆல் கண்டறிய முடியாத தோல்விகளுக்கு வழிவகுக்கும்.

எண்கள் உங்களை ஏமாற்றும்போது

TypeScript ஒரு number-ஐப் பார்க்கிறது. JavaScript engine ஒரு IEEE 754 double-precision float-ஐப் பார்க்கிறது. இந்த வேறுபாடு பேரழிவை ஏற்படுத்தும் வரை பாதிப்பற்றதாகத் தோன்றலாம்.

JavaScript ஒவ்வொரு எண்ணிற்கும் 64 bits ஒதுக்குகிறது, ஆனால் 53 bits மட்டுமே mantissa-வைச் சேமிக்கின்றன. இது 9,007,199,254,740,991 என்ற பாதுகாப்பான முழு எண் உச்சவரம்பை (safe integer ceiling) உருவாக்குகிறது. இதை விடப் பெரிய எண்கள் அருகிலுள்ள மதிப்பாக மாற்றப்படும் (rounded). நடைமுறையில், முற்றிலும் மாறுபட்ட இரண்டு அடையாளங்கள் (identifiers) உங்கள் பயன்பாட்டிற்குள் ஒரே மதிப்பாக மாறக்கூடும்.

Snowflake IDs மற்றும் பிற distributed 64-bit integer அடையாளங்கள் வழக்கமாக அந்த வரம்பைத் தாண்டிவிடுகின்றன. சிறிய பணப் பிரிவுகளில் அதிக மதிப்புள்ள தொகைகளைக் கண்காணிக்கும் நிதி அமைப்புகளும் (financial systems) இதை நெருங்கலாம். உங்கள் business logic இயங்குவதற்கு முன்பே ஆபத்து பெரும்பாலும் தோன்றிவிடும்: JSON.parse ஒரு payload-ல் உள்ள numeric literals-களை JavaScript numbers-களாக மாற்றுகிறது, இதனால் தரவு வந்தவுடனேயே துல்லியம் (precision) மௌனமாகத் துண்டிக்கப்படுகிறது. உங்கள் type definition id: number என்று உறுதியளிக்கலாம், ஆனால் முதல் function call-க்கு முன்பே runtime மதிப்பு சிதைந்துவிடுகிறது.

இதற்கான தீர்வு எளிமையானது, ஆனால் உங்கள் stack முழுவதும் ஒழுக்கத்தைக் கோருகிறது. Network transport-ன் போது பெரிய அடையாளங்களை strings-களாக வைத்திருங்கள். உங்கள் JSON schemas மற்றும் API contracts-களில், இந்தத் புலங்களை (fields) எண்களாக அல்லாமல் strings-களாக வரையறுக்கவும். பாதுகாப்பான வரம்பைத் தாண்டிய மதிப்புகளுக்கு நீங்கள் கணிதச் செயல்பாடுகளைச் செய்ய வேண்டுமென்றால், BigInt-ஐப் பயன்படுத்தவும். ஆனால் கவனமாக இருங்கள்: BigInt சாதாரண JavaScript numbers-களுடன் தானாகக் கலக்காது, மேலும் நீங்கள் அதைத் தெளிவாக மீண்டும் string-ஆக மாற்றாதவரை, JSON.stringify ஒரு பிழையைத் தராமல் BigInt-ஐ serialize செய்ய முடியாது. அடையாளங்களை (IDs) இயல்பாகவே opaque tokens-களாகக் கருதுங்கள். உண்மையில் தேவைப்படும் ஒரு தனிமைப்படுத்தப்பட்ட கணக்கீட்டுத் தொகுதியில் (isolated calculation module) இருக்கும்போது மட்டுமே அவற்றை numeric வடிவத்திற்கு மாற்றவும்