Forstå typekonvertering og tvang i JavaScript

JavaScripts dynamiske skriving betyr at koden din kan være litt enklere, men det er fortsatt mulig å gjøre feil. For å unngå dem er det nyttig å vite hvordan JavaScript løser verdier med forskjellige typer, for å sammenligne dem.

Å forstå typekonvertering og tvang i JavaScript er avgjørende for å skrive pålitelige og effektive programmer. Hvert konsept har spesifikke brukstilfeller og beste praksis som kan påvirke oppførselen til koden din.

Hvorfor skjer typekonvertering og tvang i JavaScript?

JavaScript-språket er dynamisk skrevet. Dette betyr at, i motsetning til statisk skrevet språk, krever ikke JavaScript at du eksplisitt definerer datatypen til en variabel før du bruker den. I stedet bestemmer JavaScript typen ved kjøretid avhengig av variabelens verdi.

Siden datatyper ikke er eksplisitt deklarert før kjøretid, når du utfører operasjoner som krever andre data typer, sjekker JavaScript automatisk deres kompatibilitet med hverandre for operasjonen du vil utføre. Hvis de er kompatible med hverandre, fortsetter operasjonen normalt.

Anta imidlertid at de er inkompatible med operasjonen - for eksempel å prøve å legge til en streng og et tall. I slike tilfeller "tvinger" JavaScript automatisk en av typene til å passe den andre for å sikre at operasjonen er vellykket i stedet for å gi en feil. Denne prosessen er kjent som type tvang eller implisitt tvang.

Type tvang

Typetvang er den automatiske konverteringen av en verdi fra én datatype til en annen, utført av JavaScript under kjøringen av et program for å sikre at en operasjon utføres vellykket.

Men ikke alle datatyper kan tvinges. Streng, tall og boolsk er de eneste JavaScript-datatyper at språket vil tvinge til en annen type. Når du prøver å utføre en inkompatibel operasjon med datatyper som JavaScript ikke kan tvinge, vil det gi en feil.

JavaScript tvinger typer basert på typen operasjon og operatøren du bruker i operasjonen.

Tvang med "+"-operatøren

I JavaScript er "+” Operatøren har to forskjellige virkemåter avhengig av typene av operandene. Den kan utføre både numerisk addisjon og strengsammenkobling. Dette kan føre til typetvang når en av operandene ikke er av den forventede typen.

Hvis begge operandene er tall, vil "+” Operatøren utfører tillegg:

la num1 = 42;
la nummer2 = 10;
la sum = tall1 + tall2; // Tillegg
konsoll.log (sum); // 52

Hvis begge operandene er strenger, vil "+"-operatør utfører strengsammenkobling:

la str1 = "Hallo";
la str2 = "verden";
la resultat = str1 + " " + str2; // Strengesammenkobling
konsoll.log (resultat); // "Hei Verden"

Men hvis en av operandene ikke er en streng, vil JavaScript implisitt tvinge den inn i en streng før sammenkoblingen utføres:

// Tall og streng
la num = 42;
la str = "Hallo";
// num er tvunget til en streng og deretter sammenkoblet
la resultat_1 = tall + str;
konsoll.log (resultat_1); // "42Hei"
// String og boolsk
la bool = ekte;
// bool blir tvunget til en streng og deretter sammenkoblet
la resultat_2 = bool + str;
konsoll.log (resultat_2); // "trueHallo"

Tvang med "-"-operatøren

I JavaScript er "-”-operator brukes primært for subtraksjonsoperasjoner. Når en eller begge operandene i en operasjon som involverer "-Operator er ikke et tall, JavaScript vil prøve å tvinge det til et tall.

Når begge operandene er tall, utfører JavaScript subtraksjon. Den utfører også subtraksjon når en eller begge operandene er strenger som representerer et tall:

konst num1 = 10;
konst nummer2 = 20;
konst resultat_1 = tall2 - tall1; // Subtraksjon
konsoll.log (resultat_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst resultat = strNum2 - strNum; // Skriv tvang til tall, deretter subtraksjon
konsoll.log (resultat_1); // 10

Når ingen av operandene er et tall eller en streng som representerer et tall, vil JavaScript prøve å tvinge datatypen til dens numeriske ekvivalent. Hvis datatypen ikke har noen numerisk ekvivalent, vil operasjonen returnere NaN (Ikke et tall):

// true blir tvunget til 1, usant blir tvunget til 0
konst boolNum = ekte;
konst boolNum2 = falsk;
konst resultat_1 = boolNum - boolNum2;
konsoll.log (resultat_1); // 1
// tomme matriser blir tvunget til 0
konst arrNum = [];
konst arrNum2 = [];
konst resultat_2 = arrNum - arrNum2;
konsoll.log (resultat_2); // 0
// tomme objekter blir tvunget til NaN
konst objNum = {};
konst resultat_3 = arrNum - objNum;
konsoll.log (resultat_3); // 0 - NaN = NaN

I dette eksemplet tvinger JavaScript booleske verdier ekte og falsk til deres numeriske ekvivalente verdier, 1 og 0, hhv. Tomme arrays blir tvunget til 0, og tomme gjenstander blir tvunget til NaN.

Tvang med likestillings (==)/()-operatørene

I JavaScript er likhetsoperatørene (== og ) sammenligne verdier for likestilling. Imidlertid oppfører de seg annerledes på grunn av typetvang.

«==” (løs likhet) operatør utfører typetvang, noe som betyr at den prøver å konvertere operander til samme type før sammenligning:

"10" == 10; // sant

I dette eksemplet tvinger JavaScript strengen "10" til tallet 10, så uttrykket evalueres til ekte.

Imidlertid "” (streng likestilling) operatør utfører ikke typetvang. Det krever at verdien og typen er den samme for at sammenligningen skal returnere ekte:

"10"10; // falsk

I dette eksemplet returnerer sammenligningen falsk fordi operandene er av forskjellige typer (streng og tall).

Du bør generelt bruke (streng likhet) operatør i JavaScript for å unngå uventet type tvangsatferd.

Typetvang eller implisitt konvertering kan føre til uventet atferd på grunn av dens automatiske natur. I tilfeller der du trenger å konvertere typer, er det tilrådelig å eksplisitt konvertere typene. Prosessen med å eksplisitt konvertere typene er kjent som typekonvertering. Det omtales også som typestøping og eksplisitt typekonvertering.

Type konvertering

Typekonvertering, også kjent som typecasting, er den eksplisitte prosessen med å konvertere en verdi fra en datatype til en annen i JavaScript ved hjelp av innebygde funksjoner som f.eks. Antall(), String(), boolsk(), parseInt(), og parseFloat().

Du kan utføre typekonvertering ved å overføre verdien du ønsker å konvertere til de innebygde konverteringsfunksjonene som et argument. Disse funksjonene konverterer deretter verdien til ønsket type.

Her er et eksempel som bruker Antall() funksjon:

konst numStr = "123";
konst num = Antall(numStr); // Konverterer en streng til et tall
konsoll.log (antall); // 123

Sende en streng som er et gyldig tall som et argument til Antall() funksjonen vil returnere et tall. Hvis du sender en streng som er et ugyldig tall, kommer du tilbake NaN.

Her er et eksempel som bruker String() funksjon:

konst bool = ekte;
konst str2 = String(bool); // Konverterer en boolsk til en streng
konsoll.log (str2); // "sant"

Sende en hvilken som helst datatype inn i unntatt et symbol i String() funksjonen vil konvertere datatypen til en streng.

Her er et eksempel som bruker boolsk() funksjon:

// Konverter en streng til en boolsk (sann: sann, falsk: usann)
konst str = "Hallo";
konst bool2 = boolsk(str);
konsoll.log (bool2); // sant

Sende sanne verdier til boolsk() funksjonen returnerer boolsk "true" mens sending av falske verdier returnerer boolsk "false".

Her er et eksempel som bruker ParseInt() og ParseFloat() funksjon:

// Konverter en streng til et heltall
konst numStr = "123.00";
konst num1 = parseInt(numStr);
konsoll.log (tall1); // 123
// Konverter en streng til et flyttall
konst floatStr = "3.14";
konst nummer2 = parseFloat(floatStr);
konsoll.log (tall2); // 3.14

De parseInt() funksjonen analyserer et strengargument og returnerer et heltall. De parseFloat() funksjonen konverterer en streng til et flyttall.

Utnytte type tvang og konvertering

Ved å forstå type tvang og konvertering kan du ta informerte beslutninger om når og hvordan du kan utnytte dem effektivt i koden din. Det er viktig å finne den rette balansen, bruke typetvang fornuftig for kortfattet og praktisk kode og stole på eksplisitt typekonvertering for tilsiktede og forutsigbare typekonverteringer.