„JavaScript“ tipo konvertavimo ir prievartos supratimas

„JavaScript“ dinaminis spausdinimas reiškia, kad jūsų kodas gali būti šiek tiek paprastesnis, tačiau vis tiek galima padaryti klaidų. Norint jų išvengti, naudinga žinoti, kaip „JavaScript“ išsprendžia skirtingų tipų reikšmes, jas palyginti.

Norint rašyti patikimas ir efektyvias programas, labai svarbu suprasti „JavaScript“ tipo konvertavimą ir prievartą. Kiekviena koncepcija turi specifinių naudojimo atvejų ir geriausios praktikos pavyzdžių, kurie gali turėti įtakos jūsų kodo veikimui.

Kodėl „JavaScript“ vyksta tipo konvertavimas ir prievarta?

„JavaScript“ kalba yra dinamiškai įvestas. Tai reiškia, kad priešingai nei statiškai įvestų kalbų, JavaScript nereikalauja, kad prieš naudodami jį aiškiai apibrėžtumėte kintamojo duomenų tipą. Vietoj to, „JavaScript“ nustato tipą vykdymo metu, atsižvelgiant į kintamojo reikšmę.

Kadangi duomenų tipai nėra aiškiai deklaruojami iki vykdymo laiko, kai atliekate operacijas, kurioms reikalingi skirtingi duomenys tipų, „JavaScript“ automatiškai patikrina jų suderinamumą su norima atlikti operacija. Jei jie yra suderinami vienas su kitu, operacija vyksta įprastai.

Tačiau tarkime, kad jie nesuderinami su operacija, pavyzdžiui, bandoma pridėti eilutę ir skaičių. Tokiais atvejais „JavaScript“ automatiškai „priverčia“ vieną iš tipų, kad jie atitiktų kitą, kad užtikrintų, jog operacija būtų sėkminga, o ne išmestų klaidą. Šis procesas žinomas kaip tipo prievarta arba numanoma prievarta.

Tipas prievarta

Tipo prievarta – tai automatinis vertės konvertavimas iš vieno duomenų tipo į kitą, kurį „JavaScript“ atlieka programos vykdymo metu, siekiant užtikrinti, kad operacija būtų sėkminga.

Tačiau ne visi duomenų tipai gali būti priversti. Vieninteliai yra eilutė, skaičius ir loginis dydis „JavaScript“ duomenų tipai kad kalba pereis į kitokį tipą. Kai bandysite atlikti nesuderinamą operaciją su duomenų tipais, kurių „JavaScript“ negali priversti, bus rodoma klaida.

„JavaScript“ priverčia tipus pagal operacijos tipą ir operacijos metu naudojamą operatorių.

Prievarta naudojant „+“ operatorių

„JavaScript“ programoje „+” operatorius turi du skirtingus veiksmus, priklausomai nuo jo operandų tipų. Jis gali atlikti tiek skaičių pridėjimą, tiek eilučių sujungimą. Tai gali sukelti tipo prievartą, kai vienas iš operandų nėra laukiamo tipo.

Jei abu operandai yra skaičiai, „+“ operatorius atlieka papildymą:

leisti skaičius1 = 42;
leisti skaičius2 = 10;
leisti suma = skaičius1 + skaičius2; // Papildymas
konsolė.log (suma); // 52

Jei abu operandai yra eilutės, „+” operatorius atlieka eilučių sujungimą:

leisti str1 = "Sveiki";
leisti str2 = "pasaulis";
leisti rezultatas = str1 + " " + str2; // Stygų sujungimas
konsolė.log (rezultatas); // "Labas pasauli"

Tačiau jei vienas iš operandų nėra eilutė, „JavaScript“ netiesiogiai privers jį į eilutę prieš atlikdama sujungimą:

// Skaičius ir eilutė
leisti skaičius = 42;
leisti str = "Sveiki";
// skaičius priverčiamas į eilutę ir tada sujungiamas
leisti rezultatas_1 = skaičius + str;
konsolė.log (rezultatas_1); // "42 Sveiki"
// Styga ir Būlio reikšmė
leisti bool = tiesa;
// bool sujungiama į eilutę ir tada sujungiama
leisti rezultatas_2 = bool + str;
konsolė.log (rezultatas_2); // "tikras labas"

Prievarta su „-“ operatoriumi

„JavaScript“ programoje „-“ operatorius pirmiausia naudojamas atimties operacijoms. Kai vienas arba abu operandai operacijoje, kurioje dalyvauja „-“ operatorius nėra skaičius, „JavaScript“ bandys jį įvesti į skaičių.

Kai abu operandai yra skaičiai, JavaScript atlieka atimtį. Jis taip pat atlieka atimtį, kai vienas arba abu operandai yra eilutės, žyminčios skaičių:

konst skaičius1 = 10;
konst skaičius2 = 20;
konst rezultatas_1 = skaičius2 - skaičius1; // Atimtis
konsolė.log (rezultatas_1); // 10
konst strNum = "10";
konst strNum2 = "20";
konst rezultatas = strNum2 - strNum; // Įveskite skaičių prievartą, tada atimtį
konsolė.log (rezultatas_1); // 10

Kai nė vienas iš operandų nėra skaičius arba skaičių atvaizduojanti eilutė, „JavaScript“ bandys nustatyti duomenų tipą iki jo skaitmeninio ekvivalento. Jei duomenų tipas neturi skaitmeninio atitikmens, operacija bus atlikta NaN (Ne skaičius):

