Tyyppimuunnoksen ja pakotuksen ymmärtäminen JavaScriptissä

JavaScriptin dynaaminen kirjoittaminen tarkoittaa, että koodisi voi olla hieman yksinkertaisempi, mutta virheiden tekeminen on silti mahdollista. Niiden välttämiseksi on hyödyllistä tietää, kuinka JavaScript ratkaisee eri tyyppisiä arvoja, ja vertailla niitä.

Tyyppimuunnoksen ja pakottamisen ymmärtäminen JavaScriptissä on ratkaisevan tärkeää luotettavien ja tehokkaiden ohjelmien kirjoittamisessa. Jokaisella konseptilla on erityisiä käyttötapauksia ja parhaita käytäntöjä, jotka voivat vaikuttaa koodisi toimintaan.

Miksi tyyppimuunnos ja pakottaminen tapahtuu JavaScriptissä?

JavaScript-kieli kirjoitetaan dynaamisesti. Tämä tarkoittaa, että toisin kuin staattisesti kirjoitetut kielet, JavaScript ei edellytä muuttujan tietotyypin määrittelyä ennen sen käyttöä. Sen sijaan JavaScript määrittää tyypin ajon aikana muuttujan arvon mukaan.

Koska tietotyyppejä ei ole erikseen ilmoitettu ennen suoritusaikaa, kun suoritat eri tietoja vaativia toimintoja tyyppejä, JavaScript tarkistaa automaattisesti niiden yhteensopivuuden toistensa kanssa suoritettavan toiminnon osalta. Jos ne ovat yhteensopivia keskenään, toiminta etenee normaalisti.

Oletetaan kuitenkin, että ne eivät ole yhteensopivia toiminnon kanssa – esimerkiksi yritetään lisätä merkkijono ja numero. Tällaisissa tapauksissa JavaScript automaattisesti "pakottaa" yhden tyypistä sopivaksi toiseen varmistaakseen toiminnon onnistumisen virheen aiheuttamisen sijaan. Tämä prosessi tunnetaan tyyppipakolla tai implisiittisellä pakotuksella.

Tyyppi Pakko

Tyyppipakko on arvon automaattinen muunnos tietotyypistä toiseen, jonka JavaScript suorittaa ohjelman ajon aikana varmistaakseen, että toiminto suoritetaan onnistuneesti.

Mutta kaikkia tietotyyppejä ei voida pakottaa. Merkkijono, numero ja boolean ovat ainoat JavaScript-tietotyypit että kieli pakottaa eri tyyppiin. Kun yrität suorittaa yhteensopimattoman toiminnon tietotyypeillä, joita JavaScript ei voi pakottaa, se antaa virheilmoituksen.

JavaScript pakottaa tyyppejä operaatiotyypin ja operaatiossa käyttämäsi operaattorin perusteella.

Pakottaminen “+”-operaattorilla

JavaScriptissä "+”-operaattorilla on kaksi erilaista käyttäytymistä sen operandityypeistä riippuen. Se voi suorittaa sekä numeerisen lisäyksen että merkkijonojen yhdistämisen. Tämä voi johtaa tyyppipakkotukseen, kun jokin operandeista ei ole odotettua tyyppiä.

Jos molemmat operandit ovat numeroita, "+”operaattori suorittaa lisäyksen:

antaa numero1 = 42;
antaa numero2 = 10;
antaa summa = num1 + num2; // Lisäys
konsoli.log (summa); // 52

Jos molemmat operandit ovat merkkijonoja, "+”-operaattori suorittaa merkkijonojen ketjutuksen:

antaa str1 = "Hei";
antaa str2 = "maailman";
antaa tulos = str1 + " " + str2; // Merkkijonojen ketjutus
konsoli.log (tulos); // "Hei maailma"

Jos jokin operandeista ei kuitenkaan ole merkkijono, JavaScript pakottaa sen implisiittisesti merkkijonoksi ennen ketjutuksen suorittamista:

// Numero ja merkkijono
antaa numero = 42;
antaa str = "Hei";
// Num pakotetaan merkkijonoksi ja sitten ketjutetaan
antaa tulos_1 = numero + str;
konsoli.log (tulos_1); // "42 Hei"
// Merkkijono ja Boolean
antaa bool = totta;
// bool pakotetaan merkkijonoksi ja sitten ketjutetaan
antaa tulos_2 = bool + str;
konsoli.log (tulos_2); // "trueHei"

Pakottaminen "-"-operaattorilla

JavaScriptissä "-”-operaattoria käytetään ensisijaisesti vähennyslaskuoperaatioihin. Kun toinen tai molemmat operandit operaatiossa, johon liittyy "-”-operaattori ei ole numero, JavaScript yrittää pakottaa sen numeroksi.

Kun molemmat operandit ovat numeroita, JavaScript suorittaa vähennyksen. Se suorittaa myös vähennyksen, kun toinen tai molemmat operandit ovat merkkijonoja, jotka edustavat lukua:

konst numero1 = 10;
konst numero2 = 20;
konst tulos_1 = numero2 - numero1; // Vähennys
konsoli.log (tulos_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst tulos = strNum2 - strNum; // Kirjoita numeroihin pakotus ja sitten vähennys
konsoli.log (tulos_1); // 10

Kun kumpikaan operandeista ei ole numero tai numeroa edustava merkkijono, JavaScript yrittää pakottaa tietotyypin numeeriseen vastineensa. Jos tietotyypillä ei ole numeerista vastinetta, toiminto palautuu NaN (Ei numero):

// tosi pakotetaan 1:ksi, false pakotetaan 0:ksi
konst boolNum = totta;
konst boolNum2 = väärä;
konst tulos_1 = boolNum - boolNum2;
konsoli.log (tulos_1); // 1
// tyhjät taulukot pakotetaan arvoon 0
konst arrNum = [];
konst arrNum2 = [];
konst tulos_2 = arrNum - arrNum2;
konsoli.log (tulos_2); // 0
// tyhjät objektit pakotetaan NaN: ään
konst objNum = {};
konst tulos_3 = arrNum - objNum;
konsoli.log (tulos_3); // 0 - NaN = NaN

Tässä esimerkissä JavaScript pakottaa loogiset arvot totta ja väärä niiden numeerisiin vastaaviin arvoihin, 1 ja 0, vastaavasti. Tyhjät taulukot pakotetaan 0, ja tyhjät esineet pakotetaan NaN.

Pakko tasa-arvon (==)/()-operaattoreiden kanssa

JavaScriptissä tasa-arvooperaattorit (== ja ) vertaa tasa-arvon arvoja. He kuitenkin käyttäytyvät eri tavalla tyyppipakon takia.

"==” (löysä tasa-arvo) -operaattori suorittaa tyyppipakotuksen, mikä tarkoittaa, että se yrittää muuntaa operandit samantyyppisiksi ennen vertailua:

"10" == 10; // totta

Tässä esimerkissä JavaScript pakottaa merkkijonon "10" numeroon 10, joten lauseke laskee totta.

Kuitenkin "” (tiukka tasa-arvo) -operaattori ei suorita tyyppipakkoa. Se edellyttää, että arvo ja tyyppi ovat samat, jotta vertailu palaa totta:

"10"10; // väärä

Tässä esimerkissä vertailu palautuu väärä koska operandit ovat erityyppisiä (merkkijono ja numero).

Yleensä kannattaa käyttää (tiukka tasa-arvo) -operaattori JavaScriptissä, jotta vältetään odottamaton tyyppinen pakkokäyttäytyminen.

Tyyppipakko tai implisiittinen muunnos voi johtaa odottamattomaan toimintaan sen automaattisesta luonteesta johtuen. Tapauksissa, joissa sinun on muunnettava tyyppejä, on suositeltavaa muuntaa tyypit erikseen. Tyyppien eksplisiittistä muuntamista kutsutaan tyyppimuunnokseksi. Sitä kutsutaan myös tyyppivaluksi ja eksplisiittiseksi tyyppimuunnokseksi.

Tyyppi muunnos

Tyyppimuunnos, joka tunnetaan myös nimellä tyypin casting, on eksplisiittinen prosessi, jossa arvo muunnetaan yhdestä tietotyypistä toiseen JavaScriptissä käyttämällä sisäänrakennettuja toimintoja, kuten Määrä(), merkkijono(), Boolen(), parseInt(), ja parseFloat().

Voit suorittaa tyyppimuunnoksen välittämällä muunnettavan arvon sisäänrakennetuille muunnosfunktioille argumenttina. Nämä funktiot muuntaa sitten arvosi haluamaasi tyyppiin.

Tässä on esimerkki, jossa käytetään Määrä() toiminto:

konst numStr = "123";
konst numero = Määrä(numStr); // Muuntaa merkkijonon luvuksi
konsoli.log (numero); // 123

Merkkijonon, joka on kelvollinen numero, välittäminen argumenttina Määrä() funktio palauttaa numeron. Virheellisen merkkijonon välitys palautetaan NaN.

Tässä on esimerkki, jossa käytetään merkkijono() toiminto:

konst bool = totta;
konst str2 = merkkijono(bool); // Muuntaa loogisen arvon merkkijonoksi
konsoli.log (str2); // "totta"

Minkä tahansa tietotyypin välittäminen symboliin lukuun ottamatta merkkijono() funktio muuntaa tietotyypin merkkijonoksi.

Tässä on esimerkki, jossa käytetään Boolen() toiminto:

// Muunna merkkijono boolen arvoksi (truthy: true, falsy: false)
konst str = "Hei";
konst bool2 = Boolean(str);
konsoli.log (bool2); // totta

Totuudenmukaisten arvojen välittäminen Boolen() funktio palauttaa loogisen arvon "true", kun taas väärien arvojen välittäminen palauttaa loogisen "false".

Tässä on esimerkki, jossa käytetään ParseInt() ja ParseFloat() toiminto:

// Muuntaa merkkijonon kokonaisluvuksi
konst numStr = "123.00";
konst numero1 = parseInt(numStr);
konsoli.log (num1); // 123
// Muuntaa merkkijonon liukulukuksi
konst floatStr = "3.14";
konst numero2 = parseFloat(floatStr);
konsoli.log (num2); // 3.14

The parseInt() funktio jäsentää merkkijonoargumentin ja palauttaa kokonaisluvun. The parseFloat() funktio muuntaa merkkijonon liukulukuksi.

Hyödynnetty tyyppi pakottaminen ja muuntaminen

Kun ymmärrät tyyppien pakottamisen ja muuntamisen, voit tehdä tietoon perustuvia päätöksiä siitä, milloin ja miten voit hyödyntää niitä tehokkaasti koodissasi. On tärkeää löytää oikea tasapaino käyttämällä tyyppipakkoa harkiten tiiviin ja kätevän koodin saamiseksi ja turvautumalla eksplisiittiseen tyyppimuunnoksen tarkoituksellisiin ja ennakoitaviin tyyppimuunnoksiin.