Poslední aktualizace: 1.11.2015

Často je potřeba převádět data na jiná. Například:

varnumber1 = "46"; varnumber2 = "4"; varresult = číslo1 + číslo2; konzolový protokol (výsledek); //464

Obě proměnné představují řetězce, konkrétněji řetězcové reprezentace čísel. A ve výsledku nedostaneme číslo 50, ale řetězec 464. Ale bylo by hezké, kdyby se daly také sčítat, odčítat, obecně by fungovaly jako s běžnými čísly.

V tomto případě můžeme použít transformační operace. Funkce se používá k převodu řetězce na číslo. parseInt():

varnumber1 = "46"; varnumber2 = "4"; var vysledek = parseInt(cislo1) + parseInt(cislo2); konzolový protokol (výsledek); // padesáti

Chcete-li převést řetězce na zlomková čísla aplikovaná funkce parseFloat():

varnumber1 = "46,07"; varnumber2 = "4,98"; var vysledek = parseFloat(cislo1) + parseFloat(cislo2); konzolový protokol (výsledek); //51.05

V tomto případě může mít řetězec smíšený obsah, například "123hello", to znamená, že v tomto případě jsou čísla, ale jsou zde i běžné znaky. Ale metoda parseInt() se přesto pokusí provést konverzi:

Varnum1 = "123ahoj"; varnum2 = parseInt(číslo1); log konzole(číslo2); // 123

Pokud metoda selže při převodu, vrátí NaN (Not a Number), což znamená, že řetězec nepředstavuje číslo a nelze jej převést.

Se speciální funkcí isNaN() můžete zkontrolovat, zda řetězec představuje číslo. Pokud řetězec není číslo, pak funkce vrátí true, pokud je to číslo, pak false:

Var num1 = "javascript"; varnum2 = "22"; varresult = isNaN(číslo1); konzolový protokol (výsledek); // true - číslo1 není číslo výsledek = isNaN(číslo2); konzolový protokol (výsledek); // false - číslo2 je číslo

Výše jsme uvažovali o převodu řetězců na čísla v desítková soustava. Čísla však můžeme převést do libovolného systému. Interpret JavaScriptu standardně sám hádá, do jaké číselné soustavy chceme řetězec převést (obvykle je zvolena desítková soustava). Ale můžeme použít druhý parametr k explicitnímu označení, že chceme převést řetězec na číslo v konkrétním systému. Například převod na číslo v binární systém:

Varnum1 = "110"; varnum2 = parseInt(číslo1, 2); konzolový protokol (číslo2); // 6

Výsledek bude 6, protože 110 v binárním systému je číslo 6 v desítkové soustavě.

Teď pojďme psát malý program, ve kterém používáme operace s proměnnými:

Pomocí funkce prompt() se v prohlížeči zobrazí dialogové okno s výzvou k zadání nějaké hodnoty. Druhý argument této funkce určuje hodnotu, která se má použít jako výchozí.

Funkce prompt() však vrací řetězec. Proto musíme tento řetězec převést na číslo, abychom s ním mohli provádět operace.

Po otevření stránky v prohlížeči se nám zobrazí výzva k zadání částky vkladu:

Poté se zobrazí podobná zpráva pro zadání procenta. A na konci program přijme data, převede je na čísla a provede výpočet.

JavaScript je jazyk s dynamickým typováním dat. To znamená, že můžete zapisovat hodnoty do stejné proměnné různé typy, přičemž se změní typ samotné proměnné. Toto chování často umožňuje zapomenout na odlišné chování proměnných s jiný typ, ale i tak je nutné si tuto funkci zapamatovat. Ukažme si to na následujícím příkladu.

console.log(sum(1, 2)); // 3 (zde je vše v pořádku) console.log(sum(1, "2")); // 12 (a tady ne tolik)

Jak můžete vidět z příkladu, funkce součet chová se nesprávně, pokud alespoň jeden z jeho argumentů není číslo. Faktem je, že při „přidání“ čísla do řetězce se číslo převede na řetězec a ten se spojí (slepí) s druhým operandem.

Abyste se vyhnuli takovým komplikacím, můžete zjistit typ proměnné během provádění skriptu a opravit její chování nebo pečlivě sledovat typy proměnných.

typ operátora

Tento unární operátor bere jako operand absolutně jakoukoli hodnotu a vrací svůj typ v řetězcové proměnné.

JavaScript má následující datové typy:

// 1.) objekt console.log(typeof()); // objekt var p = (x: 1, y: 3); console.log(typeofp); // objekt // 2.) funkce funkce sayHello() ( console.log("Ahoj!"); ) console.log(typeof sayHello); // funkce // 3.) string console.log(typeof "JavaScript"); // řetězec // 4.) číslo console.log(typeof 3.1415); // číslo // 5.) boolean console.log(typeof true); // boolean // 6.) undefined var notExistsOne; console.log(typeof notExistsOne); // nedefinováno console.log(typeof notExistsTwo); // nedefinováno

