TypeScript గెలిచింది. దీనివల్ల మనకు ఏమి లభించింది.
ఇకపై TypeScript వాడకం గురించి ఎవరూ వాదించరు. కొత్త ఫ్రంటెండ్ ప్రాజెక్ట్లు డిఫాల్ట్గా దీనినే ఉపయోగిస్తున్నాయి. చర్చ ముగిసింది. TypeScript గెలిచింది.
గెలవడం అనేది ఒక సాధారణ విషయం. అసలైన విలువ మీ వర్క్ఫ్లోలో types చేసే పనిలో ఉంది. ఇది కేవలం టైపోలను (typos) పట్టుకోవడం మాత్రమే కాదు.
ఒక function signature డాక్యుమెంటేషన్లా పనిచేస్తుంది. అది ఎప్పటికీ పాతబడదు (stale). కోడ్ మారితే, కంపైలర్ వెంటనే బిల్డ్ను ఫెయిల్ చేస్తుంది.
ఒక రిమైండర్ను షెడ్యూల్ చేసే ఫంక్షన్ను చూడండి. ఒక్క కామెంట్ చదవకుండానే దానికి ఏమి కావాలి మరియు అది ఏమి రిటర్న్ చేస్తుంది అనేది మీకు తెలుస్తుంది. కమ్యూనికేషన్ ఛానెల్కు సంబంధించిన ఖచ్చితమైన ఆప్షన్లు మీకు కనిపిస్తాయి. మీరు ఒక కొత్త ఛానెల్ని జోడిస్తే, మీ కోడ్ను ఎక్కడెక్కడ అప్డేట్ చేయాలో కంపైలర్ మీకు చెబుతుంది. కానీ ఒక కామెంట్ మాత్రం అక్కడే ఉండిపోయి, తప్పుగా మారిపోతుంది.
Refactoring సురక్షితంగా మారుతుంది. టైప్ లేని కోడ్లో, ఒక ఫీల్డ్ను రీనేమ్ చేయడం భయంకరంగా ఉంటుంది. మీరు స్ట్రింగ్స్ కోసం వెతికి, అంతా బాగుంటుందని ఆశిస్తారు. TypeScriptలో, మీరు కేవలం టైప్ను మారుస్తారు. దీనివల్ల ఏయే అంశాలు దెబ్బతిన్నాయో కంపైలర్ మీకు జాబితాను ఇస్తుంది. Refactoring అనేది రిస్క్గా ఉండదు, అది ఒక సురక్షితమైన పనిగా మారుతుంది.
Types AIని ఉపయోగించడంలో కూడా మీకు సహాయపడతాయి.
మీరు టైప్ లేని JavaScriptని ఎడిట్ చేయమని AIని అడిగినప్పుడు, అది ఆబ్జెక్ట్ ఆకారాన్ని (object shape) ఊహిస్తుంది. మీరు TypeScriptని ఉపయోగించినప్పుడు, type అనేది ఒక specification లాగా పనిచేస్తుంది. ఏది అనుమతించబడుతుందో AIకి ఖచ్చితంగా తెలుస్తుంది. ఎర్రర్లు production crashesగా కాకుండా, compile errorsగా కనిపిస్తాయి. Types జనరేట్ చేయబడిన కోడ్ను సరిగ్గా సరిపోయే కోడ్గా మారుస్తాయి.
Types మీ పనిని నెమ్మదిస్తాయని ప్రజలు అనేవారు. కానీ AI వర్క్ఫ్లోలో, types మీ పనిని వేగవంతం చేస్తాయి. అవి guardrails లాగా పనిచేస్తాయి. ప్రతి లైన్ను మాన్యువల్గా తనిఖీ చేయనవసరం లేకుండా, మీరు జనరేట్ చేయబడిన కోడ్ను నమ్మకంతో స్వీకరించవచ్చు.
ఈ నియమాలతో మెరుగైన types రాయండి:
- బహుళ booleansకు బదులుగా unions ఉపయోగించండి. మూడు వేర్వేరు flags కంటే "loading" | "error" | "ready" వంటి status మెరుగ్గా ఉంటుంది.
- మీ domain typesకు పేర్లు పెట్టండి. సాధారణ numberకు బదులుగా Cents వంటి typeను ఉపయోగించడం మీ ఉద్దేశాన్ని తెలియజేస్తుంది.
anyని నివారించండి.unknownని ఉపయోగించి దానిని narrow చేయండి.anyకీవర్డ్ మీ safety netను నాశనం చేస్తుంది.- inference పని చేయనివ్వండి. ప్రతిదానికీ annotate చేయకండి. మీ boundariesలను మాత్రమే annotate చేయండి, మిగిలినవి దానంతట అవే సాగునివ్వండి.
TypeScript కోడ్బేస్లను స్పష్టమైన contractsగా మార్చింది. ఈ contracts భయం లేకుండా refactoring చేయడానికి మరియు నమ్మదగిన AI సహాయం పొందడానికి వీలు కల్పిస్తాయి.
బగ్స్ను ఆపడానికి మేము typesను ఉపయోగించడం ప్రారంభించాము. అవి మిగిలినవన్నీ నిర్మించడానికి పునాది కాబట్టి, మేము వాటిని నిరంతరం ఉపయోగిస్తున్నాము.
Source: https://dev.to/parsajiravand/typescript-won-heres-what-that-actually-bought-us-53lo
Optional learning community: https://t.me/GyaanSetuAi