Utolsó frissítés: 1.11.2015

Gyakran előfordul, hogy egyik adatot a másikra kell konvertálni. Például:

varszám1 = "46"; varszám2 = "4"; varresult = szám1 + szám2; konzolnapló(eredmény); //464

Mindkét változó karakterláncokat, pontosabban számok karakterlánc-reprezentációit jelöli. És ennek eredményeként nem az 50-es számot kapjuk, hanem a 464-es karakterláncot. De jó lenne, ha ezeket is összeadnák, kivonnák, általában úgy működnének, mint a közönséges számoknál.

Ebben az esetben használhatunk transzformációs műveleteket. A függvény egy karakterlánc számmá alakítására szolgál. parseInt():

varszám1 = "46"; varszám2 = "4"; var eredmény = parseInt(szám1) + parseInt(szám2); konzolnapló(eredmény); // ötven

A karakterláncok konvertálásához törtszámok alkalmazott függvény parseFloat():

varnumber1 = "46,07"; varnumber2 = "4,98"; var eredmény = parseFloat(szám1) + parseFloat(szám2); konzolnapló(eredmény); //51.05

Ebben az esetben a karakterlánc vegyes tartalmú lehet, például "123hello", vagyis ebben az esetben vannak számok, de vannak hétköznapi karakterek is. De a parseInt() metódus továbbra is megpróbálja végrehajtani az átalakítást:

Varnum1 = "123hello"; varnum2 = parseInt(szám1); konzolnapló(szám2); // 123

Ha a metódus nem konvertál, NaN-t (Not a Number) ad vissza, ami azt jelzi, hogy a karakterlánc nem számot jelent, és nem konvertálható.

Különleges funkcióval isNaN() ellenőrizheti, hogy egy karakterlánc számot jelent-e. Ha a karakterlánc nem szám, akkor a függvény igazat ad vissza, ha szám, akkor hamis:

Var num1 = "javascript"; varnum2 = "22"; varresult = isNaN(szám1); konzolnapló(eredmény); // igaz - a szám1 nem egy szám eredmény = isNaN(num2); konzolnapló(eredmény); // false - a szám2 egy szám

Fentebb megvizsgáltuk a karakterláncok számokká fordítását decimális rendszer. A számokat azonban bármilyen rendszerre lefordíthatjuk. Alapértelmezés szerint a JavaScript értelmező maga találja ki, hogy melyik számrendszerre szeretnénk konvertálni a karakterláncot (általában a decimális rendszer van kiválasztva). De használhatjuk a második paramétert annak kifejezett jelzésére, hogy egy karakterláncot számmá szeretnénk konvertálni egy adott rendszeren. Például számmá konvertálni kettes számrendszer:

Varnum1 = "110"; varnum2 = parseInt(szám1, 2); konzolnapló(szám2); 6

Az eredmény 6 lesz, mivel a 110 binárisan a 6 decimális szám.

Most pedig írjunk kis program, amelyben változókkal végzett műveleteket használunk:

A prompt() függvény segítségével a böngészőben megjelenik egy párbeszédpanel, amely valamilyen érték megadását kéri. A függvény második argumentuma az alapértelmezés szerint használandó értéket adja meg.

A prompt() függvény azonban egy karakterláncot ad vissza. Ezért ezt a karakterláncot számmá kell alakítanunk, hogy műveleteket hajthassunk végre vele.

Miután megnyitotta az oldalt a böngészőben, megjelenik egy felhívás a befizetés összegének megadására:

Ezután egy hasonló üzenet jelenik meg a százalék megadásához. És a végén a program megkapja az adatokat, számokká alakítja, és elvégzi a számítást.

A JavaScript egy dinamikus adatbevitellel rendelkező nyelv. Ez azt jelenti, hogy ugyanahhoz a változóhoz írhat értékeket különféle típusok, míg maga a változó típusa megváltozik. Ez a viselkedés gyakran lehetővé teszi, hogy elfelejtsük a változók eltérő viselkedését különböző típusú, de még mindig emlékezni 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.

operátor típusa

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 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); // meghatározatlan

vegye figyelembe, hogy meghatározatlan ez is egy adattípus, amely egyetlen értékből áll.

Öntvény

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.

Karakterlánc konvertálása számmá

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 ; 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 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

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

String konverzió

NÁL NÉL JavaScript érték bármilyen típusú karakterláncra önthető. 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: " + (); 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(); console.log(typeofstr); // string console.log(str); // str = .toString(); console.log(typeofstr); // string console.log(str); 1,2,3

Numerikus konverzió

A számmá való átalakítás végrehajtáskor történik matematikai műveletekés típusöntéssel (==, !=) végzett összehasonlítási műveletnél, míg az érték hamisés egy üres tömböt 0 típusú értékre konvertálunk 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 = ; 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!

