„JavaScript“ suskirsto duomenis į tipus, o tai padeda grupuoti duomenis ir nustatyti, kokias reikšmes galima priskirti ir kokias operacijas galima atlikti.

Nors „JavaScript“ automatiškai konvertuoja daugelį reikšmių dėl tipo perdavimo, geriausia duomenų tipus konvertuoti rankiniu būdu, kad būtų pasiekti laukiami rezultatai.

Ši pamoka išmokys jus konvertuoti primityvius „JavaScript“ duomenų tipus, įskaitant skaičius, eilutes ir loginius duomenis.

JavaScript programavimo kalba labai gerai valdo netikėtas reikšmes. „JavaScript“ neatmeta netikėtų verčių, o bando konvertuoti. Ši numanoma konversija dar vadinama tipo prievarta.

Tam tikri metodai automatiškai konvertuoja reikšmes, kad jas būtų galima naudoti. Alert() metodas naudoja eilutę kaip savo parametrą ir automatiškai konvertuoja kitus tipus į eilutes. Taigi šiam metodui galite perduoti skaitinę reikšmę:

Jei paleisite šią eilutę, naršyklė grąžins iššokantįjį langą su reikšme 8.5, kuris jau bus konvertuotas į eilutę.

Naudodami skaičių eilutes kartu su matematiniais operatoriais, pastebėsite, kad „JavaScript“ gali apdoroti reikšmes netiesiogiai konvertuodama eilutes į skaičius:

// Atimtis
"15" - "10";
5
// Modulis
"15" % "10";
5

Tačiau ne visi operatoriai dirba nuspėjamai. Tai ypač pasakytina apie operatorių +: jis atlieka skaičių pridėjimą ir eilučių sujungimą.

// Dirbant su eilutėmis, + atlieka sujungimą
"2" + "3";
"23"

Kadangi operatorius + turi daugybę naudojimo būdų, šiame pavyzdyje jis 2 ir 3 reikšmes traktuoja kaip eilutes, net jei jos išreiškiamos kaip skaitinės eilutės. Todėl jis sujungia eilutes „2“ ir „3“ ir gauna 23, o ne prideda 2 ir 3 ir gauna 5.

Toks dviprasmiškumas atsiranda kode ir kartais sukelia netikėtų rezultatų, todėl geriau, kai tik įmanoma, aiškiai konvertuoti duomenų tipus. Tai padės prižiūrėti kodą ir tvarkyti klaidas.

Norėdami aiškiai konvertuoti reikšmę į eilutę, iškvieskite metodą String() arba n.toString().

Pabandykite konvertuoti loginę reikšmę true į eilutę naudodami String().

Tai grąžins eilutę „true“.

Taip pat galite pabandyti perduoti skaičių funkcijai:

Tai grąžins eilutę:

Dabar pabandykite naudoti String() su kintamuoju. Odisėjos kintamajam priskirkite skaitinę reikšmę ir tipui patikrinti naudokite operatoriaus tipą.

tegul odisėja = 2001;
console.log(odisėjos tipas);
numerį

Šiuo metu kintamajam odisėja yra priskirta skaitinė reikšmė 2001. Operatoriaus tipas patvirtina, kad reikšmė yra skaičius.

Dabar priskirkite kintamąjį Odyssey jo ekvivalentui funkcijoje String() ir naudokite typeof, kad įsitikintumėte, jog kintamojo reikšmė sėkmingai konvertuojama iš skaičiaus į eilutę.

odisėja = String(odisėja); // "2001"
console.log(odisėjos tipas);
styga

Kaip matote, odisėjos kintamajame dabar yra eilutė.

Funkcija n.toString() veikia panašiai. Pakeiskite n kintamuoju.

tegul smūgiai = 400;
blows.toString();

Smūgių kintamajame bus eilutė.

Vietoj kintamojo skliausteliuose galite įdėti reikšmę:

(1776).toString(); // grąžina "1776"
(false).toString(); // grąžina "false"
(100 + 200).toString(); // grąžina "300"

String() ir n.toString() aiškiai konvertuoja logines ir skaitines reikšmes į eilutes.

Skaičių () metodas gali konvertuoti reikšmę į skaičių. Dažnai reikia konvertuoti eilutes, sudarytas iš skaičių, tačiau kartais reikia konvertuoti ir Būlio reikšmes.

Pavyzdžiui, perduokite šią eilutę į skaičių() metodą:

Eilutė bus paversta skaičiumi ir nebebus cituojama.

Taip pat kintamajam galite priskirti eilutę ir ją konvertuoti.

tegul dalmatinas = "101";
Skaičius (dalmatinai);
101

Eilutės raidė „101“ buvo konvertuota į skaičių 101.

Tarpų eilutės arba tuščios eilutės bus konvertuojamos į skaičių 0.

Skaičius (" "); // grąžina 0
Skaičius (""); // grąžina 0

Atminkite, kad eilutės, kurias sudaro skaičiai, konvertuojamos į NaN, o tai reiškia ne skaičių. Tai taip pat taikoma tarpais atskirtiems skaičiams.

Skaičius ("dvylika"); // grąžina NaN
Skaičius("20 000"); // grąžina NaN
Skaičius("2 3"); // grąžina NaN
Skaičius ("11-11-11"); // grąžina NaN

Būlio duomenyse false bus 0, o tiesa bus 1.

Norint konvertuoti skaičius ar eilutes į logines reikšmes, naudojamas Boolean() metodas. Pavyzdžiui, jis padeda nustatyti, ar vartotojas įveda duomenis į teksto lauką, ar ne.

Bet kuri reikšmė, kuri interpretuojama kaip tuščia, pvz., skaičius 0, tuščia eilutė, neapibrėžta, NaN arba nulis, konvertuojama į klaidingą.

Būlio (0); // grąžina false
Būlio reikšmė (""); // grąžina false
Būlio reikšmė (neapibrėžta); // grąžina false
Būlio (NaN); // grąžina false
Būlio reikšmė(nulis); // grąžina false

Kitos reikšmės, įskaitant eilučių literalius, sudarytus iš tarpų, bus konvertuotos į true.

Būlio (2000); // grąžina tiesa
Būlio reikšmė (" "); // grąžina tiesa
Būlio („Maniakai“); // grąžina tiesa

Atminkite, kad eilutės raidė „0“ konvertuojama į tikrąją, nes tai nėra tuščia reikšmė:

Būlio reikšmė ("0"); // grąžina tiesa

Skaičių ir eilučių konvertavimas į logines reikšmes leidžia duomenis įvertinti dvejetainiu būdu ir gali būti naudojamas srautui programose valdyti.

Dabar žinote, kaip „JavaScript“ konvertuoja duomenų tipus. Dažnai dėl tipo liejimo duomenys netiesiogiai konvertuojami, todėl gali atsirasti netikėtų verčių. Norint užtikrinti, kad programos veiktų tinkamai, rekomenduojama aiškiai konvertuoti duomenų tipus.

Paskutinis atnaujinimas: 2015-11-01

Dažnai vienus duomenis reikia paversti kitais. Pavyzdžiui:

Variklio skaičius1 = "46"; var number2 = "4"; var rezultatas = skaičius1 + skaičius2; console.log(result); //464

Abu kintamieji žymi eilutes arba, tiksliau, skaičių eilutes. Ir galų gale gausime ne skaičių 50, o eilutę 464. Bet būtų gerai, jei juos būtų galima sudėti, atimti ir apskritai dirbti kaip su paprastais skaičiais.

Šiuo atveju galime naudoti konvertavimo operacijas. Norėdami konvertuoti eilutę į skaičių, naudokite funkciją parseInt():

Variklio skaičius1 = "46"; var number2 = "4"; var rezultatas = parseInt(skaičius1) + parseInt(skaičius2); console.log(result); // 50

Norėdami konvertuoti eilutes į trupmeninius skaičius, naudokite funkciją parseFloat():

Var number1 = "46,07"; var number2 = "4,98"; var rezultatas = parseFloat(skaičius1) + parseFloat(skaičius2); console.log(result); //51.05

Šiuo atveju eilutėje gali būti mišraus turinio, pavyzdžiui, „123hello“, tai yra, šiuo atveju yra skaičiai, bet yra ir įprastų simbolių. Tačiau metodas parseInt() vis tiek bandys atlikti konversiją:

Var num1 = "123labas"; var num2 = parseInt(num1); console.log(num2); // 123

Jei metodui nepavyksta konvertuoti, jis grąžina NaN (ne skaičių), o tai rodo, kad eilutė neatspindi skaičiaus ir negali būti konvertuojama.