Všimněte si, že nedefinováno je to také datový typ, který se skládá z jediné hodnoty.

Obsazení

Přetypování v programování je převod hodnoty proměnné jednoho typu na hodnotu jiného typu.
Často k této transformaci dochází bez kontroly programátora. To je vidět na příkladu s funkcí součet. Ke změně typu dochází, když výsledek provádění operace s proměnnou původního typu není jasný. Nelze například přesně říci, co vznikne přidáním řetězce s číslem, ale operace sčítání dvou čísel je zřejmá a v tomto případě je logické přivést číslo k řetězci.

Převést řetězec na číslo

Někdy může programátor sám změnit typ proměnné tím, že na ni použije nějaké operace. Například operace zvýšení nebo snížení řetězce jej převedou na číslo.

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

Stojí za zmínku, že se nemusíte uchýlit k této metodě převodu řetězce na číslo kvůli jeho špatné čitelnosti a nesrozumitelnosti. Pro tento úkol jsou v js vestavěné funkce. parseInt a parseFloat. Jako svůj první argument vezmou řetězec, který se má převést na číslo, a jako svůj volitelný druhý argument vezmou základ číselné soustavy, který obsahuje číslo v předaném řetězci jako první argument. Pokud druhý argument není zadán, bude se mít za to, že řetězec obsahuje číslo v desítkové soustavě čísel.

Funkce parseInt se používá k převodu řetězce na celé číslo a funkce parseFloat převést 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

Všimněte si, že řetězec může obsahovat libovolnou doslovnou číselnou hodnotu, včetně hexadecimální, osmičkové nebo exponenciální.

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)

Jako druhý parametr funkcí parseInt a parseFloat můžete určit základ číselné soustavy.

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

Pokud je hodnota v řetězci, které funkce parseInt a parseFloat vzít jako první parametr, není číselný literál, pak výsledkem provedení těchto funkcí bude hodnota NaN.

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

Konverze řetězce

V Hodnota JavaScriptu jakýkoli typ lze přetypovat na řetězec. Již bylo řečeno výše, že když je řetězec zřetězen s číslem, číslo se redukuje na řetězec a teprve potom dojde ke zřetězení. To se stane s jakýmkoli typem hodnoty.

var str = "Objekt: " + (); konzolový log(str); // Objekt: str = "Pole: " + ; konzolový log(str); // Pole: 1,2,3 funkce suma(a, b) ( return a + b; ) str = "Funkce: " + suma; konzolový log(str); /* Funkce: funkce sum(a, b) ( return a + b; ) */

Ve skutečnosti je při přetypování objektu na řetězec implicitně volána metoda toString, kterou lze také výslovně nazvat.

var p = (x: 2, y: 4), str; str = p.toString(); console.log(typeofstr); // řetězec console.log(str); // str = .toString(); console.log(typeofstr); // řetězec console.log(str); // 1,2,3

Numerický převod

K převodu na číslo dochází při provádění matematické operace a při provádění porovnávací operace s přetypováním typu (==, !=), zatímco hodnota Nepravdivé a prázdné pole se převedou na hodnotu typu 0 číslo.

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

Neprázdné pole, objekt a funkce jsou přetypovány na řetězec při použití v aritmetických výrazech.

var arr = ; console.log(arr + 4); // 1,2,34 funkce sum(a, b)(return a + b;) console.log(sum + 5); // funkce sum(a, b)(return a + b;)5

Jak vidíte, implicitní konverze typu v js není zdaleka vždy zřejmá, takže byste se jí měli vyhnout pomocí funkcí pro explicitní konverzi typu, jako je např. parseInt, parseFloat a toString.

To je vše. Jako vždy, ať se vám daří!

Existují dva hlavní způsoby, jak převést řetězec na číslo v javascriptu. Jedním způsobem je analyzovat jej a jiným způsobem je změnit jeho typ na číslo. Všechny triky v jiných odpovědích (např. unární plus) implikují implicitní donucení typu řetězce k číslu. Totéž můžete udělat také s funkcí Číslo.

Syntaktický

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

ParseInt a parseFloat jsou dvě funkce, které se používají k analýze řetězců na čísla. Analýza se tiše zastaví, pokud narazí na znak, který nepoznává, což může být užitečné pro analýzu řetězců jako „92px“, ale je to také poněkud nebezpečné, protože vám nezpůsobí žádnou chybu na špatném vstupu, místo toho „vrátíte NaN pokud řetězec nezačíná číslem. Mezera na začátku řetězce je ignorována. Zde je příklad něčeho, co dělá něco jiného, ​​co chcete, a nedává žádný náznak, že se něco pokazilo:

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

