TypeScript og konvertering av datatyper: En dyptgående analyse
JavaScript ble opprinnelig utviklet for å legge til små kodebiter på nettsider. Ingen forutså den enorme populariteten og bruken av JavaScript for å skape komplekse applikasjoner med mange tusen linjer kode.
Selv om JavaScript har vokst enormt og er utbredt for å utvikle applikasjoner, er det ikke et feilfritt språk. Språkets enkle start og opprinnelige tiltenkte bruk har ført til noen særegenheter som kan gjøre utviklingen av store applikasjoner utfordrende.
For eksempel vil ikke JavaScript generere en feilmelding når du refererer til elementer som ikke finnes i et objekt, eller når du multipliserer null med en numerisk verdi.
I JavaScript vil en tom streng («») betraktes som lik 0 (null) ved sammenligning med en likhetsoperator (==). Det som er verre, er at JavaScript ikke vil vise slike feil i koden din under utviklingsfasen. Du vil bare oppdage disse problemene når du kjører programmet.
TypeScript, som er bygget oppå JavaScript, ble utviklet for å adressere utfordringene som oppstår når man utvikler applikasjoner med JavaScript. For å oppnå dette utfører TypeScript statisk typekontroll mens du skriver koden.
Statisk kontroll innebærer å identifisere feil i koden uten at du trenger å kjøre den. Statisk typekontroll innebærer å sjekke for feil under utvikling basert på datatypene som opereres på i koden.
TypeScript er et «strongly typed» supersett av JavaScript. Å være et supersett av JavaScript betyr at all gyldig JavaScript-kode også er gyldig TypeScript. «Strongly typed» betyr at TypeScript legger til regler for hvordan ulike datatyper kan brukes. TypeScript er også «strongly typed», og du kan ikke omgå begrensningene som håndheves av typesystemet.
TypeScript er en stor milepæl og en betydelig utvikling innen webutvikling. TypeScript gjør det mulig å skrive mer lesbar kode som er lettere å vedlikeholde. Det fremmer også god kodepraksis og hjelper utviklere med å fange opp og unngå feil mens de skriver kode.
TypeScript er mer pålitelig og enklere å refaktorere, noe som gjør det ideelt for å utvikle store applikasjoner sammenlignet med JavaScript. Nå som vi har fastslått at TypeScript er «strongly typed», la oss se på typekonvertering, dens betydning og hvordan TypeScript håndterer typekonverteringer.
Typekonvertering i TypeScript og dens betydning
Typekonvertering er prosessen med å overføre en verdi fra én datatype til en annen, for eksempel å endre en strengverdi til et tall. Typekonvertering kan være implisitt, hvor kompilatoren automatisk konverterer kompatible datatyper under kompileringen.
Typekonvertering kan også være eksplisitt, hvor typekonverteringen er uttrykkelig angitt i kildekoden. Dette blir ofte referert til som «typecasting».
Typekonvertering er viktig fordi det gjør at utviklere kan jobbe med forskjellige dataformater samtidig som de overholder de forventede datatypene i TypeScript. Det bidrar også til å sikre forutsigbare resultater fra kildekoder.
Som utvikler hjelper typecasting deg selv med å sikre at koden din oppfyller typekravene til TypeScript. Det gjør koden din mer lesbar og forståelig og bidrar til å forhindre typerelaterte feil.
Typekonverteringer bidrar også til å støtte datavalidering, og det gjør det lettere for TypeScript å hjelpe deg i utviklingen ved å tilby alle de innebygde verktøyene, som autofullføring, som er knyttet til bestemte typer.
Et vanlig bruksområde for typekonvertering er med strenger og tall. Når du konverterer strenger til tall i TypeScript, bør du bare konvertere numeriske strenger til tall for å unngå feil i koden. Det vil si at du kan konvertere strenger som «1», «235», «5234.5» osv., men ikke strenger som «hei» til et tall.
La oss se på de forskjellige måtene å konvertere strenger til tall i TypeScript:
Typepåstand med «as»
Når du jobber med ulike datatyper i TypeScript-koden din, vil du av og til ha mer informasjon om typen verdi som TypeScript ikke kan vite om. I slike tilfeller forteller du TypeScript hvilken type en variabel vil være, og lar ikke kompilatoren utlede typen. Dette kalles typepåstand.
Typepåstand gjøres ved å bruke nøkkelordet «as». For å bruke typepåstand til å konvertere en streng til et tall, setter du først typen strengen til «unknown». Dette er fordi TypeScript som standard anser enhver konvertering av typestreng til et tall som potensielt en feil. Dette er fordi verken streng eller tall i tilstrekkelig grad overlapper den andre. For å konvertere en streng til et tall, gjør du som vist nedenfor:
/** * Setter typen til numString til ukjent, ellers vil * Typescript utlede at numString er en strengverdi */ let numString: unknown = "23452"; // Typekonvertering med "as" - numString konverteres til et tall // og tilordnes variabelen score let score = numString as number; console.log(score); console.log(score * 35);
Resultat:
23452 820820
Fra resultatet kan vi se at variabelen «numString» ble konvertert til et tall og tildelt «score». Vi kan deretter utføre numeriske beregninger som multiplikasjon med «score» fordi verdien nå er et tall.
Typepåstand med <>
Typepåstand med <> kan også brukes til å konvertere en streng til et tall. Det fungerer på samme måte som å bruke nøkkelordet «as». Den eneste forskjellen i implementeringen er syntaksen, som er vist nedenfor:
let numString: unknown = "23452"; // Typepåstand med <> for å konvertere en streng til et tall let score = <number>numString; console.log(score); console.log(score * 35);
Resultat:
23452 820820
Resultatet er det samme som ved bruk av nøkkelordet «as». Igjen, husk å ikke bruke typepåstand for å konvertere strenger som ikke har numeriske verdier.
Bruke Number-konstruktøren
For å konvertere en streng til et tall ved å bruke Number-konstruktøren, sender du inn strengen du vil konvertere til Number-konstruktøren, som vist i kodebiten nedenfor:
let numString = "23452"; // type utledet til streng let lives: string = "20"; // type kommentert til streng // sender inn streng til Number-konstruktøren for å konvertere til tall let score = Number(numString) console.log(score / 17) // sender inn streng til Number-konstruktøren for å konvertere til tall let remainingLives = Number(lives); console.log(remainingLives - 4)
Resultat:
1379.5294117647059 16
Når du bruker Number-konstruktøren, trenger du ikke å sette typen streng til ukjent. Det fungerer med strengverdier som har blitt kommentert eller utledet til streng. Husk imidlertid å sende inn numeriske strenger som «514». Hvis du sender inn en streng som ikke kan konverteres til et tall, vil NaN (Not-a-Number) bli returnert.
Bruke unary pluss (+)-operatoren
Unary pluss (+)-operatoren, som plasseres foran sin enkeltoperand, evalueres til operanden den plasseres foran. For eksempel vil +2 evalueres til tallet 2, +542 evalueres til tallet 542, og så videre. Men hvis operanden ikke er et tall, prøver unary pluss (+)-operatoren å konvertere den til et tall.
For eksempel vil +»98″ evaluere til 98, og +»0″ vil evaluere til tallet 0. Derfor kan vi bruke unary pluss (+)-operatoren til å konvertere strenger til tall. Hvis du sender inn en streng som ikke kan konverteres til et tall, vil NaN bli returnert, som vist nedenfor:
let numString1 = "23452";
let numString2 = "973.82"
let word = "hello"
// Bruker unary pluss (+) for å konvertere strenger til tall
let num1 = +numString1;
let num2 = +numString2;
let notNumber = +word;
console.log(`${num1} er en ${typeof num1}`);
console.log(`${num2} er en ${typeof num2}`);
console.log(notNumber);
Resultat:
23452 er en number 973.82 er en number NaN
Å bruke unary pluss (+)-operatoren er en god måte å konvertere strenger til tall på, siden den er rask og ikke utfører noen ekstra operasjoner på operandene.
Bruke parseInt() og parseFloat()
Akkurat som i JavaScript, skiller ikke TypeScript mellom heltall og desimaltall, også kjent som flyttall. Alle anses å være av typen «number». Når det er sagt, er oppførselen til `parseInt()` og `parseFloat()` litt forskjellig.
`parseInt()` tar et strengargument, analyserer det og returnerer et heltallsekvivalent i henhold til den angitte radiksen. `parseFloat()` tar inn en streng, analyserer den og returnerer et flyttall.
For eksempel, hvis du sender inn «897» til både `parseInt()` og `parseFloat()`, vil du få tilbake tallet 897. Men hvis du sender inn 897.75 til både `parseInt()` og `parseFloat()`, vil `parseInt()` returnere 897 mens `parseFloat()` vil returnere 897.75.
Derfor, når du konverterer numeriske strenger som ikke har et desimaltegn, bruk `parseInt()`, men hvis den numeriske strengen har desimaltegn, bruk `parseFloat()`, som vist i koden nedenfor:
let numString1 = "897.75";
let numString2 = "724";
let word = "hello";
console.log("Analyserer numeriske strenger med desimaltall")
console.log(`Bruker parseInt -> ${parseInt(numString1)}`);
console.log(`Bruker parseFloat -> ${parseFloat(numString1)}`);
console.log("Analyserer numeriske strenger med hele tall")
console.log(`Bruker parseInt -> ${parseInt(numString2)}`);
console.log(`Bruker parseFloat -> ${parseFloat(numString2)}`);
console.log("Analyserer strenger som ikke kan konverteres til tall")
console.log(parseInt(word));
console.log(parseFloat(word));
Resultat:
Analyserer numeriske strenger med desimaltall Bruker parseInt -> 897 Bruker parseFloat -> 897.75 Analyserer numeriske strenger med hele tall Bruker parseInt -> 724 Bruker parseFloat -> 724 Analyserer strenger som ikke kan konverteres til tall NaN NaN
Konklusjon
Når du jobber med strengverdier, for eksempel resultatet av API-kall, kan det hende du må konvertere dem til tall slik at du kan utføre numeriske beregninger på dem. Når et slikt behov oppstår, bør du vurdere metodene som er beskrevet i artikkelen for å konvertere strenger til tall.
Men vær forsiktig når du konverterer strenger til tall, fordi du kan få NaN når du prøver å konvertere en ikke-numerisk streng til et tall.
For å unngå en slik feil, sørg for at alle strengene du vil konvertere til tall, faktisk er numeriske strenger. Du kan også bruke en «if»-setning for å sjekke etter NaN for å unngå feil i koden.
Du kan også utforske de beste TypeScript-bibliotekene og runtime-miljøene for å utvikle kunnskapen din.