Norėdami patikrinti, ar eilutė reiškia skaičių, galite naudoti specialią funkciją isNaN(). Jei eilutė nėra skaičius, funkcija grąžina true, jei tai yra skaičius, tada false:

Var num1 = "javascript"; var num2 = "22"; var rezultatas = isNaN(num1); console.log(result); // tiesa - skaičius1 nėra skaičius rezultatas = isNaN(skaičius2); console.log(result); // false – skaičius2 yra skaičius

Aukščiau pažvelgėme į eilučių konvertavimą į skaičius dešimtainėje sistemoje. Tačiau skaičius galime konvertuoti į bet kurią sistemą. Pagal numatytuosius nustatymus JavaScript interpretatorius pats atspėja, į kurią skaičių sistemą norime konvertuoti eilutę (dažniausiai pasirenkama dešimtainė sistema). Tačiau galime naudoti antrąjį parametrą, kad aiškiai nurodytume, jog norime konvertuoti eilutę į skaičių konkrečioje sistemoje. Pavyzdžiui, konvertavimas į dvejetainį skaičių:

Var num1 = "110"; var num2 = parseInt(skaičius1, 2); console.log(num2); // 6

Rezultatas yra 6, nes 110 dvejetainėje sistemoje yra tas pats, kas 6 dešimtaine.

Dabar parašykime nedidelę programą, kurioje naudojame operacijas su kintamaisiais:

JavaScript var strSum = prompt("Įveskite įmokos sumą", 1000); var strPercent = prompt("Įveskite palūkanų normą", 10); var suma = parseInt(strSum); var procentas = parseInt(strProcentas); suma = suma + suma * procentas / 100; alert("Apskaičiavus palūkanas, indėlio suma bus: " + suma);

Funkcija prompt() naršyklėje rodo dialogo langą, kuriame prašoma įvesti reikšmę. Antrasis šios funkcijos argumentas nurodo reikšmę, kuri bus naudojama kaip numatytoji.

Tačiau funkcija prompt() grąžina eilutę. Todėl turime konvertuoti šią eilutę į skaičių, kad galėtume su ja atlikti operacijas.

Naršyklėje atidarę puslapį pamatysime raginimą įvesti įmokos sumą:

Tada pasirodys panašus pranešimas apie procentų įvedimą. Ir pabaigoje programa gaus duomenis, konvertuos juos į skaičius ir atliks skaičiavimą.

Nėra skirtumo, kokio tipo kintamasis naudojamas išraiškoje. Jei išraiška yra matematinė, visi jos kintamieji bus automatiškai interpretuojami kaip skaitiniai. Jei eilutės apdorojamos, tada visi išraiškos „dalyviai“ laikomi eilutėmis. Tačiau „JavaScript“ konvertavimo iš eilutės į skaičių iššūkis egzistuoja daug platesniame kontekste.

Eilučių konvertavimo į skaičius metodų arsenalas nėra didelis, tačiau visais paprastais atvejais jo pakanka. Čia JavaScript (ypač pradedantiesiems) yra kelias nuo paprasto iki sudėtingo naudojant praktinius pavyzdžius.

Pavyzdyje aprašomos keturios skirtingos eilutės. Pirmajame išvesties bloke funkcija typeof apibrėžia kiekvieno kintamojo tipą kaip eilutę. Tada kiekviena eilutė labai paprastai konvertuojama į skaičių. Antrame išvesties bloke matomi kintamųjų pokyčiai po konvertavimo, jų tipas tapo skaičiumi. „JavaScript parseFloat“ konversijos pavyzdys yra ypač iliustratyvus: jis buvo „12e+3“ ir tapo „12000“.

Pakeitimai konvertuojant eilutę į skaičių gali būti reikšmingi! Tačiau svarbūs tik pirmieji simboliai: jie turi būti skaitiniai. Jei nėra skaitmenų simbolių, rezultatas bus NaN.

Atvirkštinis eilutės, kuri "tampa" skaičiumi, konvertavimas ne visada yra ta pati eilutė. Šis taškas gali būti naudojamas norint patikrinti skaitinės informacijos įvedimo teisingumą.

Atitinkamai yra sveikieji skaičiai ir trupmeniniai skaičiai, „JavaScript“ paverčia eilutę į skaičių:

• parseInt;
• parseFloat.

Bendrasis atvejis įgyvendinamas naudojant eilutę paprastoje matematinėje išraiškoje.