// tiesa priverčiama iki 1, klaidinga – iki 0
konst boolSkaičius = tiesa;
konst boolNum2 = klaidinga;
konst rezultatas_1 = boolSkaičius - boolSkaičius2;
konsolė.log (rezultatas_1); // 1
// tušti masyvai priverčiami iki 0
konst arrNum = [];
konst arrNum2 = [];
konst rezultatas_2 = arrNum - arrNum2;
konsolė.log (rezultatas_2); // 0
// tušti objektai priverčiami į NaN
konst objSkaičius = {};
konst rezultatas_3 = arrSkaičius - objSkaičius;
konsolė.log (rezultatas_3); // 0 - NaN = NaN

Šiame pavyzdyje „JavaScript“ priverčia logines reikšmes tiesa ir klaidinga į jų skaitines ekvivalentines vertes, 1 ir 0, atitinkamai. Priverčiami tušti masyvai 0, o tušti objektai verčiami NaN.

Prievarta su lygybe (==)/() operatoriai

„JavaScript“ lygybės operatoriai (== ir ) palyginkite lygybės vertes. Tačiau dėl tipo prievartos jie elgiasi skirtingai.

„==” (laisvos lygybės) operatorius atlieka tipo prievartą, ty prieš palyginimą bando konvertuoti operandus į tą patį tipą:

"10" == 10; // tiesa

Šiame pavyzdyje „JavaScript“ priverčia eilutę „10“ į skaičių 10, todėl išraiška vertinama kaip tiesa.

Tačiau „” (griežta lygybė) operatorius tipo prievartos neatlieka. Kad palyginimas būtų grąžintas, vertė ir tipas turi būti vienodi tiesa:

"10"10; // netikras

Šiame pavyzdyje palyginimas grąžinamas klaidinga nes operandai yra skirtingų tipų (eilutės ir skaičių).

Paprastai turėtumėte naudoti (griežta lygybė) operatorius JavaScript, kad būtų išvengta netikėto tipo prievartos elgesio.

Tipo prievarta arba numanomas konvertavimas gali sukelti netikėtą elgesį dėl automatinio pobūdžio. Tais atvejais, kai reikia konvertuoti tipus, patartina aiškiai konvertuoti tipus. Aiškaus tipų konvertavimo procesas yra žinomas kaip tipo konvertavimas. Jis taip pat vadinamas tipo liejimu ir aiškiu tipo konvertavimu.

Tipas Konversija

Tipo konvertavimas, taip pat žinomas kaip tipo liejimas, yra aiškus vertės konvertavimas iš vieno duomenų tipo į kitą JavaScript naudojant įtaisytąsias funkcijas, pvz. Skaičius (), Eilutė (), Būlio reikšmė (), parseInt(), ir parseFloat().

Galite atlikti tipo konvertavimą, kaip argumentą perduodami vertę, kurią norite konvertuoti, į integruotas konvertavimo funkcijas. Šios funkcijos konvertuoja jūsų vertę į norimą tipą.

Štai pavyzdys naudojant Skaičius () funkcija:

konst numStr = "123";
konst skaičius = Skaičius(skaičiusStr); // Konvertuoja eilutę į skaičių
konsolė.log (skaičius); // 123

Eilutės, kuri yra tinkamas skaičius, kaip argumento perdavimas Skaičius () funkcija grąžins skaičių. Perdavus eilutę, kuri yra neteisingas skaičius, bus grąžinta NaN.

Štai pavyzdys naudojant Eilutė () funkcija:

konst bool = tiesa;
konst str2 = Styga(bool); // Konvertuoja loginę reikšmę į eilutę
konsolė.log (str2); // "tiesa"

Bet kokio tipo duomenų, išskyrus simbolį, perdavimas į Eilutė () funkcija konvertuos duomenų tipą į eilutę.

Štai pavyzdys naudojant Būlio reikšmė () funkcija:

// Konvertuoti eilutę į loginę (truthy: true, falsy: false)
konst str = "Sveiki";
konst bool2 = Būlio(str);
konsolė.log (bool2); // tiesa

Tikrų vertybių perdavimas Būlio reikšmė () funkcija grąžina loginį „true“, o perduodant klaidingas reikšmes, grąžina loginį „false“.

Štai pavyzdys naudojant ParseInt() ir ParseFloat() funkcija:

// Konvertuoti eilutę į sveikąjį skaičių
konst numStr = "123.00";
konst skaičius1 = parseInt(skaičiusStr);
konsolė.log (num1); // 123
// Konvertuoti eilutę į slankiojo kablelio skaičių
konst floatStr = "3.14";
konst skaičius2 = parseFloat(floatStr);
konsolė.log (num2); // 3.14

The parseInt() funkcija analizuoja eilutės argumentą ir grąžina sveikąjį skaičių. The parseFloat() funkcija konvertuoja eilutę į slankiojo kablelio skaičių.

Tipo prievartos ir konversijos panaudojimas

Suprasdami tipo prievartą ir konvertavimą, galite priimti pagrįstus sprendimus, kada ir kaip juos veiksmingai panaudoti savo kode. Svarbu rasti tinkamą pusiausvyrą, apgalvotai naudojant tipo prievartą, kad kodas būtų glaustas ir patogus, ir pasikliaujant aiškiu tipo konvertavimu, kad būtų tyčinis ir nuspėjamas tipo konvertavimas.