A JavaScript 2 beépített funkcióval rendelkezik a karakterláncok számokká alakításához: parseFloat() és parseInt() .
A parseFloat() argumentumként egy karakterláncot vesz fel, amelyet numerikus típussá kell alakítani, és egy lebegőpontos számot ad vissza. A számnak a sor elején kell lennie. Ha a karakterláncban a szám után további karakterek vannak, akkor azok le lesznek vágva. A szám tört részét ponton keresztül kell beírni (a vesszőt nem tekintjük elválasztónak). Ha a parseFloat() nem tudja átalakítani a karakterláncot, akkor NaN-t ad vissza.
Ezenkívül a függvény képes feldolgozni "az n számot 10-zel szorozva x hatványára", amelyet a programozásban általában E betűvel írnak le, például: 0,5E6 vagy 0,5E+6. A mérték negatív is lehet: 0,5E-6, ami 0,5*10^-6 vagy 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
A parseInt(string[, radix]) függvény egy karakterláncot vesz fel első argumentumként, elemzi, és egy egész számot ad vissza (egész típus). A függvény megpróbálja elemezni azt a számrendszert, amelyben a forráskarakterláncban szereplő szám szerepel (például decimális, oktális vagy hexadecimális – de nem csak ezek). Ezenkívül a számrendszert explicit módon megadhatjuk, ha második paraméterként adjuk át a radix-nak. A radix paraméter tetszőleges számot vehet fel 2 és 36 között (a 10 feletti rendszerek az angol ábécét használják, A-tól Z-ig).
Az 1.5e6-hoz hasonló számok kezelése nem ugyanúgy történik, mint a parseFloat() .
Kérjük, olvassa el az alábbi példákat, nehogy belefusson a parseInt() függvény munkájában rejlő buktatókba.
ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045",10) // 45 parseInt( ""70",8) // 56 (a 70 az oktálisban 56 decimálisban) parseInt(""070"") // 56 (FONTOS! nulla esetén a függvény oktális számként értelmezi a karakterláncot ) parseInt(" "88",8) // NaN (nincs 8-as számjegy az oktális rendszerben) parseInt(""a1"") // NaN (FONTOS!!! Az alapértelmezett függvény nem kezeli a számot hexadecimálisként hacsak nem adja hozzá a 0x karakterláncok elejéhez paraméter elhagyható) parseInt( ""099"") // 0 (FONTOS!!! A szám oktálisnak számít, de érvénytelen karaktereket tartalmaz) parseInt(""0.5e6"") // 0 (FONTOS!!! nem nem működik úgy, mint a parseFloat) parseInt("" ZZ",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF",16) // -255
Ha a felhasználó által beírt szövegmezőből dolgoz fel adatokat, mindig használja a parseInt() függvényt a második radix paraméterrel együtt, ez megvédi a kódot a váratlan eredményektől.
Nem mindegy, hogy milyen típusú változót használunk a kifejezésben. Ha a kifejezés matematikai, akkor minden változója automatikusan numerikusként értelmeződik. Ha karakterláncokat dolgoz fel, akkor a kifejezés minden "résztvevőjét" karakterláncként kezeli. A JavaScript "karakterlánc számmá" konvertálásának feladata azonban sokkal szélesebb összefüggésben létezik.
A karakterláncok számokká konvertálására szolgáló módszerek arzenálja nem nagy, de minden egyszerű esetben elegendő. Itt a JavaScript (főleg kezdőknek) az egyszerűtől a bonyolultig vezető út gyakorlati példákkal.
Érdekelni fog:
A példa négy különböző karakterláncot ír le. A kimenet első blokkjában a typeof függvény minden változójának típusa karakterláncként van definiálva. Ezután minden karakterlánc nagyon egyszerűen számmá alakul. A második kimeneti blokkban a változók konverzió utáni változásait láthatjuk, típusuk szám lett. A JavaScript parseFloat konverziós példája különösen árulkodó: „12e+3” volt, most „12000”.
A karakterlánc számmá alakításakor bekövetkező változások jelentősek lehetnek! De csak az első karakterek számítanak: numerikusnak kell lenniük. Ha nincsenek numerikus karakterek, az eredmény NaN lesz.
Egy karakterlánc fordított átalakítása, amelyből szám lesz, nem mindig ugyanaz a karakterlánc. Ezzel a pillanattal ellenőrizhető a numerikus információk bevitelének helyessége.
Sziasztok kedves olvasók. Ma megírom, hogyan kell átalakítani javascript karakterlánc a számhoz. Ez a Szám függvény segítségével történik, most egy példán mutatom be a használatát.
Azt is javaslom, hogy nézze meg a cikk videó változatát:
Mint tudják, a javascriptnek numerikus és karakterláncú adattípusa van. Próbáljunk meg két változót létrehozni, amelyekben tároljuk a számokat, majd az eredményt jelenítsük meg a képernyőn.
Var a = 5; var b = 12; document.write(a+b);
mi lesz az eredmény? 17, amit a böngésző mutatott nekünk. Tehát számadatokról van szó, így a böngésző sikeresen összeadta. És most hozzunk létre két másik változót, amelyekben ugyanazokat az értékeket tesszük, csak idézőjelbe. Hadd emlékeztesselek arra, hogy a javascriptben minden karakterlánc idézőjelbe van írva.
Var c = "5"; vard = "12"; document.write("
" + c + d);
Most a böngésző karakterláncnak tekinti az adatainkat, és ha hozzáadjuk őket, akkor egyszerűen hozzáadódik két karakterlánc, és 512-t kapunk, ami nem a helyes eredmény, ha a számokat összeadtuk, de akkor helyes, ha két karakterláncot összerakunk.
Itt minden egyszerű, hozzuk létre a következő két változót, amibe ugyanazt az értéket írjuk, mint ami a c és d változóknak van beállítva, de ezeket a Number metóduson átadva:
Vare = Szám(c); var f = Szám(d); document.write(e+f);
Ha most megpróbálja megjeleníteni ennek az összeadásnak az eredményét a képernyőn, akkor 17 fog megjelenni, mert a módszerünk sikeresen befejeződött, és a karakterláncot számmá alakította. Szeretném megjegyezni, hogy ha így írsz:
Document.write("
"+e+f);
Ekkor az 512 jelenik meg a képernyőn, mert karakterláncok és számok hozzáadásakor MINDIG az eredményt stringgé alakítjuk. Ha sortörést szeretne hozzáadni, és továbbra is megtartja a helyes eredményt, akkor mindent két vagy egy sorba írhat, így:
Document.write("
"+(e+f));
Ha a számokat zárójelben teszed, akkor azok nem lesznek karakterláncokká konvertálva, és sikeresen elmentik a tulajdonságaikat. Itt van egy ilyen rövid cikkem ma. Remélem, a javascript kicsit világosabb lett számodra.
A parseInt() függvény elemzi a string argumentumot, és a megadott gyök (a matematikai számrendszerek alapja) egész számát adja vissza.
Ennek az interaktív példának a forrása egy GitHub-tárolóban van tárolva. Ha szeretne hozzájárulni az interaktív példák projekthez, kérjük, klónozza a https://github.com/mdn/interactive-examples oldalt, és küldjön lehívási kérelmet.
A megadott karakterláncból elemzett egész szám.
Ha a gyök kisebb, mint 11, és az első nem szóköz karakter nem konvertálható számmá, a NaN visszaadásra kerül.
A parseInt függvény az első argumentumot karakterláncsá alakítja, elemzi a karakterláncot, majd egy egész számot vagy NaN-t ad vissza.
Ha nem NaN, akkor a visszatérési érték az az egész szám, amely az első argumentum, amelyet számként vettünk a megadott gyökben. (Például a 10-es radix egy decimális számból, a 8-as oktálisból, a 16-os hexadecimálisból és így tovább.)
A 10 feletti gyökök esetén az angol ábécé betűi a 9-nél nagyobb számokat jelölik. Például a hexadecimális számokhoz (16-os bázis) A-tól F-ig terjedő számok használatosak.
Ha a parseInt olyan karakterrel találkozik, amely nem egy szám a megadott gyökben, figyelmen kívül hagyja azt és az összes következő karaktert, és az addig a pontig elemzett egész értéket adja vissza. A parseInt a számokat egész értékekké csonkolja. A bevezető és a záró szóköz megengedett.
Mert egyes számok az e karaktert használják karakterlánc-ábrázolásukban (pl. 6.022e23 6,022 × 10 23 esetén), a parseInt használata a számok csonkolására nem várt eredményeket fog eredményezni, ha nagyon nagy vagy nagyon kis számokon használják. parseInt kell nem a Math.floor() helyettesítőjeként használható.
A parseInt pontosan két jelet ért: + a pozitív és - negatív (az ECMAScript 1 óta). Ez a szóköz eltávolítása utáni elemzés első lépéseként történik. ha nem található jel, az algoritmus a következő lépésre lép; ellenkező esetben eltávolítja az előjelet, és lefuttatja a számelemzést a karakterlánc többi részén.
Ha a radix nem definiált , 0 vagy nem meghatározott, a JavaScript a következőket feltételezi:
Ha az első karakter nem konvertálható számmá, a parseInt a NaN-t adja vissza, hacsak a gyök nem nagyobb 10-nél.
Számtani célból a NaN érték nem egy szám egyik gyökben sem. tudsz hívja meg az isNaN függvényt annak meghatározására, hogy a parseInt eredménye NaN-e. Ha a NaN-t átadjuk az aritmetikai műveleteknek, akkor a művelet eredménye is NaN lesz.
Ha egy számot egy adott gyökben lévő karakterlánc-literálra szeretne konvertálni, használja az adott számot a .toString(radix) .
A következő példák mindegyike 15-öt ad vissza:
ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // de a `parseInt(015, 10)` 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)
A következő példák mindegyike NaN-t ad vissza:
ParseInt("Hello", 8) // Egyáltalán nem szám parseInt("546", 2) // A 0-tól és az 1-től eltérő számjegyek érvénytelenek a bináris radix esetén
A következő példák mindegyike -15-öt ad vissza:
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)
A következő példák mindegyike 4-et ad vissza:
ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Nagyon nagy számból 4 lesz parseInt(0.00000000000434, 10) // Nagyon kis számból 4
A következő példa 224-et ad vissza:
ParseInt("0e0", 16) parseInt("123_456") // 123
Bár az ECMAScript 3 nem támogatja, és az ECMAScript 5 tiltja, sok implementáció a kezdő 0-val kezdődő numerikus karakterláncot oktálisként értelmezi. A következőknek lehet oktális eredménye vagy tizedesjegy. Mindig adjon meg egy radixot hogy elkerülje ezt a megbízhatatlan viselkedést.
ParseInt("0e0") // 0 parseInt("08") // 0, mert a "8" nem nyolcas számjegy.
A parseInt függvény ECMAScript 5 specifikációja már nem teszi lehetővé az implementációk számára, hogy a 0 karakterrel kezdődő karakterláncokat oktális értékként kezeljék. Az ECMAScript 5 kimondja:
A parseInt függvény egy egész értéket állít elő, amelyet a karakterlánc argumentum tartalmának a megadott gyök szerinti értelmezése diktál. A karakterláncban a bevezető szóközt figyelmen kívül hagyja. Ha a gyök definiálatlan vagy 0, akkor azt 10-nek kell tekinteni, kivéve, ha a szám 0x vagy 0X karakterpárral kezdődik, amely esetben 16-os gyököt feltételezünk.
Ez eltér az ECMAScript 3-tól, amely elbátortalanította, de lehetővé tette az oktális értelmezést.
Sok implementáció nem alkalmazta ezt a viselkedést 2013 óta, és mivel a régebbi böngészőket támogatni kell, mindig adjon meg egy radixot.
Néha hasznos az egész számok elemzésének szigorúbb módja.
A reguláris kifejezések segíthetnek:
Függvény filterInt(érték) (if (/^[-+]?(\d+|Végtelen)$/.test(érték)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt( "421 ")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Végtelen")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // NaN konzol .log (filterInt("1.61803398875")) // NaN
| Leírás | Állapot | Megjegyzés |
|---|---|---|
| ECMAScript 1st Edition (ECMA-262) | alapértelmezett | kezdeti meghatározás. |
| ECMAScript 5.1 (ECMA-262) |
alapértelmezett | |
| ECMAScript 2015 (6. kiadás, ECMA-262) A "parseInt" meghatározása a specifikációban. |
alapértelmezett | |
| ECMAScript legújabb vázlat (ECMA-262) A "parseInt" meghatározása a specifikációban. |
Piszkozat |
Az ezen az oldalon található kompatibilitási táblázat strukturált adatokból készült. Ha hozzá szeretne járulni az adatokhoz, kérjük, nézze meg a https://github.com/mdn/browser-compat-data webhelyet, és küldjön lehívási kérelmet.
Frissítse a kompatibilitási adatokat a GitHubon
| Asztali | Mobil | szerver | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Króm | él | Firefox | internet böngésző | Opera | szafari | android webview | Chrome Androidra | Firefox Androidra | Opera Androidra | Safari iOS rendszeren | Samsung internet | Node.js | |
| parseInt | Chrome teljes támogatás 1 | Edge Teljes támogatás 12 | Firefox teljes támogatás 1 | IE teljes támogatás 3 | Opera Teljes támogatás Igen | Safari Teljes támogatás Igen | WebView Android Teljes támogatás 1 | Chrome Android Teljes támogatás 18 | Firefox Android Teljes támogatás 4 | Safari iOS Teljes támogatás Igen | Samsung Internet Android Teljes támogatás 1.0 | nodejs Teljes támogatás Igen | |
| A bevezető-nulla karakterláncok elemzése decimális, nem oktális | Chrome teljes támogatás 23 | Edge Teljes támogatás 12 | Firefox teljes támogatás 21 | IE teljes támogatás 9 | Opera Teljes támogatás Igen | A Safari teljes támogatása 6 | WebView Android Teljes támogatás 4.4 | Chrome Android Teljes támogatás 25 | Firefox Android Teljes támogatás 21 | Opera Android Teljes támogatás Igen | Safari iOS teljes támogatás 6 | Samsung Internet Android Teljes támogatás Igen | nodejs Teljes támogatás Igen |
A JavaScript egy dinamikus adatbevitellel rendelkező nyelv. Ez azt jelenti, hogy ugyanahhoz a változóhoz különböző típusú értékek írhatók, miközben maga a változó típusa megváltozik. Ez a viselkedés gyakran lehetővé teszi, hogy elfelejtse a különböző típusú változók eltérő viselkedését, de emlékeznie kell erre a funkcióra. Mutassuk meg ezt a következő példában.
console.log(sum(1, 2)); // 3 (itt minden rendben van) console.log(sum(1, "2")); // 12 (és itt nem annyira)
Ahogy a példából is látható, a függvény összeg helytelenül viselkedik, ha legalább egy argumentuma nem szám. A helyzet az, hogy amikor egy számot „adunk” egy karakterlánchoz, a számot karakterláncsá alakítják, és összefűzik (összeragasztják) a második operandusszal.
Az ilyen bonyodalmak elkerülése érdekében a szkript végrehajtása során megtudhatja a változó típusát, és kijavíthatja a viselkedését, vagy gondosan figyelemmel kísérheti a változók típusát.
Ez az unáris operátor abszolút bármilyen értéket vesz operandusnak, és a típusát egy karakterlánc-változóban adja vissza.
A JavaScript a következő adattípusokkal rendelkezik:
| // 1.) objektum konzol.napló (typeof ( ) ) ; // objektum var p = ( x: 1 , y: 3 ) ; konzol.napló (p típusa) ; // objektum // 2.) function function sayHello() ( console.log ("Hello!" ) ; ) console.log (typeof sayHello) ; // függvény // 3.) string console.log ("JavaScript" típusa) ; // string // 4.) szám console.log (typeof 3.1415 ) ; // szám // 5.) logikai console.log (typeof true ) ; // logikai // 6.) undefined var notExistsOne; console.log (notExistsOne típusa) ; // definiálatlan konzol napló (typeof notExistsTwo) ; // határozatlan |
// 1.) objektum console.log(typeof()); // objektum var p = (x: 1, y: 3); console.log(typeofp); // objektum // 2.) function function sayHello() ( console.log("Hello!"); ) console.log(typeof sayHello); // függvény // 3.) string console.log(typeof "JavaScript"); // string // 4.) number console.log(typeof 3.1415); // szám // 5.) logikai console.log(typeof true); // logikai // 6.) undefined var notExistsOne; console.log(notExistsOne típusa); // undefined console.log(typeof notExistsTwo); // határozatlan
vegye figyelembe, hogy határozatlan ez is egy adattípus, amely egyetlen értékből áll.
A típusöntés a programozásban az egyik típusú változó értékének konvertálása egy másik típusú változó értékévé.
Ez az átalakítás gyakran a programozó irányítása nélkül történik. Ez látható a függvény példáján összeg. Típusváltozás akkor következik be, ha az eredeti típusú változón végrehajtott művelet eredménye nem egyértelmű. Például nem lehet pontosan megmondani, hogy mi lesz a végeredmény, ha egy karakterláncot hozzáadunk egy számmal, de a két szám összeadásának művelete nyilvánvaló, és ebben az esetben logikus, hogy a számot a karakterláncba hozzuk.
Néha a programozó maga is megváltoztathatja a változó típusát, ha néhány műveletet alkalmaz rá. Például egy karakterlánc növelése vagy csökkentése számmá alakítja azt.
var c = "nem szám"; ++c; console.log(c típusa); // NaN
Érdemes megjegyezni, hogy nem kell ehhez a karakterlánc számmá alakításának módszeréhez folyamodnia, mert rossz olvashatósága és nem nyilvánvaló. Ehhez a feladathoz a js beépített függvényei vannak. parseIntÉs parseFloat. Első argumentuknak egy számmá alakítandó karakterláncot vesznek fel, opcionális második argumentumként pedig annak a számrendszernek az alapját veszik, amely az átadott karakterláncban lévő számot tartalmazza első argumentumként. Ha a második argumentum nincs megadva, akkor a rendszer úgy tekinti, hogy a karakterlánc decimális számrendszerben tartalmaz egy számot.
Funkció parseInt karakterlánc egész számmá alakítására szolgál, és a függvény parseFloat törtszámra konvertálni.
| var a = parseInt("10") ; console. log ([ "a = " , a, "; typeof a:" , typeof a] .join (" " ) ) ; // a = 10 ; a típusa: szám var pi = parseInt("3.1415" ) ; console.log("pi = " + pi) ; // pi = 3 pi = parseFloat("3.1415" ) ; console.log("pi = " + pi) ; // pi = 3,1415 |
var a = parseInt("10"); console.log(["a = ", a, "; typeof a:", typeof a].join(" ")); // a = 10 ; típusa: szám var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3,1415"); console.log("pi = " + pi); // pi = 3,1415
Vegye figyelembe, hogy a karakterlánc bármilyen literális numerikus értéket tartalmazhat, beleértve a hexadecimális, oktális vagy exponenciális értéket is.
| a = parseInt("010") ; console.log("a = " + a) ; // a = 8 a = parseInt("0xAA" ) ; console.log("a = " + a) ; // a = 170 a = parseFloat("1e-10" ) ; console.log("a = " + a) ; // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001) |
a = parseInt("010"); console.log("a = " + a); // a = 8 a = parseInt("0xAA"); console.log("a = " + a); // a = 170 a = parseFloat("1e-10"); console.log("a = " + a); // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001)
A függvények második paramétereként parseIntÉs parseFloat megadhatja a számrendszer alapját.
| a = parseInt("10" , 8 ) ; console.log("a = " + a) ; // a = 8 a = parseInt("010" , 10 ) ; console.log("a = " + a) ; // a = 10 a = parseInt("ff" , 16 ) ; console.log("a = " + a) ; // a = 255 |
a = parseInt("10", 8); console.log("a = " + a); // a = 8 a = parseInt("010", 10); console.log("a = " + a); // a = 10 a = parseInt("ff", 16); console.log("a = " + a); // a = 255
Ha az érték benne van a karakterláncban, akkor melyik függvény parseIntÉs parseFloat vegye első paraméterként, nem numerikus literál, akkor ezeknek a függvényeknek az eredménye lesz az érték NaN.
| a = parseInt("nem szám") ; console.log("a = " + a) ; // a = NaN a = parseFloat("nem szám" ) ; console.log("a = " + a) ; // a = NaN |
a = parseInt("nem szám"); console.log("a = " + a); // a = NaN a = parseFloat("nem szám"); console.log("a = " + a); // a = NaN
A JavaScriptben bármilyen típusú érték önthető egy karakterláncba. Fentebb már volt szó, hogy ha egy karakterláncot számmal fűzünk össze, akkor a szám karakterláncra redukálódik, és csak ezután történik az összefűzés. Ez bármely értéktípusnál megtörténik.
| var str = "Objektum: " + ( ) ; konzolnapló (str) ; // Objektum: str = "Tömb: " + [ 1 , 2 , 3 ] ; konzolnapló (str) ; // Tömb: 1,2,3 függvény sum(a, b) ( return a + b; ) str = "Function: " + sum; konzolnapló (str) ; /* Függvény: sum(a, b) függvény ( return a + b; ) */ |
var str = "Objektum: " + (); konzol log(str); // Objektum: str = "Tömb: " + ; konzol log(str); // Tömb: 1,2,3 függvény sum(a, b) ( return a + b; ) str = "Function: " + sum; konzol log(str); /* Függvény: sum(a, b) függvény ( return a + b; ) */
Valójában egy objektum karakterláncba öntésekor a metódus implicit módon meghívásra kerül toString, amit kifejezetten nevezhetünk is.
| var p = (x: 2, y: 4), str; str = p.toString(); konzol.napló (typeof str) ; // string console.log (str) ; // str = [ 1 , 2 , 3 ] .toString ( ); konzol.napló (typeof str) ; // string console.log (str) ; 1,2,3 |
var p = (x: 2, y: 4), str; str = p.toString(); console.log(typeofstr); // string console.log(str); // str = .toString(); console.log(typeofstr); // string console.log(str); 1,2,3
A számmá konvertálás matematikai műveletek végrehajtásakor és típusöntéssel (==, !=) végzett összehasonlító művelet során történik, míg az érték hamisÉs üres tömb típusú 0 értékre konvertálják szám.
var a = igaz + igaz + igaz; // 1 + 1 + 1 console.log(a); 3
A nem üres tömb, objektum és függvény egy karakterláncba kerül, ha aritmetikai kifejezésekben használják.
| var arr = [ 1 , 2 , 3 ] ; console.log (arr + 4 ) ; // 1,2,34 függvény sum(a, b) ( return a + b; ) console. log (sum + 5 ) ; // függvény összeg(a, b)(return a + b;)5 |
var arr = ; console.log(arr + 4); // 1,2,34 függvény sum(a, b)(return a + b;) console.log(sum + 5); // függvény összeg(a, b)(return a + b;)5
Amint láthatja, az implicit típuskonverzió a js-ben korántsem mindig nyilvánvaló, ezért kerülje el az explicit típuskonverziós függvények használatával, mint pl. parseInt, parseFloatÉs toString.
Ez minden. Mint mindig, sok sikert neked!
