Pochopení převodu typů a donucení v JavaScriptu

Dynamické psaní JavaScriptu znamená, že váš kód může být o něco jednodušší, ale stále je možné dělat chyby. Abyste se jim vyhnuli, je užitečné vědět, jak JavaScript řeší hodnoty s různými typy, a porovnat je.

Pochopení převodu typů a donucení v JavaScriptu je zásadní pro psaní spolehlivých a efektivních programů. Každý koncept má specifické případy použití a osvědčené postupy, které mohou ovlivnit chování vašeho kódu.

Proč v JavaScriptu dochází ke konverzi typů a nátlaku?

Jazyk JavaScript je dynamicky typováno. To znamená, že na rozdíl od staticky typovaných jazyků JavaScript nevyžaduje, abyste explicitně definovali datový typ proměnné před jejím použitím. Místo toho JavaScript určuje typ za běhu v závislosti na hodnotě proměnné.

Protože datové typy nejsou explicitně deklarovány až do běhu, kdy provádíte operace vyžadující jiná data typů, JavaScript automaticky kontroluje jejich vzájemnou kompatibilitu pro operaci, kterou chcete provést. Pokud jsou vzájemně kompatibilní, operace pokračuje normálně.

Předpokládejme však, že jsou s operací nekompatibilní – například při pokusu o přidání řetězce a čísla. V takových případech JavaScript automaticky „vynucuje“ jeden z typů, aby odpovídal druhému, aby zajistil, že operace bude úspěšná, místo aby vyvolal chybu. Tento proces je známý jako typ nátlaku nebo implicitní nátlak.

Typ donucení

Typ donucení je automatický převod hodnoty z jednoho datového typu na jiný, prováděný JavaScriptem během běhu programu, aby se zajistilo úspěšné provedení operace.

Ale ne všechny datové typy lze vynutit. Řetězec, číslo a boolean jsou jediné Datové typy JavaScriptu že se jazyk donutí k jinému typu. Když se pokusíte provést nekompatibilní operaci s datovými typy, které JavaScript nedokáže vynutit, vyvolá chybu.

JavaScript vynucuje typy na základě typu operace a operátoru, který v operaci používáte.

Nátlak s operátorem „+“.

V JavaScriptu „+Operátor ” má dvě různá chování v závislosti na typech svých operandů. Může provádět jak sčítání čísel, tak zřetězení řetězců. To může vést k vynucení typu, když jeden z operandů není očekávaného typu.

Pokud jsou oba operandy čísly, „+Operátor ” provede přidání:

nechat číslo1 = 42;
nechat číslo2 = 10;
nechat součet = číslo1 + číslo2; // Přidání
řídicí panel.log (součet); // 52

Pokud jsou oba operandy řetězce, „+Operátor ” provádí zřetězení řetězců:

nechat str1 = "Ahoj";
nechat str2 = "svět";
nechat výsledek = str1 + " " + str2; // Zřetězení řetězců
řídicí panel.log (výsledek); // "Ahoj světe"

Pokud však jeden z operandů není řetězec, JavaScript jej před provedením zřetězení implicitně vnutí do řetězce:

// Číslo a řetězec
nechat číslo = 42;
nechat str = "Ahoj";
// num je převedeno na řetězec a poté zřetězeno
nechat vysledek_1 = cislo + str;
řídicí panel.log (vysledek_1); // "42Ahoj"
// Řetězec a logická hodnota
nechat bool = skutečný;
// bool je převeden na řetězec a poté zřetězen
nechat vysledek_2 = bool + str;
řídicí panel.log (vysledek_2); // "trueHello"

Nátlak s operátorem „-“.

V JavaScriptu „-Operátor ” se primárně používá pro operace odečítání. Když jeden nebo oba operandy v operaci zahrnující „-Operátor ” není číslo, JavaScript se jej pokusí vnutit do čísla.

Když jsou oba operandy čísla, JavaScript provede odečítání. Provádí také odečítání, když jeden nebo oba operandy jsou řetězce, které představují číslo:

konst číslo1 = 10;
konst číslo2 = 20;
konst vysledek_1 = cislo2 - cislo1; // Odečítání
řídicí panel.log (vysledek_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst vysledek = strNum2 - strNum; // Zadejte donucení k číslům a poté odečítání
řídicí panel.log (vysledek_1); // 10

Když ani jeden z operandů není číslo nebo řetězec představující číslo, JavaScript se pokusí donutit datový typ k jeho číselnému ekvivalentu. Pokud datový typ nemá číselný ekvivalent, operace se vrátí NaN (Není číslo):

// true je vynuceno na 1, false je vynuceno na 0
konst boolNum = skutečný;
konst boolNum2 = Nepravdivé;
konst vysledek_1 = boolNum - boolNum2;
řídicí panel.log (vysledek_1); // 1
// prázdná pole jsou vynucena na 0
konst arrNum = [];
konst arrNum2 = [];
konst vysledek_2 = arrNum - arrNum2;
řídicí panel.log (vysledek_2); // 0
// prázdné objekty jsou přinuceny k NaN
konst objNum = {};
konst vysledek_3 = arrNum - objNum;
řídicí panel.log (vysledek_3); // 0 - NaN = NaN

V tomto příkladu JavaScript vynucuje booleovské hodnoty skutečný a Nepravdivé na jejich číselné ekvivalentní hodnoty, 1 a 0, respektive. Prázdná pole jsou vynucena 0, a prázdné předměty jsou donuceny NaN.

Nátlak s operátory rovnosti (==)/().

V JavaScriptu jsou operátory rovnosti (== a ) porovnejte hodnoty pro rovnost. V důsledku typového donucení se však chovají jinak.

"==Operátor ” (volná rovnost) provádí vynucování typu, což znamená, že se pokouší převést operandy na stejný typ před porovnáním:

"10" == 10; // skutečný

V tomto příkladu JavaScript převede řetězec „10“ na číslo 10, takže výraz se vyhodnotí jako skutečný.

Nicméně, „Operátor ” (přísná rovnost) neprovádí typový nátlak. Vyžaduje, aby hodnota a typ byly stejné, aby se porovnání vrátilo skutečný:

"10"10; // Nepravdivé

V tomto příkladu se vrátí porovnání Nepravdivé protože operandy jsou různých typů (řetězec a číslo).

Obecně byste měli používat operátor (přísná rovnost) v JavaScriptu, aby se zabránilo neočekávanému chování typu nátlaku.

Typový nátlak nebo implicitní konverze mohou díky své automatické povaze vést k neočekávanému chování. V případech, kdy potřebujete typy převést, je vhodné typy výslovně převést. Proces explicitní konverze typů je známý jako konverze typu. Označuje se také jako typové odlévání a explicitní typová konverze.

Převod typu

Převod typu, známý také jako přetypování, je explicitní proces převodu hodnoty z jednoho datového typu na jiný v JavaScriptu pomocí vestavěných funkcí, jako je např. Číslo(), Tětiva(), Boolean(), parseInt(), a parseFloat().

Převod typu můžete provést předáním hodnoty, kterou chcete převést, do vestavěných převodních funkcí jako argument. Tyto funkce pak převedou vaši hodnotu na požadovaný typ.

Zde je příklad pomocí Číslo() funkce:

konst numStr = "123";
konst číslo = Číslo(numStr); // Převede řetězec na číslo
řídicí panel.log (číslo); // 123

Předání řetězce, který je platným číslem, jako argument do Číslo() funkce vrátí číslo. Předání řetězce, který je neplatným číslem, se vrátí NaN.

Zde je příklad pomocí Tětiva() funkce:

konst bool = skutečný;
konst str2 = Tětiva(bool); // Převede boolean na řetězec
řídicí panel.log (str2); // "skutečný"

Předání libovolného datového typu do kromě symbolu do Tětiva() funkce převede datový typ na řetězec.

Zde je příklad pomocí Boolean() funkce:

// Převod řetězce na booleovský (truthy: true, false: false)
konst str = "Ahoj";
konst bool2 = Boolean(str);
řídicí panel.log (bool2); // skutečný

Předávání pravdivých hodnot Boolean() funkce vrací logickou hodnotu „true“, zatímco předávání chybných hodnot vrací booleovskou hodnotu „false“.

Zde je příklad pomocí ParseInt() a ParseFloat() funkce:

// Převede řetězec na celé číslo
konst numStr = "123.00";
konst číslo1 = parseInt(numStr);
řídicí panel.log (číslo 1); // 123
// Převede řetězec na číslo s plovoucí desetinnou čárkou
konst floatStr = "3.14";
konst číslo2 = parseFloat(floatStr);
řídicí panel.log (číslo 2); // 3.14

The parseInt() funkce analyzuje argument řetězce a vrátí celé číslo. The parseFloat() funkce převede řetězec na číslo s plovoucí desetinnou čárkou.

Využití typu nátlaku a konverze

Když porozumíte typu donucení a konverze, můžete činit informovaná rozhodnutí o tom, kdy a jak je efektivně využít ve svém kódu. Je důležité najít správnou rovnováhu, uvážlivě používat typové donucení pro stručný a pohodlný kód a spoléhat se na explicitní konverzi typu pro záměrné a předvídatelné konverze typu.