Pochopenie konverzie typov a nátlaku v JavaScripte

Dynamické písanie JavaScriptu znamená, že váš kód môže byť o niečo jednoduchší, no stále je možné robiť chyby. Aby ste sa im vyhli, je užitočné vedieť, ako JavaScript rozlišuje hodnoty s rôznymi typmi a porovnávať ich.

Pochopenie konverzie typov a nátlaku v JavaScripte je rozhodujúce pre písanie spoľahlivých a efektívnych programov. Každý koncept má špecifické prípady použitia a osvedčené postupy, ktoré môžu ovplyvniť správanie vášho kódu.

Prečo dochádza ku konverzii typov a nátlaku v JavaScripte?

Jazyk JavaScript sa zadáva dynamicky. To znamená, že na rozdiel od jazykov so staticky typizovaným jazykom JavaScript nevyžaduje, aby ste pred použitím premennej explicitne definovali typ údajov. Namiesto toho JavaScript určuje typ za behu v závislosti od hodnoty premennej.

Keďže dátové typy nie sú explicitne deklarované až do runtime, keď vykonávate operácie vyžadujúce iné dáta typy, JavaScript automaticky kontroluje ich vzájomnú kompatibilitu pre operáciu, ktorú chcete vykonať. Ak sú navzájom kompatibilné, operácia prebieha normálne.

Predpokladajme však, že sú nekompatibilné s operáciou – napríklad pri pokuse o pridanie reťazca a čísla. V takýchto prípadoch JavaScript automaticky „vynúti“ jeden z typov, aby sa zmestil do druhého, aby sa zabezpečilo, že operácia bude úspešná, namiesto toho, aby vyvolal chybu. Tento proces je známy ako typ nátlaku alebo implicitný nátlak.

Typ nátlaku

Nátlak typu je automatická konverzia hodnoty z jedného dátového typu na druhý, ktorú vykonáva JavaScript počas behu programu, aby sa zabezpečilo úspešné vykonanie operácie.

Nie všetky typy údajov však možno vynútiť. Reťazec, číslo a boolean sú jediné Typy údajov JavaScript že jazyk prinúti iný typ. Keď sa pokúsite vykonať nekompatibilnú operáciu s typmi údajov, ktoré JavaScript nedokáže vynútiť, zobrazí sa chyba.

JavaScript vynucuje typy na základe typu operácie a operátora, ktorý pri operácii používate.

Nátlak pomocou operátora „+“.

V JavaScripte je „+Operátor ” má dve rôzne správania v závislosti od typov svojich operandov. Môže vykonávať sčítanie čísel aj zreťazenie reťazcov. To môže viesť k typovému nátlaku, keď jeden z operandov nie je očakávaného typu.

Ak sú oba operandy čísla, „+Operátor ” vykoná sčítanie:

nech číslo1 = 42;
nech číslo2 = 10;
nech súčet = číslo1 + číslo2; // Doplnenie
konzoly.log (súčet); // 52

Ak sú oba operandy reťazce, „+Operátor ” vykoná zreťazenie reťazcov:

nech str1 = "Ahoj";
nech str2 = "svet";
nech výsledok = str1 + " " + str2; // Zreťazenie reťazcov
konzoly.log (výsledok); // "Ahoj svet"

Ak však jeden z operandov nie je reťazec, JavaScript ho pred vykonaním zreťazenia implicitne vnúti do reťazca:

// Číslo a reťazec
nech číslo = 42;
nech str = "Ahoj";
// num sa prevedie do reťazca a potom sa zreťazí
nech vysledok_1 = cislo + str;
konzoly.log (vysledok_1); // "42Ahoj"
// Reťazec a logická hodnota
nech bool = pravda;
// bool je prevedený na reťazec a potom zreťazený
nech vysledok_2 = bool + str;
konzoly.log (vysledok_2); // "trueHello"

Nátlak s operátorom „-“.

V JavaScripte je „-Operátor ” sa primárne používa na operácie odčítania. Keď jeden alebo oba operandy v operácii zahŕňajúcej „-Operátor ” nie je číslo, JavaScript sa ho pokúsi vnútiť do čísla.

Keď sú oba operandy čísla, JavaScript vykoná odčítanie. Vykonáva aj odčítanie, keď jeden alebo oba operandy sú reťazce, ktoré predstavujú číslo:

konšt číslo1 = 10;
konšt číslo2 = 20;
konšt vysledok_1 = cislo2 - cislo1; // Odčítanie
konzoly.log (vysledok_1); // 10
konšt strNum = "10";
konšt strNum2 = "20";
konšt vysledok = strNum2 - strNum; // K číslam zadajte vynútenie a potom odčítanie
konzoly.log (vysledok_1); // 10

Keď ani jeden z operandov nie je číslo alebo reťazec predstavujúci číslo, JavaScript sa pokúsi prinútiť typ údajov na jeho číselný ekvivalent. Ak typ údajov nemá číselný ekvivalent, operácia sa vráti NaN (Nie číslo):