Két fő módja van a karakterlánc számmá alakításának JavaScriptben. Az egyik módja annak elemzése, másik módja a típusának számra váltása. A többi válaszban szereplő összes trükk (pl. unáris plusz) magában foglalja a karakterlánc típusának a számra való rákényszerítését. Ugyanezt megteheti a Szám funkcióval is.

Szintaktikai

Var parsed = parseInt("97", 10);

A ParseInt és a parseFloat két függvény, amelyet a karakterláncok számokká történő elemzésére használnak. Az elemzés csendben leáll, ha olyan karaktert talál, amelyet nem ismer fel, ami hasznos lehet a karakterláncok, például a "92px" elemzéséhez, de kissé veszélyes is, mivel nem ad hibát rossz bevitel esetén, hanem "vissza fog térni" NaN, ha a karakterlánc nem számmal kezdődik. A karakterlánc elején lévő szóközt figyelmen kívül hagyja. Íme egy példa arra, hogy valami mást csinál, amit szeretne, és nem utal arra, hogy valami rosszul sült el:

Var widgetsSold = parseInt("97 800", 10); // widgetsSold most 97

Jó gyakorlat, ha második argumentumként mindig tizedesjegyet ad meg. Régebbi böngészőkben, ha egy karakterlánc 0-val kezdődik, akkor azt oktálisként értelmezi, hacsak nincs megadva radix érték, ami sok embert meglepett. A hexadecimális indítás viselkedése akkor aktiválódik, ha a karakterlánc 0x-szal kezdődik, hacsak nincs megadva gyökérték. 0xff. A szabvány valójában megváltozott az ecmascript 5-tel, így modern böngészők többé ne futtasson oktálisokat, ha a vezető 0 van, ha nincs megadva ok. A parseInt a 36-os alapig értelmezi a gyököket, ebben az esetben a kis- és nagybetűket is egyenértékűnek tekintjük.

Módosítsa a karakterlánc típusát számra

Az összes többi fent említett trükk, amely nem használja a ParseInt-et, magában foglalja egy karakterlánc számmá kényszerítését. Inkább kifejezetten csinálom

Var cast = Szám("97");

Ez különbözik az elemzési módszerektől (bár továbbra is figyelmen kívül hagyja a szóközöket). Szigorúbb: ha nem érti a teljes karakterláncot, akkor NaN -t ad vissza, így nem használhatod olyan karakterláncokhoz, mint a 97px. Mivel primitív számot szeretne, nem számburkoló objektumot, ügyeljen arra, hogy a Szám függvény előtt ne írja be az új karaktert.

Nyilvánvaló, hogy számmá konvertálva olyan értéket adunk, amely lehet egy lebegő érték, nem pedig egy egész szám, ezért ha egész számot szeretne, módosítania kell. Ennek többféle módja van:

Varrounded = Math.floor(Szám("97.654")); // további lehetőségek a Math.ceil, Math.round varfix = Number("97.654").toFixed(0); // csonka helyett kerekítve var bitwised = Number("97.654")|0; // ne használja nagy számokhoz

Bármely bitenkénti operátor (itt bitenkénti vagy bitenkénti negációt is csináltam, de csinálhatsz dupla tagadást is, mint az előző válaszban vagy Bitshiftben) 32 bites egész számra konvertálja az értéket, és a legtöbb előjeles egész számra konvertálja. Felhívjuk figyelmét, hogy ez nem akarja, hogy nagy egész számokat keressen. Ha egy egész szám nem ábrázolható 32 bitben, akkor az befejeződik.

~~"3000000000.654" === -1294967296 // Ez ugyanaz, mint a Szám("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000.654 >> 0 === 3647256576 // de nagyobb számokkal még mindig meghiúsul

A nagy számok helyes működéséhez a kerekítési módszereket kell használni

Math.floor("3000000000.654") === 3000000000 // Ez ugyanaz, mint a Math.floor(Number("3000000000.654"))

Ne feledje, hogy ezek a módszerek mindegyike érti az exponenciális jelölést, így 2e2 200 , nem pedig NaN. Ezenkívül a Number megérti az "Infinity" kifejezést, míg az elemzési módszerek nem.

Egyedi

Nem valószínű, hogy a fenti módszerek bármelyike ​​pontosan azt csinálja, amit szeretne. Például általában hibaelemzési hibát akarok, és nincs szükségem az Infinity támogatására, kitevőkre vagy kezdő szóközökre. A használattól függően néha érdemes egyéni konverziós függvényt írni.

Mindig ellenőrizze, hogy a számkimenet vagy az elemzési módszerek egyike megfelel-e a várt számnak. Szinte biztos, hogy az isNaN használatával győződjön meg arról, hogy a szám nem NaN (általában ez az egyetlen módja annak, hogy megtudja, hogy az elemzés sikertelen volt-e).

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.

JavaScript-módszerek karakterláncok számokká konvertálására

A karakterláncok számokká konvertálására szolgáló módszerek arzenálja nem nagy, de összességében elegendő egyszerű esetek. 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. Az első kimeneti blokkban mindegyik típusa változó függvény typeof 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.