Je dobrým zvykem vždy uvést jako druhý argument desetinné číslo. Pokud by ve starších prohlížečích řetězec začínal na 0, byl by interpretován jako osmičkový, pokud nebyla zadána hodnota radix, což mnoho lidí překvapilo. Chování pro hex start se spustí, pokud řetězec začíná 0x, pokud není zadaná hodnota radix. 0xff. Standard se skutečně změnil s ecmascriptem 5 tak moderní prohlížeče již nespouštět osmičkové hodnoty, když je úvodní 0, pokud není zadán žádný důvod. parseInt rozumí radikálům až do základu 36, v takovém případě jsou velká i malá písmena považována za ekvivalentní.

Změňte typ řetězce na číslo

Všechny ostatní triky uvedené výše, které nepoužívají ParseInt, zahrnují implicitní vynucení řetězce na číslo. Raději to dělám explicitně

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

To se liší od metod analýzy (ačkoli stále ignoruje mezery). Je přísnější: pokud nerozumí celému řetězci, vrátí NaN , takže jej nemůžete použít pro řetězce jako 97px . Protože chcete primitivní číslo, nikoli objekt obálky Number, ujistěte se, že funkci Number nepředcházíte novým .

Je zřejmé, že převod na číslo dává hodnotu, která může být spíše plovoucí než celé číslo, takže pokud chcete celé číslo, musíte ho změnit. Existuje několik způsobů, jak to provést:

Varrounded = Math.floor(Number("97,654")); // další možnosti jsou Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // spíše zaokrouhlené než zkrácené var bitwised = Number("97.654")|0; // nepoužívejte pro velká čísla

Jakýkoli bitový operátor (zde jsem udělal bitovou nebo, ale můžete také provést dvojitou negaci jako v předchozí odpovědi nebo Bitshift) převede hodnotu na 32bitové celé číslo a většina se převede na celé číslo se znaménkem. Vezměte prosím na vědomí, že toto nebude chtít, abyste hledali velká celá čísla. Pokud celé číslo nemůže být reprezentováno 32 bity, bude dokončeno.

~~"3000000000.654" === -1294967296 // Toto je stejné jako Číslo("3000000000.654")|0 "3000000000.654" >>> 0 === 000000000000000000000000000>> 0 === 3647256576 // ale stále selhává s většími čísly

Chcete-li správně pracovat s velkými čísly, musíte použít metody zaokrouhlování

Math.floor("3000000000.654") === 3000000000 // To je stejné jako Math.floor(Number("3000000000.654"))

Mějte na paměti, že všechny tyto metody rozumí exponenciálnímu zápisu, takže 2e2 je 200, nikoli NaN. Number také rozumí "nekonečnu", zatímco metody analýzy nikoli.

Zvyk

Je nepravděpodobné, že některá z těchto metod dělá přesně to, co chcete. Například obvykle chci chybu při selhání analýzy a nepotřebuji podporu Infinity, exponenty ani úvodní mezery. V závislosti na vašem použití má někdy smysl napsat vlastní konverzní funkci.

Vždy zkontrolujte, zda výstup čísla nebo jedna z metod analýzy odpovídá očekávanému číslu. Téměř jistě budete chtít použít isNaN, abyste se ujistili, že číslo není NaN (obvykle jediný způsob, jak zjistit, zda analýza selhala).

Nezáleží na tom, jaký typ proměnné je ve výrazu použit. Pokud je výraz matematický, všechny jeho proměnné budou automaticky interpretovány jako číselné. Pokud se zpracovávají řetězce, pak se se všemi "účastníky" výrazu zachází jako s řetězci. Úkol převést JavaScript „řetězec na číslo“ však existuje v mnohem širším kontextu.

Metody JavaScriptu pro převod řetězců na čísla

Arzenál metod pro převod řetězců na čísla není velký, ale celkem dostačující jednoduché případy. Zde je JavaScript (zejména pro začátečníky) cestou od jednoduchého ke složitému s praktickými příklady.

Bude vás zajímat:

Příklad popisuje čtyři různé řetězce. V prvním výstupním bloku typ každého z nich variabilní funkce typeof je definován jako řetězec. Každý řetězec se pak velmi jednoduše převede na číslo. V druhém výstupním bloku jsou vidět změny proměnných po převodu, jejich typ se stal číslem. Příklad konverze JavaScript parseFloat je obzvláště odhalující: bylo to „12e+3“, nyní je to „12000“.

Změny při převodu řetězce na číslo mohou být významné! Ale záleží pouze na prvních znacích: musí být číselné. Pokud nejsou žádné číselné znaky, výsledkem bude NaN.

Zpětný převod řetězce, který se "stává" číslem, není vždy stejný řetězec. Tento okamžik lze využít pro kontrolu správnosti zadání číselných informací.