Pas på type tvang: denne avancerede funktion kan være årsagen til subtile fejl, så sørg for at du ved, hvordan det virker.
JavaScripts dynamiske indtastning betyder, at din kode kan være en smule enklere, men det er stadig muligt at lave fejl. For at undgå dem er det nyttigt at vide, hvordan JavaScript løser værdier med forskellige typer, for at sammenligne dem.
At forstå typekonvertering og tvang i JavaScript er afgørende for at skrive pålidelige og effektive programmer. Hvert koncept har specifikke use cases og bedste praksis, der kan påvirke adfærden af din kode.
Hvorfor sker typekonvertering og tvang i JavaScript?
JavaScript-sproget er dynamisk indtastet. Dette betyder, at i modsætning til statisk indtastede sprog, kræver JavaScript ikke, at du eksplicit definerer datatypen for en variabel, før du bruger den. I stedet bestemmer JavaScript typen ved kørsel afhængigt af variablens værdi.
Da datatyper ikke udtrykkeligt erklæres før runtime, når du udfører handlinger, der kræver forskellige data typer, tjekker JavaScript automatisk deres kompatibilitet med hinanden for den handling, du vil udføre. Hvis de er kompatible med hinanden, forløber operationen normalt.
Men antag, at de er inkompatible med operationen - for eksempel at prøve at tilføje en streng og et tal. I sådanne tilfælde "tvinger" JavaScript automatisk en af typerne til at passe til den anden for at sikre, at operationen lykkes i stedet for at kaste en fejl. Denne proces er kendt som type tvang eller implicit tvang.
Type tvang
Typetvang er den automatiske konvertering af en værdi fra én datatype til en anden, udført af JavaScript under afviklingen af et program for at sikre, at en operation udføres med succes.
Men ikke alle datatyper kan tvinges. Streng, tal og boolean er de eneste JavaScript-datatyper at sproget vil tvinge til en anden type. Når du forsøger at udføre en inkompatibel operation med datatyper, som JavaScript ikke kan tvinge, vil det give en fejl.
JavaScript tvinger typer baseret på typen af operation og den operatør du bruger i operationen.
Tvang med "+"-operatøren
I JavaScript er "+” Operatøren har to forskellige adfærd afhængigt af typen af dens operander. Den kan udføre både numerisk tilføjelse og strengsammenkædning. Dette kan føre til typetvang, når en af operanderne ikke er af den forventede type.
Hvis begge operander er tal, vil "+” operatør udfører tilføjelse:
lade nummer1 = 42;
lade nummer2 = 10;
lade sum = num1 + num2; // Tilføjelse
konsol.log (sum); // 52
Hvis begge operander er strenge, vil "+” operatør udfører strengsammenkædning:
lade str1 = "Hej";
lade str2 = "verden";
lade resultat = str1 + " " + str2; // Strengsammenkædning
konsol.log (resultat); // "Hej Verden"
Men hvis en af operanderne ikke er en streng, vil JavaScript implicit tvinge den til en streng, før sammenkædningen udføres:
// Tal og streng
lade antal = 42;
lade str = "Hej";// num tvinges til en streng og derefter sammenkædet
lade resultat_1 = antal + str;
konsol.log (resultat_1); // "42Hej"// String og Boolean
lade bool = rigtigt;
// bool tvinges til en streng og sammenkædes derefter
lade result_2 = bool + str;
konsol.log (resultat_2); // "sandHej"
Tvang med "-"-operatøren
I JavaScript er "-” operator bruges primært til subtraktionsoperationer. Når en eller begge operander i en operation, der involverer "-” operator er ikke et tal, JavaScript vil forsøge at tvinge det til et tal.
Når begge operander er tal, udfører JavaScript subtraktion. Den udfører også subtraktion, når en eller begge operander er strenge, der repræsenterer et tal:
konst nummer1 = 10;
konst nummer2 = 20;
konst resultat_1 = num2 - num1; // Subtraktion
konsol.log (resultat_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst resultat = strNum2 - strNum; // Indtast tvang til tal, derefter subtraktion
konsol.log (resultat_1); // 10
Når ingen af operanderne er et tal eller en streng, der repræsenterer et tal, vil JavaScript forsøge at tvinge datatypen til dens numeriske ækvivalent. Hvis datatypen ikke har nogen numerisk ækvivalent, vender handlingen tilbage NaN (Ikke et nummer):
// sand bliver tvunget til 1, falsk bliver tvunget til 0
konst boolNum = rigtigt;
konst boolNum2 = falsk;
konst resultat_1 = boolNum - boolNum2;
konsol.log (resultat_1); // 1// tomme arrays bliver tvunget til 0
konst arrNum = [];
konst arrNum2 = [];
konst resultat_2 = arrNum - arrNum2;
konsol.log (resultat_2); // 0
// tomme objekter bliver tvunget til NaN
konst objNum = {};
konst resultat_3 = arrNum - objNum;
konsol.log (resultat_3); // 0 - NaN = NaN
I dette eksempel tvinger JavaScript booleske værdier rigtigt og falsk til deres numeriske ækvivalente værdier, 1 og 0, henholdsvis. Tomme arrays tvinges til 0, og tomme genstande tvinges til NaN.
Tvang med ligestillings-(==)/()-operatørerne
I JavaScript er lighedsoperatørerne (== og ) sammenligne værdier for lighed. De opfører sig dog anderledes på grund af typetvang.
Det "==” (løs lighed) operator udfører typetvang, hvilket betyder at den forsøger at konvertere operander til samme type før sammenligning:
"10" == 10; // rigtigt
I dette eksempel tvinger JavaScript strengen "10" til tallet 10, så udtrykket evalueres til rigtigt.
Imidlertid "” (streng lighed) operatør udfører ikke typetvang. Det kræver, at værdien og typen er den samme, for at sammenligningen vender tilbage rigtigt:
"10"10; // falsk
I dette eksempel vender sammenligningen tilbage falsk fordi operanderne er af forskellige typer (streng og tal).
Du bør generelt bruge (streng lighed) operatør i JavaScript for at undgå uventet type tvangsadfærd.
Typetvang eller implicit konvertering kan føre til uventet adfærd på grund af dens automatiske karakter. I tilfælde hvor du skal konvertere typer, er det tilrådeligt at konvertere typerne eksplicit. Processen med eksplicit at konvertere typerne er kendt som typekonvertering. Det omtales også som typestøbning og eksplicit typekonvertering.
Typekonvertering
Typekonvertering, også kendt som typecasting, er den eksplicitte proces med at konvertere en værdi fra én datatype til en anden i JavaScript ved hjælp af indbyggede funktioner som f.eks. Nummer(), Snor(), Boolean(), parseInt(), og parseFloat().
Du kan udføre typekonvertering ved at overføre den værdi, du ønsker at konvertere, til de indbyggede konverteringsfunktioner som et argument. Disse funktioner konverterer derefter din værdi til den ønskede type.
Her er et eksempel ved hjælp af Nummer() fungere:
konst numStr = "123";
konst antal = Nummer(numStr); // Konverterer en streng til et tal
konsol.log (antal); // 123
Sende en streng, der er et gyldigt tal, som et argument til Nummer() funktion vil returnere et tal. Sender en streng, der er et ugyldigt tal, returneres NaN.
Her er et eksempel ved hjælp af Snor() fungere:
konst bool = rigtigt;
konst str2 = Snor(bool); // Konverterer en boolean til en streng
konsol.log (str2); // "rigtigt"
Sende enhver datatype ind i undtagen et symbol i Snor() funktion vil konvertere datatypen til en streng.
Her er et eksempel ved hjælp af Boolean() fungere:
// Konverter en streng til en boolsk (sandhed: sand, falsk: falsk)
konst str = "Hej";
konst bool2 = Boolean(str);
konsol.log (bool2); // rigtigt
At videregive sande værdier til Boolean() funktion returnerer det boolske "sand", mens det at sende falske værdier returnerer det boolske "false".
Her er et eksempel ved hjælp af ParseInt() og ParseFloat() fungere:
// Konverter en streng til et heltal
konst numStr = "123.00";
konst nummer1 = parseInt(numStr);
konsol.log (tal1); // 123
// Konverter en streng til et flydende kommatal
konst floatStr = "3.14";
konst nummer2 = parseFloat(floatStr);
konsol.log (tal2); // 3.14
Det parseInt() funktion analyserer et strengargument og returnerer et heltal. Det parseFloat() funktion konverterer en streng til et flydende kommatal.
Udnyttelse af typetvang og konvertering
Ved at forstå typetvang og konvertering kan du træffe informerede beslutninger om, hvornår og hvordan du kan udnytte dem effektivt i din kode. Det er vigtigt at finde den rigtige balance ved at bruge typetvang fornuftigt for at få kortfattet og bekvem kode og stole på eksplicit typekonvertering til forsætlige og forudsigelige typekonverteringer.
