Posledná aktualizácia: 1.11.2015

Často je potrebné previesť jeden údaj na druhý. Napríklad:

varnumber1 = "46"; varnumber2 = "4"; varvysledok = cislo1 + cislo2; konzolový protokol (výsledok); //464

Obe premenné predstavujú reťazce, presnejšie reťazcové reprezentácie čísel. A v dôsledku toho dostaneme nie číslo 50, ale reťazec 464. Bolo by však pekné, keby sa dali aj sčítať, odčítať, vo všeobecnosti by fungovali ako s obyčajnými číslami.

V tomto prípade môžeme použiť transformačné operácie. Funkcia sa používa na prevod reťazca na číslo. parseInt():

varnumber1 = "46"; varnumber2 = "4"; var vysledok = parseInt(cislo1) + parseInt(cislo2); konzolový protokol (výsledok); // päťdesiat

Ak chcete previesť reťazce na zlomkové čísla aplikovaná funkcia parseFloat():

varnumber1 = "46,07"; varnumber2 = "4,98"; var vysledok = parseFloat(cislo1) + parseFloat(cislo2); konzolový protokol (výsledok); //51,05

V tomto prípade môže mať reťazec zmiešaný obsah, napríklad "123hello", to znamená, že v tomto prípade sú čísla, ale sú tu aj bežné znaky. Metóda parseInt() sa však stále pokúsi vykonať konverziu:

Varnum1 = "123 ahoj"; varnum2 = parseInt(num1); konzola log(num2); // 123

Ak sa metóde nepodarí konvertovať, vráti NaN (Not a Number), čo znamená, že reťazec nepredstavuje číslo a nedá sa skonvertovať.

So špeciálnou funkciou isNaN() môžete skontrolovať, či reťazec predstavuje číslo. Ak reťazec nie je číslo, funkcia vráti hodnotu true, ak je to číslo, vráti hodnotu false:

Var num1 = "javascript"; varnum2 = "22"; varvysledok = isNaN(číslo1); konzolový protokol (výsledok); // true - cislo1 nie je cislo vysledok = isNaN(num2); konzolový protokol (výsledok); // false - číslo2 je číslo

Vyššie sme uvažovali o preklade reťazcov na čísla v desiatková sústava. Čísla však vieme preložiť do akéhokoľvek systému. Interpret JavaScriptu štandardne sám uhádne, do akej číselnej sústavy chceme reťazec previesť (zvyčajne je zvolená desiatková sústava). Ale môžeme použiť druhý parameter na explicitné označenie, že chceme previesť reťazec na číslo v konkrétnom systéme. Napríklad prevod na číslo v binárny systém:

Varnum1 = "110"; varnum2 = parseInt(číslo1, 2); log konzoly (num2); // 6

Výsledok bude 6, pretože 110 v binárnom systéme je číslo 6 v desiatkovej sústave.

Teraz poďme písať malý program, v ktorom používame operácie s premennými:

Pomocou funkcie prompt() sa v prehliadači zobrazí dialógové okno s výzvou na zadanie nejakej hodnoty. Druhý argument tejto funkcie určuje hodnotu, ktorá sa má štandardne použiť.

Funkcia prompt() však vracia reťazec. Preto musíme tento reťazec previesť na číslo, aby sme s ním mohli vykonávať operácie.

Po otvorení stránky v prehliadači sa nám zobrazí výzva na zadanie sumy vkladu:

Potom sa zobrazí podobná správa pre zadanie percenta. A na konci program prijme údaje, prevedie ich na čísla a vykoná výpočet.

JavaScript je jazyk s dynamickým typovaním údajov. To znamená, že môžete zapisovať hodnoty do rovnakej premennej rôzne druhy, pričom sa zmení typ samotnej premennej. Toto správanie často umožňuje zabudnúť na odlišné správanie premenných s iný typ, no aj tak je potrebné si túto vlastnosť zapamätať. Ukážeme si to na nasledujúcom príklade.

console.log(sum(1, 2)); // 3 (tu je všetko v poriadku) console.log(sum(1, "2")); // 12 (a tu nie tak veľa)

