Förstå typkonvertering och tvång i JavaScript

JavaScripts dynamiska skrivning innebär att din kod kan vara lite enklare, men det är fortfarande möjligt att göra misstag. För att undvika dem är det användbart att veta hur JavaScript löser värden med olika typer, för att jämföra dem.

Att förstå typkonvertering och tvång i JavaScript är avgörande för att skriva tillförlitliga och effektiva program. Varje koncept har specifika användningsfall och bästa praxis som kan påverka beteendet hos din kod.

Varför sker typkonvertering och tvång i JavaScript?

JavaScript-språket är dynamiskt skriven. Detta innebär att, till skillnad från statiskt skrivna språk, kräver JavaScript inte att du uttryckligen definierar datatypen för en variabel innan du använder den. Istället bestämmer JavaScript typen vid körning beroende på variabelns värde.

Eftersom datatyper inte explicit deklareras förrän vid körning, när du utför operationer som kräver olika data typer, kontrollerar JavaScript automatiskt deras kompatibilitet med varandra för den operation du vill utföra. Om de är kompatibla med varandra fortsätter operationen normalt.

Men anta att de är inkompatibla med operationen, till exempel att försöka lägga till en sträng och ett nummer. I sådana fall "tvingar" JavaScript automatiskt en av typerna att passa den andra för att säkerställa att operationen lyckas istället för att skapa ett fel. Denna process är känd som typtvång eller implicit tvång.

Typ tvång

Typtvång är den automatiska omvandlingen av ett värde från en datatyp till en annan, utförd av JavaScript under körningen av ett program för att säkerställa att en operation utförs framgångsrikt.

Men inte alla datatyper kan tvingas fram. Sträng, nummer och boolean är de enda JavaScript-datatyper att språket kommer att tvingas till en annan typ. När du försöker utföra en inkompatibel operation med datatyper som JavaScript inte kan tvinga fram kommer det att skapa ett fel.

JavaScript tvingar fram typer baserat på typen av operation och den operatör du använder i operationen.

Tvång med "+"-operatören

I JavaScript är "+” Operatören har två olika beteenden beroende på typen av dess operander. Den kan utföra både numerisk addition och strängsammansättning. Detta kan leda till typtvång när en av operanderna inte är av den förväntade typen.

Om båda operanderna är siffror, visas "+” Operatören utför tillägg:

låta num1 = 42;
låta num2 = 10;
låta summa = num1 + num2; // Tillägg
trösta.log (summa); // 52

Om båda operanderna är strängar visas "+”operatorn utför strängsammansättning:

låta str1 = "Hallå";
låta str2 = "värld";
låta resultat = str1 + " " + str2; // Strängsammansättning
trösta.log (resultat); // "Hej världen"

Men om en av operanderna inte är en sträng, kommer JavaScript implicit att tvinga den till en sträng innan sammankopplingen utförs:

// Nummer och sträng
låta num = 42;
låta str = "Hallå";
// num tvingas till en sträng och sammanfogas sedan
låta resultat_1 = num + str;
trösta.log (resultat_1); // "42Hej"
// String och Boolean
låta bool = Sann;
// bool tvingas till en sträng och sammanfogas sedan
låta result_2 = bool + str;
trösta.log (resultat_2); // "trueHello"

Tvång med "-"-operatören

I JavaScript är "-” operatorn används främst för subtraktionsoperationer. När en eller båda operanderna i en operation som involverar "-” Operatören är inte ett nummer, JavaScript kommer att försöka tvinga det till ett nummer.

När båda operanderna är siffror, utför JavaScript subtraktion. Den utför också subtraktion när en eller båda operanderna är strängar som representerar ett tal:

konst num1 = 10;
konst num2 = 20;
konst resultat_1 = num2 - num1; // Subtraktion
trösta.log (resultat_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst resultat = strNum2 - strNum; // Skriv tvång till siffror, sedan subtraktion
trösta.log (resultat_1); // 10

När ingen av operanderna är ett tal eller en sträng som representerar ett tal, kommer JavaScript att försöka tvinga datatypen till dess numeriska motsvarighet. Om datatypen inte har någon numerisk motsvarighet kommer operationen att återkomma NaN (Inte ett nummer):

// sant tvingas till 1, falskt tvingas till 0
konst boolNum = Sann;
konst boolNum2 = falsk;
konst result_1 = boolNum - boolNum2;
trösta.log (resultat_1); // 1
// tomma arrayer tvingas till 0
konst arrNum = [];
konst arrNum2 = [];
konst resultat_2 = arrNum - arrNum2;
trösta.log (resultat_2); // 0
// tomma objekt tvingas till NaN
konst objNum = {};
konst resultat_3 = arrNum - objNum;
trösta.log (resultat_3); // 0 - NaN = NaN

I det här exemplet tvingar JavaScript fram booleska värden Sann och falsk till deras numeriska ekvivalenta värden, 1 och 0, respektive. Tomma arrayer tvingas till 0, och tomma föremål tvingas till NaN.

Tvång med jämlikhet (==)/() operatörer

I JavaScript är jämlikhetsoperatorerna (== och ) jämföra värden för jämställdhet. De beter sig dock olika på grund av typtvång.

den "==” (lös likhet) operatör utför typtvång, vilket betyder att den försöker konvertera operander till samma typ innan jämförelse:

"10" == 10; // Sann

I det här exemplet tvingar JavaScript strängen "10" till siffran 10, så uttrycket utvärderas till Sann.

Men den "” (strikt jämlikhet) operatör utför inte typtvång. Det kräver att värdet och typen är samma för att jämförelsen ska returneras Sann:

"10"10; // falskt

I det här exemplet returnerar jämförelsen falsk eftersom operanderna är av olika typer (sträng och nummer).

Du bör i allmänhet använda (strikt jämlikhet) operatör i JavaScript för att undvika oväntat tvångsbeteende.

Typtvång eller implicit konvertering kan leda till oväntat beteende på grund av dess automatiska karaktär. I de fall du behöver konvertera typer, är det lämpligt att uttryckligen konvertera typerna. Processen att explicit konvertera typerna kallas typkonvertering. Det kallas också typgjutning och explicit typkonvertering.

Typkonvertering

Typkonvertering, även känd som typgjutning, är den explicita processen att konvertera ett värde från en datatyp till en annan i JavaScript med hjälp av inbyggda funktioner som t.ex. Siffra(), Sträng(), Boolean(), parseInt(), och parseFloat().

Du kan utföra typkonvertering genom att skicka värdet du vill konvertera till de inbyggda konverteringsfunktionerna som ett argument. Dessa funktioner konverterar sedan ditt värde till önskad typ.

Här är ett exempel med hjälp av Siffra() fungera:

konst numStr = "123";
konst num = siffra(numStr); // Konverterar en sträng till ett tal
trösta.log (antal); // 123

Att skicka en sträng som är ett giltigt nummer som ett argument till Siffra() funktionen returnerar ett nummer. Att skicka en sträng som är ett ogiltigt nummer kommer att returneras NaN.

Här är ett exempel med hjälp av Sträng() fungera:

konst bool = Sann;
konst str2 = Sträng(bool); // Konverterar en boolean till en sträng
trösta.log (str2); // "Sann"

Att skicka vilken datatyp som helst till utom en symbol till Sträng() funktionen konverterar datatypen till en sträng.

Här är ett exempel med hjälp av Boolean() fungera:

// Konvertera en sträng till en boolesk (sanning: sant, falskt: falskt)
konst str = "Hallå";
konst bool2 = Boolean(str);
trösta.log (bool2); // Sann

Att överföra sanna värderingar till Boolean() funktionen returnerar det booleska ordet "true" medan överföring av falska värden returnerar det booleska "false".

Här är ett exempel med hjälp av ParseInt() och ParseFloat() fungera:

// Konvertera en sträng till ett heltal
konst numStr = "123.00";
konst num1 = parseInt(numStr);
trösta.log (nummer1); // 123
// Konvertera en sträng till ett flyttal
konst floatStr = "3.14";
konst num2 = parseFloat(floatStr);
trösta.log (nummer2); // 3.14

De parseInt() funktion analyserar ett strängargument och returnerar ett heltal. De parseFloat() funktion konverterar en sträng till ett flyttal.

Utnyttja typtvång och konvertering

Genom att förstå typtvång och konvertering kan du fatta välgrundade beslut om när och hur du ska utnyttja dem effektivt i din kod. Det är viktigt att hitta rätt balans, använda typtvång på ett klokt sätt för att få kortfattad och bekväm kod och förlita sig på explicit typkonvertering för avsiktliga och förutsägbara typkonverteringar.