TypeScript வென்றுவிட்டது. அது உண்மையில் நமக்கு எதை பெற்றுத் தந்துள்ளது.

இனி TypeScript பயன்படுத்துவது குறித்து யாரும் விவாதிப்பதில்லை. புதிய திட்டங்கள் (projects) இயல்பாகவே இதைப் பயன்படுத்துகின்றன. விவாதம் முடிந்துவிட்டது.

இதன் உண்மையான மதிப்பு வெறும் எழுத்துப் பிழைகளைக் (typos) கண்டறிவது மட்டுமல்ல. அது அதைவிடப் பல மடங்கு மேலானது.

ஒரு function signature ஆவணமாக (documentation) செயல்படுகிறது. அது ஒருபோதும் காலாவதியாகாது. குறியீடு (code) மாறினால், compiler பில்டைத் (build) தோல்வியடையச் செய்யும்.

இந்த function-ஐப் பாருங்கள்:

function scheduleReminder(
  userId: string,
  at: Date,
  channel: "email" | "push" | "sms",
): Promise<ReminderId>;

இதை எப்படி அழைப்பது (call) என்பது உங்களுக்குத் துல்லியமாகத் தெரியும். இதற்கு என்ன தேவை மற்றும் இது எதைத் திருப்பித் தரும் (returns) என்பதும் உங்களுக்குத் தெரியும். 'channel' என்பது இந்த மூன்று குறிப்பிட்ட சரங்களில் (strings) ஒன்றாகத்தான் இருக்க வேண்டும் என்பதும் உங்களுக்குத் தெரியும்.

நீங்கள் பின்னர் "slack" என்ற விருப்பத்தைச் சேர்த்தால், உங்கள் குறியீட்டின் ஒவ்வொரு பகுதியையும் புதுப்பிக்க compiler உங்களைக் கட்டாயப்படுத்துகிறது. ஆனால் ஒரு கமெண்ட் (comment) காலாவதியாகி உங்களுக்குத் தவறான தகவலைத் தரும்.

வகைப்படுத்தப்படாத குறியீட்டில் (untyped code), ஒரு புலத்தின் (field) பெயரை மாற்றுவது பயமாக இருக்கும். நீங்கள் சரங்களைத் (strings) தேடி, எல்லாம் சரியாக நடக்கும் என்று நம்புவீர்கள். TypeScript-இல், நீங்கள் வகையை (type) மாற்றினால் போதும். எதெல்லாம் உடைந்துவிட்டது என்பதற்கான ஒரு வேலைப் பட்டியலை (to-do list) compiler உங்களுக்கு வழங்கும். இதனால் refactoring செய்வது பாதுகாப்பானதாகிறது.

வகைகள் (Types) AI-க்கும் உதவுகின்றன.

ஒரு AI மாடல் JavaScript-இல் குறியீட்டின் அமைப்பைக் (code shapes) guesswork மூலம் கணிக்க முயல்கிறது. TypeScript-இல், வகை என்பது ஒரு விவரக்குறிப்பு (specification). எதெல்லாம் அனுமதிக்கப்படும் என்பதை AI அறிந்துகொள்ளும். தவறுகள், production crashes ஆக மாறாமல் பிழைகளாகவே (errors) வெளிப்படும்.

வகைகள் பாதுகாப்பு வேலிகளாக (guardrails) செயல்படுகின்றன. ஒவ்வொரு வரியையும் கையால் சரிபார்ப்பதற்குப் பதிலாக, நம்பிக்கையுடன் AI குறியீட்டைப் பயன்படுத்த அவை உங்களை அனுமதிக்கின்றன.

இந்த விதிகளுடன் சிறந்த வகைகளை (types) எழுதுங்கள்:

• பல booleans-களுக்குப் பதிலாக unions-களைப் பயன்படுத்துங்கள். மூன்று தனித்தனி flags-களை விட "loading" | "error" | "ready" போன்ற ஒரு status சிறந்தது. • உங்கள் domain வகைகளுக்குப் பெயரிடுங்கள். நோக்கத்தைக் காட்ட type Cents = number என்பதைப் பயன்படுத்துங்கள். • any-ஐத் தவிர்க்கவும். அதற்குப் பதிலாக unknown-ஐப் பயன்படுத்தி வகையைச் சுருக்கவும் (narrow the type). • inference வேலை செய்ய விடுங்கள். function signatures போன்ற எல்லைகளை மட்டும் குறிக்கவும் (annotate), மற்றவற்றைத் தானாகவே நடக்க விடுங்கள்.

TypeScript குறியீட்டுத் தொகுப்புகளை (codebases) கட்டாயப்படுத்தப்பட்ட ஒப்பந்தங்களின் (enforced contracts) தொகுப்பாக மாற்றியுள்ளது. இந்த ஒப்பந்தங்கள் அச்சமின்றி refactoring செய்யவும் மற்றும் நம்பகமான AI உதவியைப் பெறவும் வழிவகை செய்கின்றன.

பிழைகளைத் தடுக்கவே நாங்கள் வகைகளைப் பயன்படுத்தத் தொடங்கினோம். ஆனால் அவை மற்ற அனைத்திற்கும் அடிப்படையாக இருப்பதால், தொடர்ந்து அவற்றைப் பயன்படுத்துகிறோம்.

Source: https://dev.to/parsajiravand/typescript-won-heres-what-that-actually-bought-us-53lo