Pakanka prieš simbolių eilutę įdėti ženklą „+“ ir, jei joje yra skaičius, išraiškos rezultatas bus skaičius. Kintamojo reikšmė gali keistis, bet tipas visada pasikeis: typeof rodys skaičių, o ne eilutę. Svarbu suprasti, kad naudojant konvertuotą kintamąjį eilutės išraiškoje, rezultatas gali būti visiškai kitoks.

„JavaScript“ pradedantiesiems šiame kontekste yra labai paprasta. Sunkiau suprasti sveikųjų skaičių konvertavimo operaciją naudojant pasrseInt metodą, nes jis automatiškai veikia dešimtainėje skaičių sistemoje, tačiau eilutę gali interpretuoti kaip aštuntainį arba šešioliktainį. Tačiau ši aplinkybė ne visada priklauso nuo antrojo parametro, kuris nurodo skaičių sistemą.

„JavaScript“ visada pavers eilutę skaičiumi, tačiau jei eilutėje eilutės pradžioje nėra nė vieno skaitmeninio simbolio, rezultatas bus NaN.

Būtina suprasti skaičių sistemas, kaip rašyti šešioliktainius (skaičius prasideda "0x") ir aštuntuosius skaičius (skaičius prasideda "0").

Norint suprasti „JavaScript“ parseFloat metodo niuansus, pakanka turėti idėją, kas yra matematinis tikrojo skaičiaus žymėjimas.

„JavaScript“ yra naršyklės kalba, todėl ji svarbesnė nei kitos kalbos simboliams, nepriklausantiems pagrindiniam lotyniškos abėcėlės ir skaičių rinkiniui. Rūšiavimas yra populiari operacija. Tačiau ne visada prasminga siųsti duomenis į serverį rūšiavimo tikslais; lengviau ir praktiškiau darbą atlikti vietoje, naršyklėje.

Norėdami išspręsti šią problemą, eilutės simbolius galite paversti skaitiniais kodais arba raidėms ir skaičiams priskirti sutvarkytą skaičių seką. Eilutei taikomas metodas charCodeAt() kintamajam iB priskirs skaitinę reikšmę 98, tai yra raidės "b" kodą. Atsižvelgiant į tai, kad raidės „a“ kodo reikšmė yra 97, galite gauti visų lotyniškos abėcėlės raidžių skaičius didėjančia tvarka mažųjų ir didžiųjų raidžių rinkiniais. Panašiai ir rusų abėcėlės raidėms.

Mūsų pačių sukurta rūšiavimo pagal skaičius versija leidžia sukurti reikiamus simbolių rinkinius. Pavyzdžiui, galite „pertvarkyti“ kirilicą ir lotynišką abėcėlę arba jas maišyti, kad liktų tik raidės, kurių rašyba skiriasi, arba į rinkinius įtraukti tabuliavimo ir tarpo simbolius.

Jei raidės „a“ kodas yra 97, tai skirtumas tarp raidės ir skaičiaus 97 suteiks unikalų raidės numerį abėcėlėje. Susumavus unikalius kiekvienos eilutės simbolio skaičius, sunku gauti unikalų tos eilutės numerį.

Jei kiekvienai eilutės raidės vietai priskiriate svorį, pavyzdžiui, pozicija:

• 0 svoris 1;
• 1 svoris 10;
• 2 svoris 100;

tada padauginę unikalų kiekvieno simbolio skaičių eilutėje iš padėties, kurioje jis rastas, svorio ir susumavus visus skaičius, galite gauti unikalų skaičių ir naudoti jį kaip originalo atitikimą vienas su vienu. styga.

Šis eilutės konvertavimas į skaičių yra grįžtamasis, ty visada galite gauti pradinę eilutę iš skaičiaus. Toks konvertavimas yra naudingas, nes bet kurią operaciją galima saugiai atlikti naudojant numerį, atsižvelgiant į kodavimą, kirilicą ir kitas vietines svetainės puslapio funkcijas, taikymo sritį ir lankytojo šalį.

Dažnai iškyla užduotis interneto puslapiuose sukurti selektorius, kurių reikšmės iš anksto negali būti nurodytos, tačiau laikui bėgant jos papildomos. Pačioje pirmoje programoje pirmasis lankytojas gali įvesti informaciją tuščias parinkiklis.