Ako môžete vidieť na príklade, funkcia súčet sa správa nesprávne, ak aspoň jeden z jeho argumentov nie je číslo. Faktom je, že pri „pridávaní“ čísla do reťazca sa číslo prevedie na reťazec a ten sa spojí (zlepí) s druhým operandom.

Aby ste predišli takýmto komplikáciám, môžete zistiť typ premennej počas vykonávania skriptu a opraviť jej správanie, alebo pozorne sledovať typy premenných.

typ operátora

Tento unárny operátor berie ako operand absolútne akúkoľvek hodnotu a vracia svoj typ v reťazcovej premennej.

JavaScript má nasledujúce typy údajov:

// 1.) objekt console.log(typeof()); // objekt var p = (x: 1, y: 3); console.log(typeofp); // objekt // 2.) funkcia function sayHello() ( console.log("Ahoj!"); ) console.log(typeof sayHello); // funkcia // 3.) string console.log(typeof "JavaScript"); // reťazec // 4.) číslo console.log(typeof 3.1415); // číslo // 5.) boolean console.log(typeof true); // boolean // 6.) undefined var notExistsOne; console.log(typeof notExistsOne); // undefined console.log(typeof notExistsTwo); // nedefinované

poznač si to nedefinované je to tiež dátový typ, ktorý pozostáva z jednej hodnoty.

Obsadenie

Typové pretypovanie sa v programovaní chápe ako prevod hodnoty premennej jedného typu na hodnotu iného typu.
Často k tejto transformácii dochádza bez kontroly programátora. Vidno to na príklade s funkciou súčet. K zmene typu dochádza, keď nie je jasný výsledok vykonania operácie s premennou pôvodného typu. Nedá sa napríklad presne povedať, čo bude výsledkom sčítania reťazca s číslom, ale operácia sčítania dvoch čísel je zrejmá a v tomto prípade je logické zredukovať číslo na reťazec.

Previesť reťazec na číslo

Niekedy môže programátor sám zmeniť typ premennej tým, že na ňu použije nejaké operácie. Napríklad operácie zvýšenia alebo zníženia reťazca ho skonvertujú na číslo.

var c = "nie je-číslo"; ++c; console.log(typeof c); // NaN

Stojí za zmienku, že nie je potrebné uchýliť sa k tejto metóde prevodu reťazca na číslo, pretože je zle čitateľný a nie je zrejmé. Pre túto úlohu sú v js vstavané funkcie. parseInt a parseFloat. Ako prvý argument berú reťazec, ktorý sa má previesť na číslo, a ako svoj voliteľný druhý argument berú základ číselnej sústavy, ktorý obsahuje číslo v odovzdanom reťazci ako prvý argument. Ak druhý argument nie je zadaný, bude sa predpokladať, že reťazec obsahuje číslo v desiatkovej sústave čísel.

Funkcia parseInt sa používa na konverziu reťazca na celé číslo a funkciu parseFloat previesť na zlomkové.

var a = parseInt("10"); console.log(["a = ", a, "; typ a:", typ a].join(" ")); // a = 10; typeof a: číslo var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3,1415"); console.log("pi = " + pi); // pi = 3,1415

Upozorňujeme, že reťazec môže obsahovať akúkoľvek doslovnú číselnú hodnotu vrátane hexadecimálnej, osmičkovej alebo exponenciálnej.

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)

Ako druhý parameter funkcií parseInt a parseFloat môžete určiť základ číselnej sústavy.

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

Ak je hodnota v reťazci, ktorá funkcia parseInt a parseFloat vziať ako prvý parameter, nie je číselný literál, potom výsledkom vykonania týchto funkcií bude hodnota NaN.

a = parseInt("nie je číslo"); console.log("a = " + a); // a = NaN a = parseFloat("nie je číslo"); console.log("a = " + a); // a = NaN

Konverzia reťazca

