Inzicht in typeconversie en dwang in JavaScript

Dankzij het dynamische typen van JavaScript kan uw code iets eenvoudiger zijn, maar het is nog steeds mogelijk om fouten te maken. Om ze te vermijden, is het handig om te weten hoe JavaScript waarden met verschillende typen oplost, om ze te kunnen vergelijken.

Het begrijpen van typeconversie en dwang in JavaScript is cruciaal voor het schrijven van betrouwbare en efficiënte programma's. Elk concept heeft specifieke use cases en best practices die het gedrag van uw code kunnen beïnvloeden.

Waarom vinden typeconversie en dwang plaats in JavaScript?

De JavaScript-taal wordt dynamisch getypt. Dit betekent dat, in tegenstelling tot statisch getypeerde talen, JavaScript niet vereist dat u het gegevenstype van een variabele expliciet definieert voordat u deze gebruikt. In plaats daarvan bepaalt JavaScript het type tijdens runtime, afhankelijk van de waarde van de variabele.

Aangezien gegevenstypen pas tijdens runtime expliciet worden gedeclareerd, wanneer u bewerkingen uitvoert waarvoor andere gegevens nodig zijn typen, controleert JavaScript automatisch hun compatibiliteit met elkaar voor de bewerking die u wilt uitvoeren. Als ze compatibel zijn met elkaar, verloopt de bewerking normaal.

Stel echter dat ze niet compatibel zijn met de bewerking, bijvoorbeeld als u probeert een tekenreeks en een getal toe te voegen. In dergelijke gevallen "dwingt" JavaScript automatisch een van de typen om bij de andere te passen om ervoor te zorgen dat de bewerking succesvol is in plaats van een fout te genereren. Dit proces staat bekend als typedwang of impliciete dwang.

Typ dwang

Typedwang is de automatische conversie van een waarde van het ene gegevenstype naar het andere, uitgevoerd door JavaScript tijdens het uitvoeren van een programma om ervoor te zorgen dat een bewerking met succes wordt uitgevoerd.

Maar niet alle gegevenstypen kunnen worden afgedwongen. String, number en boolean zijn de enige JavaScript-gegevenstypen dat de taal zal dwingen tot een ander type. Wanneer u een incompatibele bewerking probeert uit te voeren met gegevenstypen die JavaScript niet kan afdwingen, wordt er een fout gegenereerd.

JavaScript dwingt typen af ​​op basis van het type bewerking en de operator die u in de bewerking gebruikt.

Dwang met de "+"-operator

In JavaScript is de "+De operator ” heeft twee verschillende gedragingen, afhankelijk van de typen operanden. Het kan zowel numerieke optelling als tekenreeksaaneenschakeling uitvoeren. Dit kan leiden tot typedwang wanneer een van de operanden niet van het verwachte type is.

Als beide operanden getallen zijn, wordt de "+”-operator voert toevoeging uit:

laten aantal1 = 42;
laten aantal2 = 10;
laten som = getal1 + getal2; // Toevoeging
troosten.log (som); // 52

Als beide operanden strings zijn, wordt de "+”-operator voert tekenreeksaaneenschakeling uit:

laten str1 = "Hallo";
laten str2 = "wereld";
laten resultaat = str1 + " " + str2; // String aaneenschakeling
troosten.log (resultaat); // "Hallo Wereld"

Als een van de operanden echter geen string is, dwingt JavaScript deze impliciet tot een string voordat de aaneenschakeling wordt uitgevoerd:

// Getal en tekenreeks
laten aantal = 42;
laten str = "Hallo";
// num wordt gedwongen tot een tekenreeks en vervolgens samengevoegd
laten resultaat_1 = aantal + str;
troosten.log (resultaat_1); // "42Hallo"
// String en Booleaans
laten boel = WAAR;
// bool wordt gedwongen tot een string en vervolgens samengevoegd
laten resultaat_2 = bool + str;
troosten.log (resultaat_2); // "trueHallo"

Dwang met de "-" operator

In JavaScript is de "-” operator wordt voornamelijk gebruikt voor aftrekbewerkingen. Wanneer een of beide operanden in een operatie met de "-”operator is geen nummer, JavaScript zal proberen het in een nummer te dwingen.

Wanneer beide operanden getallen zijn, voert JavaScript aftrekken uit. Het voert ook aftrekken uit wanneer een of beide operanden strings zijn die een getal vertegenwoordigen:

const aantal1 = 10;
const aantal2 = 20;
const resultaat_1 = aantal2 - aantal1; // Aftrekken
troosten.log (resultaat_1); // 10
const strNum = "10";
const strNum2 = "20";
const resultaat = strNum2 - strNum; // Typ dwang tot getallen en vervolgens aftrekken
troosten.log (resultaat_1); // 10

Wanneer geen van de operanden een getal is of een tekenreeks die een getal vertegenwoordigt, zal JavaScript proberen het gegevenstype te dwingen tot zijn numerieke equivalent. Als het gegevenstype geen numeriek equivalent heeft, wordt de bewerking geretourneerd NaN (Geen nummer):