Kiekviena nauja informacijos eilutės įvestis į selektorių (bet kurio lankytojo) paverčiama skaičiumi, kuris kartu su originalu siunčiamas saugoti į serverį. Kai prasideda nauja sesija arba atvyksta naujas lankytojas, parinkiklis nebėra tuščias. Kai puslapis įkeliamas, jis ateina į naršyklę su netuščiu parinkikliu.

Kiekvienai naujai parinkiklio reikšmei ji siunčiama į serverį saugoti tik vieną kartą ir tik vieną kartą priskiriamas unikalus skaitmeninis kodas.

Norint išspręsti šią problemą, negalima naudoti „JavaScript“ eilutės į skaičių metodo. Įprasti metodai parseInt ir parseFloat yra skirti kitiems tikslams, tačiau galite sugalvoti algoritmą, kaip vienareikšmiškai konvertuoti eilutę į skaičių, o nebūtinai į apverčiamą. Pakanka, kad konvertavimo algoritmas nepasikartotų skirtinguose eilutės simbolių rinkiniuose.

Kurdamas puslapį kūrėjas naudoja didelius informacijos kiekius. Leidimas lankytojui įvesti informaciją yra geras būdas sumažinti svetainės reitingą dėl prasto funkcionalumo ir nuvilti lankytoją.

Lankytojo veiksmams tam tikriems informacijos blokams priskyrus įvykių tvarkyklę JavaScript funkcijos pavidalu, galima suformuluoti filtrą, kuris leis lankytojui tiksliai išsikelti tikslą, rasti reikiamą informaciją, gauti norimą sprendimą. .

Stygos informacijos transformacija čia gali būti savavališkai didelė eilutės dalyje ir labai maža skaičių dalyje. Kitaip tariant, kūrėjas konvertuoja „JavaScript“ eilutę į skaičių, naudodamas savo algoritmą. Lankytojas manipuliuoja suprantama informacija, o į serverį siunčiamas minimalus duomenų kiekis – skaičius.

Skaičių rinkinio visiems lankytojams dinamika tiksliai žinomos informacijos kontekste leidžia kitai JavaScript funkcijai (ne tvarkyklei), iškviečiamai serverio atsakymą per AJAX mechanizmą, greitai pateikti visiems lankytojams reikiamą informaciją vienu metu realiuoju laiku. . Taip veikia sistema.

Ši JavaScript eilutės konvertavimo į skaičių parinktis yra labai populiari kuriant internetinius žaidimus, interaktyvias konferencijas, momentinius pranešimus ir pan.

„JavaScript“ ir CSS, apdorojant skaitmeninę informaciją, leidžia valdyti puslapio rodymą nedalyvaujant serveriui. CSS taisyklės kuriamos kaip poeilutės, rekursyviai. Paprastai parametras yra skaičius, po kurio eina kelios raidės (pavyzdžiui, "px", "pt", "em", ...). Parametras yra taisyklės poeilutė, o taisyklė yra klasės arba identifikatoriaus stiliaus poeilutė.

JavaScript recursion.Substring.Substring... suranda norimą skaičių, konvertuoja jį iš eilutės į skaičių, pakeičia ir įrašo atgal į norimą vietą. Taisyklė pasikeičia automatiškai. Tai paprasta ir patogu, serveris nedalyvauja.

Funkcija parseInt() analizuoja eilutės argumentą ir grąžina sveikąjį skaičių nurodytos raidės (matematinių skaičių sistemų bazės).

Šio interaktyvaus pavyzdžio šaltinis saugomas „GitHub“ saugykloje. Jei norite prisidėti prie interaktyvių pavyzdžių projekto, klonuokite https://github.com/mdn/interactive-examples ir atsiųskite mums užklausą.

Sveikasis skaičius, išanalizuotas iš pateiktos eilutės .

Jei raidė yra mažesnė nei 11, o pirmasis ne tarpo simbolis negali būti paverstas skaičiumi, grąžinamas NaN.

Funkcija parseInt konvertuoja savo pirmąjį argumentą į eilutę, išanalizuoja tą eilutę, tada grąžina sveikąjį skaičių arba NaN .

Jei ne NaN, grąžinama vertė bus sveikasis skaičius, kuris yra pirmasis argumentas, paimtas kaip skaičius nurodytoje raidėje. (Pavyzdžiui, 10 radiksas konvertuoja iš dešimtainio skaičiaus, 8 – iš aštuntainio, 16 – iš šešioliktainio skaičiaus ir t. t.)