// true bude vynútená na 1, false bude vynútená na 0
konšt boolNum = pravda;
konšt boolNum2 = falošný;
konšt vysledok_1 = boolNum - boolNum2;
konzoly.log (vysledok_1); // 1
// prázdne polia sa vynútia na 0
konšt arrNum = [];
konšt arrNum2 = [];
konšt vysledok_2 = arrNum - arrNum2;
konzoly.log (vysledok_2); // 0
// prázdne objekty sú prinútené na NaN
konšt objNum = {};
konšt vysledok_3 = arrNum - objNum;
konzoly.log (vysledok_3); // 0 - NaN = NaN

V tomto príklade JavaScript vynúti boolovské hodnoty pravda a falošný na ich číselné ekvivalentné hodnoty, 1 a 0, resp. Prázdne polia sú vynútené 0, a prázdne predmety sú donútené NaN.

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

V JavaScripte operátory rovnosti (== a ) porovnajte hodnoty pre rovnosť. Typovým nátlakom sa však správajú inak.

"==Operátor ” (voľná rovnosť) vykonáva typovú nátlak, čo znamená, že sa pokúša previesť operandy na rovnaký typ pred porovnaním:

"10" == 10; // pravda

V tomto príklade JavaScript prinúti reťazec „10“ na číslo 10, takže výraz sa vyhodnotí ako pravda.

Avšak, „Operátor ” (prísna rovnosť) nevykonáva typový nátlak. Vyžaduje, aby hodnota a typ boli rovnaké, aby sa porovnanie vrátilo pravda:

"10"10; // nepravda

V tomto príklade sa vráti porovnanie falošný pretože operandy sú rôznych typov (reťazec a číslo).

Vo všeobecnosti by ste mali používať (prísna rovnosť) operátora v JavaScripte, aby sa predišlo neočakávanému nátlakovému správaniu.

Typový nátlak alebo implicitná konverzia môže viesť k neočakávanému správaniu vďaka svojej automatickej povahe. V prípadoch, keď potrebujete previesť typy, je vhodné explicitne previesť typy. Proces explicitnej konverzie typov je známy ako konverzia typu. Označuje sa tiež ako typové liatie a explicitná typová konverzia.

Typ Konverzia

Konverzia typu, tiež známa ako pretypovanie, je explicitný proces prevodu hodnoty z jedného dátového typu na iný v JavaScripte pomocou vstavaných funkcií, ako napr. číslo(), String(), Boolean(), parseInt(), a parseFloat().

Konverziu typu môžete vykonať tak, že hodnotu, ktorú chcete previesť, odošlete do vstavaných konverzných funkcií ako argument. Tieto funkcie potom prevedú vašu hodnotu na požadovaný typ.

Tu je príklad použitia číslo() funkcia:

konšt numStr = "123";
konšt číslo = číslo(numStr); // Skonvertuje reťazec na číslo
konzoly.log (číslo); // 123

Odovzdanie reťazca, ktorý je platným číslom, ako argument do číslo() funkcia vráti číslo. Zadanie reťazca, ktorý je neplatným číslom, sa vráti NaN.

Tu je príklad použitia String() funkcia:

konšt bool = pravda;
konšt str2 = Reťazec(bool); // Konvertuje boolovskú hodnotu na reťazec
konzoly.log (str2); // "pravda"

Odovzdanie akéhokoľvek dátového typu do okrem symbolu do String() funkcia skonvertuje typ údajov na reťazec.

Tu je príklad použitia Boolean() funkcia:

// Konvertovať reťazec na booleovský (pravda: pravda, nepravda: nepravda)
konšt str = "Ahoj";
konšt bool2 = Boolean(str);
konzoly.log (bool2); // pravda

Odovzdávanie pravdivých hodnôt Boolean() funkcia vráti boolovskú hodnotu „true“, zatiaľ čo odovzdanie falošných hodnôt vráti boolovskú hodnotu „false“.

Tu je príklad použitia ParseInt() a ParseFloat() funkcia:

// Konvertuje reťazec na celé číslo
konšt numStr = "123.00";
konšt číslo1 = parseInt(numStr);
konzoly.log (číslo 1); // 123
// Konvertuje reťazec na číslo s pohyblivou rádovou čiarkou
konšt floatStr = "3.14";
konšt číslo2 = parseFloat(floatStr);
konzoly.log (číslo 2); // 3.14

The parseInt() funkcia analyzuje argument reťazca a vráti celé číslo. The parseFloat() funkcia skonvertuje reťazec na číslo s pohyblivou rádovou čiarkou.

Využitie typu nátlaku a konverzie

Pochopením typu nátlaku a konverzie môžete robiť informované rozhodnutia o tom, kedy a ako ich efektívne využiť vo svojom kóde. Je dôležité nájsť správnu rovnováhu, používať nátlak typu uvážlivo pre stručný a pohodlný kód a spoliehať sa na explicitnú konverziu typu pre zámerné a predvídateľné konverzie typu.