JavaScript rozděluje data na typy, což pomáhá seskupovat data a určovat, jaké hodnoty lze přiřadit a jaké operace lze provést.
Ačkoli JavaScript převádí mnoho hodnot automaticky z důvodu přetypování, je nejlepší převést datové typy ručně, abyste dosáhli očekávaných výsledků.
Tento kurz vás naučí, jak převést primitivní datové typy JavaScriptu, včetně čísel, řetězců a logických hodnot.
Implicitní převod
Programovací jazyk JavaScript zvládá neočekávané hodnoty velmi dobře. JavaScript neodmítá neočekávané hodnoty, ale pokusí se převést. Tato implicitní konverze se také nazývá nátlak typu.
Samostatné metody automaticky převádějí hodnoty na jejich použití. Metoda alert () převezme řetězec jako svůj parametr a automaticky převede další typy na řetězce. Můžete tedy předat číselnou hodnotu této metodě:
Pokud spustíte tento řádek, prohlížeč vrátí vyskakovací okno s hodnotou 8,5, které již bude převedeno na řetězec.
Pomocí řetězců čísel spolu s matematickými operátory zjistíte, že JavaScript dokáže zpracovat hodnoty implicitním převodem řetězců na čísla:
// Odečíst
"15" - "10";
5
// Modul
"15" % "10";
5
Ale ne všichni operátoři pracují předvídatelně. To platí zejména pro operátor +: provádí přidávání čísel a zřetězení řetězců.
// Při práci s řetězci + provádí zřetězení
"2" + "3";
"23"
Protože operátor + má mnoho použití, zachází v tomto příkladu s hodnotami 2 a 3 jako s řetězci, i když jsou vyjádřeny jako číselné řetězce. Proto zřetězí řetězce „2“ a „3“ a dostane 23 a nepřidá 2 a 3 a dostane 5.
K tomuto druhu nejednoznačnosti dochází ve vašem kódu a někdy vytváří neočekávané výsledky, takže je nejlepší explicitně převádět datové typy, kdykoli je to možné. To pomůže při údržbě kódu a zpracování chyb.
Převod hodnot na řetězce
Chcete-li explicitně převést hodnotu na řetězec, zavolejte metodu String () nebo n.toString ().
Zkuste převést boolean true na řetězec pomocí String ().
Tím se vrátí řetězcový literál „true“.
Můžete také zkusit předat číslo funkci:
Vrátí řetězcový literál:
Nyní zkuste použít String () s proměnnou. Přiřaďte proměnné odyssey číselnou hodnotu a pomocí operátoru typeof zkontrolujte typ.
nechť odysea \u003d 2001;
console.log (typeof odyssey);
číslo
Na tento moment odyssey je nastavena na číselnou hodnotu 2001. Operátor typeof potvrdí, že hodnota je číslo.
Nyní přiřaďte proměnné odyssey její ekvivalent uvnitř funkce String () a poté pomocí typeof ověřte, zda je hodnota proměnné úspěšně převedena z čísla na řetězec.
odyssey \u003d řetězec (odysea); // „2001“
console.log (typeof odyssey);
tětiva
Jak vidíte, proměnná odyssey nyní obsahuje řetězec.
Podobným způsobem funguje i funkce n.toString (). Nahraďte n proměnnou.
nechat údery \u003d 400;
blows.toString ();
Proměnlivé údery budou obsahovat strunu.
Místo proměnné můžete zadat hodnotu do závorek:
(1776) .toString (); // vrací „1776“
(false) .toString (); // vrací „false“
(100 + 200). ToString (); // vrátí „300“
String () a n.toString () explicitně převádějí logické a číselné hodnoty na řetězce.
Převod hodnot na čísla
Metoda Number () může převést hodnotu na číslo. Často je nutné převést řetězce skládající se z čísel, ale někdy je také nutné převést logické hodnoty.
Například předejte následující řetězec metodě Number ():
Řetězec bude převeden na číslo a nebude již citován.
Můžete také přiřadit řetězec proměnné a poté ji převést.
ať dalmatians \u003d "101";
Počet (dalmatinů);
101
Řetězcový literál „101“ byl převeden na číslo 101.
Řádky mezer nebo prázdné řetězce budou převedeny na číslo 0.
Číslo (""); // vrátí 0
Číslo (""); // vrátí 0
Uvědomte si, že řetězce, které nejsou složeny z čísel, jsou převedeny na NaN, což znamená Not a Number. To platí také pro čísla oddělená mezerami.
Číslo („dvanáct“); // vrací NaN
Číslo („20 000“); // vrací NaN
Číslo („2 3“); // vrací NaN
Číslo („11-11-11“); // vrací NaN
V booleovských datech bude false 0 a true 1.
Převod hodnot na booleovské hodnoty
Metoda Boolean () se používá k převodu čísel nebo řetězců na booleovské hodnoty. Pomáhá například určit, zda uživatel zadává data do textového pole, či nikoli.
Jakákoli hodnota, která je interpretována jako prázdná, například číslo 0, prázdný řetězec, nedefinováno, NaN nebo , se převede na false.
Boolean (0); // vrátí hodnotu false
Boolean (""); // vrátí hodnotu false
Boolean (undefined); // vrátí hodnotu false
Boolean (NaN); // vrátí hodnotu false
Boolean (null); // vrátí hodnotu false
Ostatní hodnoty, včetně řetězcových literálů skládajících se z mezer, budou převedeny na true.
Boolean (2000); // vrací true
Boolean (""); // vrací true
Boolean („maniaci“); // vrací true
Všimněte si, že řetězcový literál "0" je převeden na true, protože nejde o prázdnou hodnotu:
Boolean ("0"); // vrací true
Převod čísel a řetězců na booleovské hodnoty umožňuje vyhodnocovat data v binární systém a lze je použít k řízení toku programů.
Závěr
Nyní víte, jak JavaScript převádí datové typy. často kvůli přetypování jsou data implicitně převedena, což může vést k neočekávaným hodnotám. Doporučuje se výslovně převádět datové typy, abyste zajistili správné fungování programů.
V JavaScriptu lze hodnoty převádět zcela volně (explicitně a implicitně) z jednoho typu na jiný. Například pokud jakýkoli operátor očekává, že obdrží hodnotu určitého typu a bude mu předána hodnota jiného typu, pak se interpret automaticky pokusí provést převody na požadovaný typ:
Console.log (10 + "stroje"); // "10 aut". Číslo je implicitně převedeno na řetězec console.log ("7" * "4"); // 28. Oba řetězce jsou implicitně převedeny na čísla
Implicitní převod - to je případ, kdy tlumočník automaticky provede převod typu, tj. bez účasti programátora. Explicitní převod - to je případ, kdy převod provádí sám programátor. Explicitní převod se také nazývá odlévání typu:
Console.log ("7" * "4"); // 28. Implicitní převod console.log (Number ("7") * Number ("4")); // 28. Explicitní převod
Níže uvedená tabulka popisuje, jak JavaScript převádí hodnoty z jednoho typu na jiný. Prázdné buňky odpovídají situacím, kdy není nutná žádná transformace:
| Hodnota | Převod na: | |||
|---|---|---|---|---|
| Tětiva | Číslo | Booleovský | Objekt | |
| nedefinováno nula | "nedefinováno" "nula" | NaN 0 | nepravdivé nepravdivé | chyba TypeError chyba TypeError |
| skutečný nepravdivé | "skutečný" "Nepravdivé" | 1 0 | new Boolean (true) new Boolean (false) |
|
| „“ (prázdný řádek) "1.2" "jeden" "-10" "+10" "011" „0xff“ |
0 1.2 NaN -10 10 11 255 |
nepravdivé skutečný skutečný skutečný skutečný skutečný skutečný |
nový řetězec ("") nový řetězec ("1.2") nový řetězec („jeden“) nový řetězec ("- 10") nový řetězec ("+ 10") nový řetězec („011“) nový řetězec („0xff“) |
|
| 0 -0 NaN Nekonečno -Nekonečno 3 | "0" "0" „NaN“ "Nekonečno" "-Nekonečno" "3" | nepravdivé nepravdivé nepravdivé skutečný skutečný skutečný | nové číslo (0) nové číslo (-0) nové číslo (NaN) nové číslo (nekonečno) nové číslo (-Infinity) nové číslo (3) |
|
| () (jakýkoli objekt) (prázdné pole) | viz Převádění objektů "" | viz Převádění objektů 0 9 NaN NaN | skutečný skutečný | |
Pro explicitní převod na jednoduché typy se používají následující funkce: Boolean (), Number (), String (). V implicitní konverzi používá tlumočník stejné funkce, které se používají pro explicitní převod.
Pro explicitní převod můžete místo funkcí použít operátory. Pokud je například jeden z operandů operátoru + řetězec, pak se druhý operand také převede na řetězec. Unární operátor + převede svůj operand na číslo. Unární operátor! převede operand na booleovskou hodnotu a invertuje ji. To vše vedlo ke vzniku následujících zvláštních způsobů převodu typu, které lze v praxi nalézt:
X + "" // Stejné jako řetězec (x) + x // Stejné jako číslo (x). Můžete také vidět x - 0 !! x // Stejné jako Boolean (x)
Převod na čísla
Funkce Number () převádí hodnoty podle následujících pravidel:
- Booleovské hodnoty true a false jsou převedeny na 1, respektive 0.
- Čísla jsou vrácena beze změny.
- Null se převede na 0.
- Nedefinovaná hodnota se převede na NaN.
Pro řetězce existují speciální pravidla:
- Pokud řetězec obsahuje pouze číslice s úvodním znakem + nebo - nebo bez znaménka, je vždy převeden na celé desetinné číslo. Počáteční nuly jsou ignorovány, například „0011“ se převede na 11.
- Pokud je řetězec číslem s plovoucí desetinnou čárkou s počátečním znakem + nebo - nebo bez znaménka, je převeden na odpovídající číslo s plovoucí desetinnou čárkou (počáteční nuly jsou také ignorovány).
- Pokud je řetězec šestnáctkové číslo, je převedeno na odpovídající celé číslo v desítkové soustavě.
- Pokud je řetězec prázdný, je převeden na 0.
- Pokud řetězec obsahuje něco jiného než předchozí možnosti, je převeden na NaN.
- U objektů se volá metoda valueOf () a její návratová hodnota se automaticky převede podle předchozích pravidel. Pokud je výsledkem tohoto převodu NaN, je volána metoda toString () a jsou použita pravidla pro převod řetězců na čísla.
Unární operátory + a - se řídí stejnými pravidly jako funkce Number ().
Převádění na booleovské hodnoty
Funkce Boolean () převede hodnotu na booleovský ekvivalent:
- Následující hodnoty jsou převedeny na false: undefined, , 0, -0, NaN, "".
- False se vrací beze změny.
- Všechny ostatní hodnoty jsou převedeny na true.
Převod na řetězce
Funkce String () převádí hodnoty podle následujících pravidel:
- Pro všechny hodnoty kromě null a undefined je automaticky volána metoda toString () a je vrácena řetězcová reprezentace hodnoty.
- U hodnoty null se vrátí řetězec „null“.
- U nedefinovaných je vrácen řetězec „undefined“.
Převod jednoduchých typů na objekty
K převodu jednoduchých hodnot na objekty se používají konstruktory Boolean (), Number (), String ():
Var oNum \u003d nové číslo (3); var oStr \u003d nový řetězec ("1.2"); var oBool \u003d new Boolean (true); výstraha (typ čísla); // "objekt" upozornění (typ oStr); // "objekt" upozornění (typ oBool); // „objekt“
Převod objektů na jednoduché hodnoty
Všechny objekty dědí dvě metody převodu: toString () a valueOf ().
Metoda toString () vrací řetězcovou reprezentaci objektu. Ve výchozím nastavení nevrací nic zajímavého:
Výstraha ((x: 1) .toString ()); // „“
Některé typy mají více specializované verze metody toString (). Například metoda toString () pole převede všechny jeho prvky na řetězce a poté je zřetězí do jednoho řetězce a vloží mezi ně čárky:
Výstraha (.toString ()); // „1,2,3“
Účel metody valueOf () není tak dobře definován: předpokládá se, že převede objekt na jednoduchou hodnotu, která ji představuje, pokud taková hodnota existuje. Objekty jsou ze své podstaty složené hodnoty a většinu objektů nelze reprezentovat jako jednu jednoduchou hodnotu, takže metoda valueOf () ve výchozím nastavení nevrací jednoduchou hodnotu, ale odkaz na ni:
Výstraha (typeof (x: 2) .valOO ()); // „objekt“
Při převodu objektu na řetězec interpret jazyka JavaScript provede následující akce:
- Pokud má objekt metodu toString (), volá ji tlumočník. Pokud vrátí jednoduchou hodnotu, tlumočník převede hodnotu na řetězec (pokud se nejedná o řetězec) a vrátí výsledek převodu.
- Pokud objekt nemá metodu toString () nebo tato metoda nevrací jednoduchou hodnotu, pak tlumočník zkontroluje přítomnost metody valueOf (). Pokud je tato metoda definována, tlumočník ji volá. Pokud vrátí jednoduchou hodnotu, interpret převede tuto hodnotu na řetězec (pokud to není řetězec) a vrátí výsledek převodu.
Při převodu objektu na číslo provede tlumočník totéž, ale nejprve vyzkouší metodu valueOf ():
- Pokud má objekt metodu valueOf (), která vrací jednoduchou hodnotu, interpret převede (je-li to nutné) tuto hodnotu na číslo a vrátí výsledek.
- Pokud objekt nemá metodu valueOf () nebo tato metoda nevrací jednoduchou hodnotu, pak tlumočník zkontroluje existenci metody toString (). Pokud má objekt metodu toString (), která vrací jednoduchou hodnotu, provede interpret převod a vrátí výslednou hodnotu.
- V opačném případě tlumočník dospěje k závěru, že ani toString () ani valueOf () neumožňuje získání jednoduché hodnoty a vyvolá TypeError.
Metody toString () a valueOf () jsou čteny / zapisovány, takže je lze přepsat a explicitně určit, co konverze vrátí:
Var obj \u003d (); obj.toString \u003d function () (návrat "object";); alert ("This" + obj); // "Toto je objekt"
Poslední aktualizace: 1. 11. 2015
Často je nutné převádět jedno údaje na jiné. Například:
Var číslo1 \u003d "46"; var number2 \u003d "4"; var výsledek \u003d číslo1 + číslo2; console.log (výsledek); // 464
Obě proměnné představují řetězce nebo spíše řetězcové reprezentace čísel. A nakonec nedostaneme číslo 50, ale řetězec 464. Ale bylo by hezké, kdyby se daly také sčítat, odčítat, obecně, pracovat jako s běžnými čísly.
V tomto případě můžeme použít transformační operace. Chcete-li převést řetězec na číslo, použijte funkci parseInt ():
Var číslo1 \u003d "46"; var number2 \u003d "4"; var result \u003d parseInt (číslo1) + parseInt (číslo2); console.log (výsledek); // padesátka
Chcete-li převést řetězce na zlomková čísla, použijte funkci parseFloat ():
Var number1 \u003d "46.07"; var number2 \u003d "4,98"; var result \u003d parseFloat (číslo1) + parseFloat (číslo2); console.log (výsledek); //51.05
V tomto případě může mít řetězec smíšený obsah, například „123hello“, tj. V tento případ existují čísla, ale existují i \u200b\u200bběžné symboly. Metoda parseInt () se ale přesto pokusí provést převod:
Var num1 \u003d "123hello"; var num2 \u003d parseInt (num1); console.log (num2); // 123
Pokud se metoda nepodaří převést, 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, vrátí funkce true, pokud je toto číslo false:
Var num1 \u003d "javascript"; var num2 \u003d "22"; var výsledek \u003d isNaN (num1); console.log (výsledek); // true - num1 není číselný výsledek \u003d isNaN (num2); console.log (výsledek); // false - num2 je číslo
Nahoře jsme uvažovali o převodu řetězců na čísla v desítkové soustavě. Můžeme však přeložit čísla do jakéhokoli systému. Ve výchozím nastavení interpret jazyka JavaScript sám odhaduje, na který číselný systém chceme řetězec převést (zpravidla je zvolen desítkový systém). Ale můžeme použít druhý parametr k výslovné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í podobě:
Var num1 \u003d "110"; var num2 \u003d parseInt (num1, 2); console.log (num2); // 6
Výsledek je 6, protože 110 v binárním formátu je 6 v desítkovém formátu.
Nyní napíšeme malý program, ve kterém používáme operace s proměnnými:
Pomocí funkce prompt () prohlížeč zobrazí dialogové okno s výzvou k zadání určité hodnoty. Druhý argument této funkce označuje výchozí hodnotu.
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:
Podobná zpráva se poté zobrazí pro zadání procenta. A na konci program přijme data, převede je na čísla a provede sčítání.
Ahoj milí čtenáři. Dnes napíšu, jak se to transformuje javascript řetězec na číslo. To se provádí pomocí funkce Number, prozatím vám ukážu, jak ji použít na příkladu.
Navrhuji také sledovat video verzi tohoto článku:
Trochu o datových typech
Jak víte, v JavaScriptu existují číselné a řetězcové datové typy. Pokusme se vytvořit dvě proměnné, do kterých budeme ukládat čísla, a poté zobrazit výsledek na obrazovce.
Var a \u003d 5; var b \u003d 12; document.write (a + b);
Jaký bude výsledek? 17, což nám přinesl prohlížeč. Jedná se tedy o číselná data, takže je prohlížeč úspěšně přidal. Nyní vytvořme další dvě proměnné, do kterých vložíme stejné hodnoty, ale do uvozovek. Dovolte mi připomenout, že všechny řetězce v JavaScriptu jsou psány v uvozovkách.
Var c \u003d "5"; var d \u003d "12"; document.write ("
"+ c + d);
Nyní prohlížeč považuje naše data za řetězce, a pokud je přidáme, jednoduše se přidají dva řádky a dostaneme 512, což není správný výsledek, pokud byla přidána čísla, ale je správný, pokud dáme dva řetězce dohromady.
Jak mohu převést v JavaScriptu řetězec na číslo?
Všechno je zde jednoduché, vytvořme další dvě proměnné, do kterých zapíšeme stejnou hodnotu, která je nastavena na proměnné ca ad, ale předáme je metodou Number:
Var e \u003d číslo (c); var f \u003d číslo (d); document.write (e + f);
Pokud se nyní pokusíte zobrazit výsledek z tohoto přidání na obrazovce, zobrazí se 17. Je to proto, že naše metoda úspěšně fungovala a převedla řetězec na číslo. Chci poznamenat, že pokud píšete takto:
Document.write ("
"+ e + f);
Poté se na obrazovce zobrazí 512, protože při přidávání řetězců a čísel JE VŽDY výsledek je převeden na řetězec. Pokud chcete přidat konec řádku a přesto zachovat správný výsledek, můžete vše napsat na dva řádky nebo jeden řádek takto:
Document.write ("
"+ (e + f));
Pokud uzavřete čísla v závorkách, nebudou převedena na řetězce a úspěšně uloží jejich vlastnosti. Zde je takový krátký článek, který dnes mám. Doufám, že se vám javascript stal trochu jasnějším.
JavaScript má 2 vestavěné funkce pro převod řetězců na čísla: parseFloat () a parseInt ().
parseFloat () bere jako argument řetězec, který má být přetypován na číselný typ, a vrátí float. Číslo musí být na začátku řádku. Pokud jsou za číslem v řetězci další znaky, budou zkráceny. Částečná část čísla musí být napsána oddělená tečkou (čárka není vnímána jako oddělovač) Pokud parseFloat () nemůže převést řetězec, vrátí NaN.
Funkce také dokáže zpracovat „číslo n vynásobené 10 na mocninu x“, které se obvykle píše v programování pomocí písmene E, například: 0,5E6 nebo 0,5E + 6. Stupeň může být také záporný: 0,5E-6, což se rovná 0,5 * 10 ^ -6 nebo 0,5 / 1 000 000.
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
Funkce parseInt (string [, radix]) vezme řetězec jako svůj první argument, analyzuje jej a vrátí celé číslo (celočíselný typ). Funkce se pokusí analyzovat číselný systém, ve kterém je zapsáno číslo ve zdrojovém řetězci (například desítkové, osmičkové nebo šestnáctkové, ale nejen tyto). Číselný systém lze také výslovně specifikovat jeho předáním jako druhého parametru radix. Parametr radix může mít libovolné číslo mezi 2 a 36 (systémy nad 10 používají anglickou abecedu, A až Z).
Funkce nezpracovává čísla jako 1.5e6 stejným způsobem jako parseFloat ().
Přečtěte si níže uvedené příklady, abyste se nezasekli o úskalích skrytých ve funkci parseInt ().
ParseInt ("" 25 "") // 25 parseInt ("" - 25 "") // -25 parseInt ("" 45.12 "") // 45 parseInt ("" 045 "", 10) // 45 parseInt ( "" 70 "", 8) // 56 (70 v osmičkovém je 56 v desítkovém) parseInt ("" 070 "") // 56 (DŮLEŽITÉ !!! první nula způsobí, že funkce analyzuje řetězec jako osmičkové číslo ) parseInt ("" 88 "", 8) // NaN (v osmičkové soustavě není 8) parseInt ("" a1 "") // NaN (DŮLEŽITÉ !!! Funkce nezachází s číslem jako hex výchozí, pokud jej nepřidáte na začátek řádků 0x) parseInt ("" a1 "", 16) // 161 (číselný systém je zde výslovně uveden) parseInt ("" 0xa1 "") // 161 (správný hexadecimální formát , druhý parametr můžete vynechat) parseInt ("" 099 "") // 0 (DŮLEŽITÉ !!! Číslo je interpretováno jako osmičkové, ale obsahuje neplatné znaky) parseInt ("" 0,5e6 "") // 0 (DŮLEŽITÉ !!! nefunguje jako parseFloat) parseInt ("" ZZ "", 36) // 1295 parseInt ("" - FF "") // NaN parseInt ("" - FF "", 16) // -255
Pokud zpracováváte data z textového pole, které zadá uživatel, vždy použijte parseInt () s druhým parametrem radix, to ochrání váš kód před neočekávanými výsledky.