// true wordt gedwongen tot 1, false wordt gedwongen tot 0
const boolNum = WAAR;
const boolNum2 = vals;
const resultaat_1 = boolNum - boolNum2;
troosten.log (resultaat_1); // 1
// lege arrays worden gedwongen tot 0
const arrNum = [];
const arrNum2 = [];
const result_2 = arrNum - arrNum2;
troosten.log (resultaat_2); // 0
// lege objecten worden gedwongen tot NaN
const objNum = {};
const result_3 = arrNum - objNum;
troosten.log (resultaat_3); // 0 - NaN = NaN

In dit voorbeeld dwingt JavaScript booleaanse waarden af WAAR En vals naar hun numerieke equivalente waarden, 1 En 0, respectievelijk. Lege arrays worden gedwongen 0, en lege objecten worden gedwongen NaN.

Dwang met de gelijkheid (==)/()-operatoren

In JavaScript zijn de gelijkheidsoperatoren (== En ) vergelijk waarden voor gelijkheid. Door typedwang gedragen ze zich echter anders.

De "==” (losse gelijkheid) operator voert type dwang uit, wat betekent dat het probeert operanden naar hetzelfde type te converteren vóór vergelijking:

"10" == 10; // WAAR

In dit voorbeeld dwingt JavaScript de tekenreeks "10" tot het getal 10, dus de uitdrukking evalueert naar WAAR.

Echter, de "” (strikte gelijkheid) operator voert geen typedwang uit. Het vereist dat de waarde en het type hetzelfde zijn om de vergelijking te laten terugkeren WAAR:

"10"10; // vals

In dit voorbeeld keert de vergelijking terug vals omdat de operanden van verschillende typen zijn (string en nummer).

Over het algemeen moet u de (strikte gelijkheid) operator in JavaScript om onverwacht typedwanggedrag te voorkomen.

Typedwang of impliciete conversie kan leiden tot onverwacht gedrag vanwege de automatische aard ervan. In gevallen waarin u typen moet converteren, is het raadzaam om de typen expliciet te converteren. Het proces van het expliciet converteren van de typen staat bekend als typeconversie. Het wordt ook wel typecasting en expliciete typeconversie genoemd.

Type conversie

Typeconversie, ook wel typecasting genoemd, is het expliciete proces van het converteren van een waarde van het ene gegevenstype naar het andere in JavaScript met behulp van ingebouwde functies zoals Nummer(), Snaar(), Booleaans(), ontledenInt(), En ontleedFloat().

U kunt typeconversie uitvoeren door de waarde die u wilt converteren als argument door te geven aan de ingebouwde conversiefuncties. Deze functies converteren vervolgens uw waarde naar het gewenste type.

Hier is een voorbeeld met behulp van de Nummer() functie:

const aantalStr = "123";
const aantal = Nummer(aantalStr); // Converteert een tekenreeks naar een getal
troosten.log (aantal); // 123

Een tekenreeks doorgeven die een geldig getal is als argument voor de Nummer() functie retourneert een getal. Als u een tekenreeks doorgeeft die een ongeldig getal is, wordt geretourneerd NaN.

Hier is een voorbeeld met behulp van de Snaar() functie:

const boel = WAAR;
const str2 = Snaar(boel); // Converteert een boolean naar een string
troosten.log (str2); // "WAAR"

Elk gegevenstype doorgeven aan de behalve een symbool in de Snaar() functie converteert het gegevenstype naar een tekenreeks.

Hier is een voorbeeld met behulp van de Booleaans() functie:

// Converteer een string naar een boolean (truthy: true, false: false)
const str = "Hallo";
const bool2 = Booleaans(str);
troosten.log (boo2); // WAAR

Waarheidswaarden doorgeven aan de Booleaans() functie retourneert de boolean "true" terwijl het doorgeven van valse waarden de boolean "false" retourneert.

Hier is een voorbeeld met behulp van de ParseInt() En ParseFloat() functie:

// Converteer een string naar een geheel getal
const aantalStr = "123.00";
const aantal1 = ontleedInt(aantalStr);
troosten.log (num1); // 123
// Converteer een tekenreeks naar een getal met drijvende komma
const floatStr = "3.14";
const aantal2 = ontleedFloat(floatStr);
troosten.log (aantal2); // 3.14

De ontledenInt() functie ontleedt een tekenreeksargument en retourneert een geheel getal. De ontleedFloat() functie converteert een tekenreeks naar een getal met drijvende komma.

Gebruikmaken van typedwang en conversie

Door typedwang en conversie te begrijpen, kunt u weloverwogen beslissingen nemen over wanneer en hoe u deze effectief in uw code kunt gebruiken. Het is belangrijk om de juiste balans te vinden, oordeelkundig gebruik te maken van typedwang voor beknopte en handige code en te vertrouwen op expliciete typeconversie voor opzettelijke en voorspelbare typeconversies.