AT Hodnota JavaScript akýkoľvek typ môže byť prenesený na reťazec. Už vyššie bolo povedané, že pri zreťazení reťazca s číslom sa číslo zredukuje na reťazec a až potom dôjde k zreťazeniu. Stane sa to pri akomkoľvek type hodnoty.

var str = "Objekt: " + (); konzola log(str); // Objekt: str = "Pole: " + ; konzola log(str); // Pole: 1,2,3 funkcia suma(a, b) ( return a + b; ) str = "Funkcia: " + suma; konzola log(str); /* Funkcia: funkcia suma(a, b) ( return a + b; ) */

V skutočnosti sa pri pretypovaní objektu na reťazec metóda implicitne volá natiahnuť, ktorú možno nazvať aj výslovne.

var p = (x: 2, y: 4), str; str = p.toString(); console.log(typeofstr); // reťazec console.log(str); // str = .toString(); console.log(typeofstr); // reťazec console.log(str); // 1,2,3

Číselná konverzia

Prevod na číslo nastáva pri vykonávaní matematické operácie a pri vykonávaní porovnávacej operácie s pretypovaním (==, !=), pričom hodnota falošný a prázdne pole sa skonvertujú na hodnotu typu 0 číslo.

var a = true + true + true; // 1 + 1 + 1 console.log(a); // 3

Neprázdne pole, objekt a funkcia sa pri použití v aritmetických výrazoch prenesú do reťazca.

var arr = ; console.log(arr + 4); // 1,2,34 funkcia suma(a, b)(návrat a + b;) console.log(suma + 5); // funkcia suma(a, b)(návrat a + b;)5

Ako vidíte, implicitná konverzia typov v js nie je zďaleka vždy zrejmá, takže by ste sa jej mali vyhnúť používaním funkcií na konverziu explicitných typov, ako napr. parseInt, parseFloat a natiahnuť.

To je všetko. Ako vždy, nech sa vám darí!

Existujú dva hlavné spôsoby, ako previesť reťazec na číslo v javascripte. Jedným zo spôsobov je analyzovať ho a iným spôsobom zmeniť jeho typ na číslo. Všetky triky v iných odpovediach (napr. jednočlenné plus) znamenajú implicitné prinútenie typu reťazca k číslu. To isté môžete urobiť aj s funkciou Číslo.

Syntaktické

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

ParseInt a parseFloat sú dve funkcie, ktoré sa používajú na analýzu reťazcov na čísla. Analýza sa zastaví potichu, ak zasiahne znak, ktorý nepozná, čo môže byť užitočné pri analýze reťazcov ako „92px“, ale je to tiež trochu nebezpečné, pretože vám neposkytne žiadnu chybu pri zlom vstupe, namiesto toho „vrátite NaN ak reťazec nezačína číslom. Medzera na začiatku reťazca sa ignoruje. Tu je príklad niečoho, čo robí niečo iné, čo chcete, a nenaznačuje to, že sa niečo pokazilo:

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

Je dobrou praxou vždy uvádzať desatinné číslo ako druhý argument. Ak by v starších prehliadačoch reťazec začínal na 0, bol by interpretovaný ako osmičkový, pokiaľ by nebola špecifikovaná hodnota radix, čo mnohých prekvapilo. Správanie pre hex štart sa spustí, ak reťazec začína 0x, pokiaľ nie je špecifikovaná hodnota radix. 0xff. Štandard sa skutočne zmenil s ecmascriptom 5 tak moderné prehliadače už nespúšťajte osmičky, keď je na začiatku 0, ak nie je zadaný žiadny dôvod. parseInt rozumie radikálom až do základu 36, v takom prípade sa veľké aj malé písmená považujú za ekvivalentné.

Zmeňte typ reťazca na číslo

Všetky ostatné triky uvedené vyššie, ktoré nepoužívajú ParseInt, zahŕňajú implicitné vynútenie reťazca na číslo. Radšej to robím explicitne

Var cast = Číslo("97");

Toto sa líši od metód analýzy (hoci stále ignoruje medzery). Je to prísnejšie: ak nerozumie celému reťazcu, vráti NaN , takže ho nemôžete použiť pre reťazce ako 97px . Pretože chcete primitívne číslo a nie objekt obálky čísla, uistite sa, že pred funkciou Číslo nepredchádzate novým .