Jei radikalai yra didesni nei 10, angliškos abėcėlės raidės žymi skaitmenis, didesnius nei 9. Pavyzdžiui, šešioliktainiams skaičiams (16 bazė) naudojami nuo A iki F.

Jei parseInt aptinka simbolį, kuris nėra skaitmuo nurodytoje raidėje , jis nepaiso jo ir visų tolesnių simbolių ir grąžina sveikojo skaičiaus reikšmę, išanalizuota iki to taško. ParseInt sutrumpina skaičius iki sveikųjų skaičių. Leidžiamos priekinės ir užpakalinės erdvės.

Kadangi kai kurie skaičiai savo eilutės vaizde naudoja e simbolį (pvz., 6,022e23, kai yra 6,022 × 10 23), naudojant parseInt skaičiams sutrumpinti, gaunami netikėti rezultatai, kai naudojami labai dideliems arba labai mažiems skaičiams. parseInt turėtų ne būti naudojamas kaip Math.floor() pakaitalas.

parseInt supranta tiksliai du ženklus: + teigiamą ir - neigiamą (nuo ECMAScript 1). Tai atliekama kaip pradinis analizės veiksmas pašalinus tarpą. Jei ženklų nerandama, algoritmas pereina prie kito žingsnio; kitu atveju jis pašalina ženklą ir paleidžia skaičių analizę likusioje eilutės dalyje.

Jei radix yra neapibrėžtas , 0 arba nenurodytas, JavaScript daro prielaidą, kad:

Jei pirmojo simbolio negalima konvertuoti į skaičių, parseInt grąžina NaN, nebent radiksas yra didesnis nei 10.

Aritmetiniais tikslais NaN reikšmė nėra skaičius jokiame radikse. Norėdami nustatyti, ar parseInt rezultatas yra NaN, galite iškviesti funkciją isNaN. Jei NaN perkeliama į aritmetines operacijas, operacijos rezultatas taip pat bus NaN .

Norėdami konvertuoti skaičių į eilutės literalą tam tikrame radikse, naudokite tą skaičių .toString(radix) .

Visi šie pavyzdžiai grąžina 15:

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // bet `parseInt(015, 10)` bus return 13 parseInt(15.99, 10) parseInt("15,123", 10) parseInt("FXX123", 16) parseInt("1111", 2) parseInt("15 * 3", 10) parseInt("15e2", 10) parseInt("15px", 10) parseInt("12", 13)

Visi šie pavyzdžiai grąžina NaN:

ParseInt("Sveiki", 8) // Visai ne skaičius parseInt("546", 2) // Kiti skaitmenys nei 0 arba 1 yra netinkami dvejetainiam radiksui

Visi šie pavyzdžiai grąžina -15:

ParseInt("-F", 16) parseInt("-0F", 16) parseInt("-0XF", 16) parseInt(-15.1, 10) parseInt("-17", 8) parseInt("-15", 10) parseInt("-1111", 2) parseInt("-15e1", 10) parseInt("-12", 13)

Visi šie pavyzdžiai grąžina 4:

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Labai didelis skaičius tampa 4 parseInt(0.00000000000434, 10) // Labai mažas skaičius tampa 4

Šis pavyzdys grąžina 224:

ParseInt("0e0", 16) parseInt("123_456") // 123

Nors ECMAScript 3 to neskatina ir ECMAScript 5 draudžia, daugelis įdiegimų skaitinę eilutę, prasidedančią pirmuoju 0, interpretuoja kaip aštuntainį. Toliau pateiktame rezultate gali būti aštuntainis arba dešimtainis rezultatas. Visada nurodykite šaknį, kad išvengtumėte šio nepatikimo elgesio.

ParseInt("0e0") // 0 parseInt("08") // 0, nes "8" nėra aštuntainis skaitmuo.

Funkcijos parseInt ECMAScript 5 specifikacija nebeleidžia diegiant eilutes, prasidedančias 0 simboliu, laikyti aštuontainėmis reikšmėmis. ECMAScript 5 teigia:

Funkcija parseInt sukuria sveikojo skaičiaus reikšmę, padiktuotą interpretuojant eilutės argumento turinį pagal nurodytą radiksą. Pirmaujantis tarpas eilutėje yra ignoruojamas. Jei raidė neapibrėžta arba 0, laikoma, kad ji yra 10, išskyrus atvejus, kai skaičius prasideda simbolių poromis 0x arba 0X, tokiu atveju tariamas 16.

