JavaScript var ment for å skrive korte kodebiter på bare noen få linjer som skulle bygges inn i nettsider. Ingen kunne forutse at JavaScript ble så populært som det er nå, eller at det ble brukt til å skrive applikasjoner med tusenvis av kodelinjer.
Så mye som JavaScript har vokst og nå er mye brukt i å bygge applikasjoner, er det ikke et perfekt språk. Den ydmyke begynnelsen og den opprinnelige tiltenkte bruken betyr at JavaScript har noen særheter som kan gjøre det å bygge store applikasjoner til et mareritt.
JavaScript vil for eksempel ikke gi en feil når du refererer til elementer som ikke finnes i et objekt eller når du multipliserer null med en numerisk verdi.
For JavaScript er en tom streng(“”) lik 0(null) når de to sammenlignes med en likhetsoperator(==). Enda verre, JavaScript vil ikke vise deg slike feil i koden din under utvikling. Du vil bare se feilene når du kjører programmet.
TypeScript, bygget på toppen av JavaScript, ble dermed utviklet for å lindre utfordringene som oppstår når man bygger applikasjoner med JavaScript. For å oppnå dette utfører TypeScript statisk typekontroll mens du skriver koden.
Statisk kontroll betyr å oppdage feil i koden din uten at du trenger å kjøre koden. Statisk typekontroll er altså å sjekke for feil under utvikling basert på typen verdier som opereres på i koden.
TypeScript er et maskinskrevet supersett av JavaScript. Å være et supersett av JavaScript betyr at enhver gyldig JavaScript-kode også er gyldig TypeScript. Å bli skrevet betyr at TypeScript legger til regler for hvordan ulike datatyper kan brukes. TypeScript er også sterkt skrevet, og du kan ikke omgå begrensningene som håndheves av typesystemet.
TypeScript er en stor milepæl og en betydelig utvikling innen webutvikling. TypeScript lar deg skrive mer lesbar kode som er enkel å vedlikeholde. Det håndhever også god kodingspraksis, og det hjelper utviklere med å fange opp og unngå feil når de skriver kode.
TypeScript er mer pålitelig og lett å refaktorisere, noe som gjør det ideelt for å bygge store applikasjoner sammenlignet med JavaScript. Når TypeScript er sterkt skrevet, la oss se på typekonvertering, dens betydning og hvordan TypeScript håndterer typekonverteringer.
Innholdsfortegnelse
Typekonvertering i TypeScript og dens betydning
Typekonvertering er prosessen med å konvertere en verdi fra én datatype til en annen, for eksempel å konvertere en strengverdi til et tall. Typekonvertering kan gjøres implisitt, der kompilatoren automatisk konverterer kompatible datatyper under komplikasjoner.
Typekonvertering kan også være eksplisitt, der typekonverteringen er eksplisitt påkrevd i kildekoden. Dette blir ofte referert til som typecasting.
Typekonvertering er viktig fordi den lar utviklere jobbe med forskjellige dataformater mens de fortsatt samsvarer med de forventede datatypene i TypeScript. Det bidrar også til å sikre forutsigbare utfall fra kildekoder.
Som utvikler hjelper casting av typene deg selv med å sikre at koden fortsatt oppfyller typekravene til TypeScript. Det gjør koden din mer lesbar og forståelig og bidrar til å forhindre typerelaterte feil.
Typekonverteringer hjelper også med å støtte datavalideringer, og det hjelper TypeScript til å hjelpe deg i utviklingen ved å tilby alle de innebygde verktøyene, for eksempel 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, konverterer du bare numeriske strenger til tall for å unngå feil i koden din. Det vil si at du kan konvertere strenger som «1», «235», «5234.5» og så videre. Ikke konverter strenger som «hei» til et tall
La oss se på de forskjellige måtene å konvertere strenger til tall i TypeScript:
Skriv påstand med «som»
Når du arbeider med ulike datatyper i TypeScript-koden din, vil du til tider 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 søkeordet as. For å bruke typepåstand til å konvertere en streng til et tall, sett først typen av strengen til ukjent. 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, fortsett som vist nedenfor:
/** * set the type of numString to be unkown, otherwise, * Typescript will infer numString to be a string value */ let numString: unknown = "23452"; // Type conversion using as - numString is converted to a number // and assigned to the variable score let score = numString as number; console.log(score); console.log(score * 35);
Produksjon:
23452 820820
Fra utdata, legg merke til at variabelen numString ble konvertert til et tall og tildelt poengsum. Vi kan da gjøre numeriske beregninger som multiplikasjon med poengsum fordi verdien er et tall
Skriv påstand ved å bruke <>
Typepåstand med <> kan også brukes til å konvertere en streng til et tall. Det fungerer akkurat som å bruke som nøkkelord. Den eneste forskjellen i implementeringen er syntaksen, som er vist nedenfor:
let numString: unknown = "23452"; // Type assertion using <> to convert a string to a number let score = <number>numString; console.log(score); console.log(score * 35);
Produksjon:
23452 820820
Utgangen er den samme som å bruke søkeordet as. Igjen, husk å ikke bruke typepåstand for å konvertere strenger som ikke har numeriske verdier.
Bruke tallkonstruktøren
For å konvertere en streng til et tall ved å bruke tallkonstruktøren, passerer du strengen du vil konvertere til tallkonstruktøren som vist i kodebiten nedenfor:
let numString = "23452"; // type inferred to string let lives: string = "20"; // type annotated to string // pass in string to Number constructor to convert to number let score = Number(numString) console.log(score / 17) // pass in string to Number constructor to convert to number let remainingLives = Number(lives); console.log(remainingLives - 4)
Produksjon:
1379.5294117647059 16
Når du bruker tallkonstruktøren, trenger du ikke sette typen streng til ukjent. Det fungerer med strengverdier som har blitt kommentert eller utledet til streng. Husk imidlertid å gi 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 går foran sin enkeltoperand, evalueres til operanden den går foran. For eksempel, +2 evalueres til tallet 2, +542 evalueres til tallet 542, og så videre. Men hvis operanden ikke er et tall, prøver unær pluss (+) operatoren å konvertere den til et tall.
For eksempel vil +”98″ evaluere til98, og +”0″ vil evaluere til tallet 0. Derfor kan vi bruke unær pluss (+)-operatoren til å konvertere strenger til tall. Hvis du sender inn en streng som ikke kan konverteres til et tall, returneres NaN som vist nedenfor:
let numString1 = "23452";
let numString2 = "973.82"
let word = "hello"
// Using the Unary plus (+) to convert strings to numbers
let num1 = +numString1;
let num2 = +numString2;
let notNumber = +word;
console.log(`${num1} is a ${typeof num1}`);
console.log(`${num2} is a ${typeof num2}`);
console.log(notNumber);
Produksjon:
23452 is a number 973.82 is a number NaN
Å bruke unær pluss (+)-operatoren er en god måte å konvertere strenger til tall, siden den er rask og ikke utfører noen ekstra operasjoner på operandene.
Bruke parseInt() og parseFloat()
Akkurat som i JavaScript, skiller Typescript ikke mellom heltall og desimaltall også kjent som flyttall. Alle anses å være av typenummer. Når det er sagt, er oppførselen til parseInt() og parseFloat() litt forskjellig.
parseInt() tar inn et strengargument, analyserer det og returnerer et heltallsekvivalent i henhold til den angitte radiksen. parseFloat() tar inn en streng og 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() returner 897 mens parsefloat() vil returnere 897.75.
Derfor, når du konverterer numeriske strenger som ikke har et desimalsted, bruk parseInt(), men hvis den numeriske strengen har desimalplasser, bruk parseFloat() som vist i koden nedenfor:
let numString1 = "897.75";
let numString2 = "724";
let word = "hello";
console.log("Parsing numerical strings with decimal numbers")
console.log(`Using parseInt -> ${parseInt(numString1)}`);
console.log(`Using parseFloat -> ${parseFloat(numString1)}`);
console.log("Parsing numerical strings with whole numbers")
console.log(`Using parseInt -> ${parseInt(numString2)}`);
console.log(`Using parseFloat -> ${parseFloat(numString2)}`);
console.log("Parsing strings that can't convert to number")
console.log(parseInt(word));
console.log(parseFloat(word));
Produksjon:
Parsing numerical strings with decimal numbers Using parseInt -> 897 Using parseFloat -> 897.75 Parsing numerical strings with whole numbers Using parseInt -> 724 Using parseFloat -> 724 Parsing strings that can't convert to number NaN NaN
Konklusjon
Når du arbeider med strengverdier, for eksempel resultatet av API-kall, vil du kanskje 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 fremhevet i artikkelen for å konvertere strenger til tall.
Men når du konverterer strenger til tall, vær forsiktig fordi du kan få NaN når du prøver å konvertere en streng til et tall.
For å unngå en slik feil, sørg for at alle strengene du vil konvertere til et tall er numeriske strenger. Du kan også bruke en if-setning for å se etter NaN for å unngå feil i koden.
Du kan også utforske de beste TypeScript-bibliotekene og kjøretiden for å vite som utvikler.