Je zrejmé, že prevod na číslo dáva hodnotu, ktorá môže byť skôr pohyblivá ako celé číslo, takže ak chcete celé číslo, musíte ho zmeniť. Existuje niekoľko spôsobov, ako to urobiť:

Varrounded = Math.floor(Number("97,654")); // ďalšie možnosti sú Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // zaokrúhlené a nie skrátené var bitwised = Number("97.654")|0; // nepoužívajte pre veľké čísla

Akýkoľvek bitový operátor (tu som urobil bitový alebo, ale môžete urobiť aj dvojitú negáciu ako v predchádzajúcej odpovedi alebo Bitshift) prevedie hodnotu na 32-bitové celé číslo a väčšina z nich sa prevedie na celé číslo so znamienkom. Upozorňujeme, že toto nebude chcieť, aby ste hľadali veľké celé čísla. Ak celé číslo nemôže byť reprezentované 32 bitmi, bude dokončené.

~~"3000000000.654" === -1294967296 // Toto je to isté ako Číslo("3000000000.654")|0 "3000000000.654" >>> 0 === 00000000 30000000000000000000000>> 0 === 3647256576 // ale stále zlyháva pri väčších číslach

Ak chcete správne pracovať s veľkými číslami, musíte použiť metódy zaokrúhľovania

Math.floor("3000000000.654") === 3000000000 // Toto je rovnaké ako Math.floor(Number("3000000000,654"))

Majte na pamäti, že všetky tieto metódy chápu exponenciálny zápis, takže 2e2 je 200, nie NaN. Number tiež rozumie "nekonečnu", zatiaľ čo metódy analýzy nie.

Vlastné

Je nepravdepodobné, že niektorá z týchto metód robí presne to, čo chcete. Napríklad zvyčajne chcem, aby sa vyskytla chyba, keď analýza zlyhala, a nepotrebujem podporu Infinity, exponenty alebo medzery na začiatku. V závislosti od vášho použitia má niekedy zmysel napísať vlastnú konverznú funkciu.

Vždy skontrolujte, či výstup čísla alebo jedna z metód analýzy zodpovedá očakávanému číslu. Takmer určite budete chcieť použiť isNaN, aby ste sa uistili, že číslo nie je NaN (zvyčajne jediný spôsob, ako zistiť, či analýza zlyhala).

Nezáleží na tom, aký typ premennej je použitý vo výraze. Ak je výraz matematický, všetky jeho premenné budú automaticky interpretované ako číselné. Ak sú spracované reťazce, potom sa so všetkými "účastníkmi" výrazu zaobchádza ako s reťazcami. Úloha previesť JavaScript „reťazec na číslo“ však existuje v oveľa širšom kontexte.

JavaScript metódy na prevod reťazcov na čísla

Arzenál metód na prevod reťazcov na čísla nie je veľký, ale vo všeobecnosti dostatočný jednoduché prípady. JavaScript (najmä pre začiatočníkov) je cesta od jednoduchého k zložitému s praktickými príkladmi.

Bude vás zaujímať:

Príklad popisuje štyri rôzne reťazce. V prvom výstupnom bloku typ každého z nich variabilná funkcia typeof je definovaný ako reťazec. Každý reťazec sa potom veľmi jednoducho prevedie na číslo. V druhom výstupnom bloku môžete vidieť zmeny v premenných po konverzii, z ich typu sa stalo číslo. Príklad konverzie JavaScript parseFloat je obzvlášť výstižný: bolo to „12e+3“, teraz je to „12000“.

Zmeny pri prevode reťazca na číslo môžu byť významné! Dôležité sú však iba prvé znaky: musia byť číselné. Ak nie sú žiadne číselné znaky, výsledkom bude NaN.

Spätná konverzia reťazca, ktorý sa „stane“ číslom, nie je vždy ten istý reťazec. Tento moment je možné využiť na kontrolu správnosti zadávania číselných informácií.