Tai skiriasi nuo ECMAScript 3, kuris buvo nerekomenduojamas, bet leido interpretuoti aštuonetą.

Daugelis diegimų nepritaikė šios elgsenos nuo 2013 m., todėl turi būti palaikomos senesnės naršyklės, todėl visada nurodykite šaknį .

Kartais naudinga turėti griežtesnį sveikųjų skaičių analizavimo būdą.

Įprastos išraiškos gali padėti:

Funkcija filterInt(value) (if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt( "421 ")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Begalybė")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // NaN console .log (filterInt("1.61803398875")) // NaN

Šiame puslapyje esanti suderinamumo lentelė sukurta iš struktūrinių duomenų. Jei norite prisidėti prie duomenų, apsilankykite https://github.com/mdn/browser-compat-data ir atsiųskite mums užklausą.

Atnaujinkite GitHub suderinamumo duomenis

„JavaScript“ turi 2 integruotas funkcijas, skirtas konvertuoti eilutes į skaičius: parseFloat() ir parseInt() .

parseFloat() kaip argumentą paima eilutę, kuri turi būti konvertuojama į skaitinį tipą, ir grąžina slankiojo skaičiaus. Skaičius turi būti eilutės pradžioje. Jei eilutėje po skaičiaus yra kitų simbolių, jie nupjaunami. Skaičiaus trupmeninė dalis turi būti rašoma atskiriant tašku (kablelis nesuvokiamas kaip skyriklis). Jei parseFloat() negali konvertuoti eilutės, ji grąžina NaN.

Funkcija taip pat gali apdoroti „skaičius n, padaugintas iš 10 iki x laipsnio“, kuris programuojant paprastai rašomas raide E, pavyzdžiui: 0,5E6 arba 0,5E+6. Laipsnis taip pat gali būti neigiamas: 0,5E-6, kuris yra lygus 0,5*10^-6 arba 0,5/1000000.

ParseFloat(""3.78kg"") // 3.78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4.111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003

Funkcija parseInt(string[, radix]) paima eilutę kaip pirmąjį argumentą, ją išanalizuoja ir grąžina sveikąjį skaičių (tipo integer). Funkcija bando analizuoti skaičių sistemą, kurioje įrašytas skaičius šaltinio eilutėje (pavyzdžiui, dešimtainis, aštuntainis arba šešioliktainis – bet ne tik šie). Taip pat galite aiškiai nurodyti skaičių sistemą, pateikdami ją kaip antrojo parametro radiksą. Radix parametras gali būti bet koks skaičius nuo 2 iki 36 (sistemose, didesnėse nei 10, naudojamos angliškos abėcėlės raidės nuo A iki Z).

Funkcija neapdoroja skaičių, tokių kaip 1.5e6, kaip parseFloat() .

Perskaitykite toliau pateiktus pavyzdžius, kad nesukluptumėte spąstų, paslėptų veikiant funkcijai parseInt().

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt("45.12"") // 45 parseInt(""045",10) // 45 parseInt( ""70",8) // 56 (70 aštuntainėje yra 56 dešimtainėje) parseInt(""070"") // 56 (SVARBU!!! jei pirmiausia nulis, funkcija išnagrinės eilutę kaip aštuntąjį skaičių ) parseInt(" "88",8) // NaN (aštuontainėje sistemoje nėra 8 skaitmens) parseInt(""a1"") // NaN (SVARBU!!! Numatytoji funkcija skaičius nelaikomas kaip šešioliktainis, jei jis nepridėtas prie pradžios eilučių 0x) parseInt(""a1",16) // 161 (čia aiškiai nurodyta skaičių sistema) parseInt(""0xa1"") // 161 (teisinga šešioliktainio skaičiaus formatas , nereikia nurodyti antrojo parametro) parseInt( ""099"") // 0 (SVARBU!!! Skaičius traktuojamas kaip aštuntainis, bet jame yra neteisingų simbolių) parseInt(""0.5e6"") / / 0 (SVARBU!!! neveikia kaip parseFloat) parseInt("" ZZ",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF",16) / / -255

Jei analizuojate vartotojo įvestį iš teksto lauko, visada naudokite parseInt() kartu su antruoju radix parametru, kad apsaugotumėte kodą nuo netikėtų rezultatų.