Javascript kontroluje typ premennej. Získajte typ operátora

a = (b> 0) && (c + 1! = d); vlajka =! (stav = 0);

Tabuľka 14.5. Logickí operátori

Popis operátora

! NIE (logická inverzia)

&& AND (logické násobenie)

|| ALEBO (logické sčítanie)

Tabuľka 14.6. Výsledky spustenia operátorov AND a OR

Operand 1	Operand 2

Tabuľka 14.7. Výsledky vyhlásenia NOT

Získajte typ operátora

Získajte operátor typu typeof vráti reťazec popisujúci dátový typ operandu. Operand, ktorého typ chcete vedieť, je umiestnený za týmto operátorom a je uzavretý v zátvorkách:

s = typeof ("str");

V dôsledku tohto výrazu bude premenná s obsahovať reťazec „string“ označujúci typ reťazca.

Všetky hodnoty, ktoré môže operátor typeof vrátiť, sú uvedené v tabuľke. 14.8.

	Tabuľka 14.8. Hodnoty vrátené operátorom typeof

Dátový typ		Vrátený reťazec

Reťazec

Numerické



		Tabuľka 14.8 (koniec)

Dátový typ	Vrátený reťazec

Logické

Kompatibilita a konverzia dátových typov

Teraz je načase zvážiť dve ďalšie dôležité otázky: kompatibilitu dátového typu a prevod z jedného typu na druhý.

Čo sa stane, keď spojíte dve čísla? Správne - ešte jedna číselná hodnota. A ak pridáte číslo a reťazec? Ťažko povedať ... JavaScript sa tu stretáva s problémom nekompatibility dátových typov a pokúša sa ich zlučiť prevedením jedného z nich do druhého. Najprv sa pokúsi previesť reťazec na číslo a v prípade úspechu vykoná sčítanie. V prípade neúspechu sa číslo prevedie na reťazec a dva výsledné reťazce sa spoja. Napríklad spustením webového skriptu v zozname 14.6 sa hodnota b zmení na číslo, keď sa pridá do a; premenná c bude teda obsahovať hodnotu 23.

Výpis 14.6

var a, b, c, d, e, f; a = 11;

b = "12"; c = a + b;

d = "JavaScript"; e = 2;

Pretože však hodnotu d nemožno previesť na číslo, hodnota e sa prevedie na reťazec a výsledok - hodnota f - sa stane

Booleovské hodnoty sa podľa potreby prevedú na číselné alebo reťazcové hodnoty. True bude prevedené na číslo 1 alebo reťazec „1“ a nepravdivé bude prevedené na 0 alebo „0“. Naopak, číslo 1 bude konvertované na true a číslo 0 bude prevedené na false. Tiež sa prevedie hodnota false

hodnoty sú null a nedefinované.

	Časť III. Správanie webových stránok. Webové skripty

Je vidieť, že JavaScript má problémy so správnym vykonaním aj nesprávne napísaných výrazov. Niekedy to funguje, ale častejšie všetko nefunguje podľa plánu a nakoniec sa spustenie webového skriptu preruší z dôvodu zistenia chyby na úplne inom mieste, na úplne správnom operátorovi. Preto je lepšie takéto incidenty nepripúšťať.

Priorita operátora

Posledným problémom, na ktorý sa tu pozrieme, je prednosť operátora. Ako si pamätáme, prednosť ovplyvňuje poradie, v ktorom sa výrazy vykonávajú.

Nech je nasledujúci výraz:

V tomto prípade sa najskôr k hodnote premennej b pripočíta hodnota c a potom sa zo súčtu odčíta 10. Operátory tohto výrazu majú rovnakú prioritu, a preto sa vykonávajú striktne zľava doprava.

Teraz zvážte nasledujúci výraz:

Tu sa najskôr hodnota c vynásobí 10 a až potom sa k výslednému produktu pripočíta hodnota b. Operátor násobenia má prednosť pred operátorom sčítania, takže prísne objednávanie zľava doprava bude mimo prevádzky.

Najnižšiu prioritu majú operátori priradenia. Preto je najskôr vyhodnotený samotný výraz a potom je jeho výsledok priradený k premennej.

V. Všeobecne platí, že základný princíp vykonávania všetkých operátorov je nasledujúci: najskôr sa vykonajú operátori s vyššou prioritou a až potom operátori s nižšou prioritou. Operátory s rovnakou prioritou sa vykonávajú v poradí, v akom sa zobrazujú (zľava doprava).

V. tab. 14.9 uvádza všetkých operátorov, ktorých sme skúmali, zostupne podľa ich priority.

		Tabuľka 14.9. Prednosť operátora (zostupne)

	Operátori	Popis

	++ - - ~! Typ	Prírastok, úbytok, zmena znamienka, logické NIE, odvodenie typu

		Násobenie, delenie, pričom zvyšok

		Sčítanie a spájanie reťazcov, odčítanie


		Operátori porovnávania
		Operátori porovnávania


		Logické AND

Kapitola 14. Úvod do webového programovania. Jazyk JavaScript

		Tabuľka 14.9 (koniec)

Operátori	Popis

	Logické ALEBO

	Podmienený operátor (pozri nižšie)

= <оператор>=	Zadanie, jednoduché a zložité

POZOR!

Pamätajte si túto tabuľku. Nesprávny príkaz na vykonanie príkazu môže viesť k ťažko rozpoznateľným chybám, v ktorých zdanlivo úplne správny výraz dáva nesprávny výsledok.

Ale čo keď potrebujeme prelomiť bežný poriadok vykonávania príkazov? Použime zátvorky. S týmto zápisom sa najskôr vykonajú vyhlásenia uzavreté v zátvorkách:

a = (b + c) * 10;

Tu sa najskôr vykoná sčítanie hodnôt premenných b a c a potom sa výsledný súčet vynásobí 10.

Prednosť majú aj operátori uvedení v zátvorkách. Preto sa často používa viacero vnorených zátvoriek:

a = ((b + c) * 10 - d) / 2 + 9;

Tu sa príkazy vykonajú v nasledujúcom poradí:

1. Dodatok b a c.

2. Výslednú sumu vynásobte 10.

3. Odčítanie d z produktu.

4. Rozdelenie rozdielu na 2.

5. Pridajte 9 do kvocientu.

Ak odstránite zátvorky:

a = b + c * 10 - d / 2 + 9;

potom bude poradie vykonávania operátorov nasledovné:

1. Násobenie c a 10.

2. Delenie d na 2.

3. Doplnok b a výrobky c a 10.

4. Odčítanie kvocientu od delenia od výslednej sumy d do 2.

5. K výslednému rozdielu pripočítame 9.

Výsledok je úplne iný, však?

Nedefinované: „nedefinované“
Null: "objekt"
Booleovský: „booleovský“
Číslo: "číslo"
Reťazec: „reťazec“
Funkcia: "funkcia"
Všetko ostatné: „predmet“

K tejto tabuľke by mali byť pridané nasledujúce poznámky:

1. typeof null === "objekt".

Teoreticky je to jemný bod. V jazykoch so statickým typom nesmie premenná typu objektu obsahovať objekt (NULL, nula, nulový ukazovateľ).

V praxi je to v JavaScripte nepohodlné. Vývojári ES 5.1 teda urobia intuitívnejšiu vec: typeof null === "null".

Ale keďže ES3 zatiaľ máme, nemýlite sa napríklad v tomto:

/ * Funkcia vyhľadá nejaký objekt a vráti ho alebo vráti hodnotu null, ak sa nič nenájde * / funkcia search () () var obj = search (); if (typeof obj === "object") (// skutočne sme našli objekt (FAIL) obj.method ();)

2. Nezabudnite na objekty obalu (typ nového čísla (5) === "objekt").

3. A nezabudnite na právo prehliadačov robiť čokoľvek s hostiteľskými objektmi.

Nenechajte sa prekvapiť, že Safari si tvrdohlavo myslí, že HTMLCollection je typ funkcie, a IE pred verziou 9 uchovával našu obľúbenú funkciu alert () ako objekt. Tiež prehliadač Chrome považoval funkciu RegExp za funkciu, ale teraz sa zdá, že ju vycítil a odpovedal na ňu objektom.

natiahnuť ()

Pokúšať sa zistiť typ hodnoty z výsledku metódy toString () je zbytočné. Vo všetkých „triedach“ je táto metóda prepísaná na svoju vlastnú.

Metóda je vhodná na zobrazenie informácií o ladení, ale typ premennej ňou nemožno určiť.

Object.prototype.toString ()

Aj keď je toString predefinovaný v rámci konkrétnych „tried“, stále máme jeho pôvodnú implementáciu z Object. Skúsme to použiť:

console.log (Object .prototype .toString .call (hodnota));

console.log (Object.prototype.toString.call (hodnota));

Clinton túto záťaž zriedi

Je iróniou, že táto metóda funguje prekvapivo dobre.

Pri skalárnych typoch vráti ,,,.

Vtipné je, že sa vracia aj nové Číslo (5), na ktorom tu zlyhal typ chyby.

Metóda zlyhá v prípade hodnoty null a nedefinovanej. Vracajú sa rôzne prehliadače, niekedy očakávané a niekedy všeobecne. Je však ľahké určiť typ týchto dvoch hodnôt bez neho.

Zábava začína, keď sa dostaneme k objektom (k tým s typeof === "objekt").

vstavané objekty fungujú prakticky bez problémov:

{} —
—
Dátum -
Chyba -
RegExp -

Jediná vec, ktorá vypadne zo zoznamu argumentov, je to, že.
S hostiteľskými objektmi sa veci opäť zhoršujú.

V IE sa objekty DOM začali stávať „normálnymi“ objektmi až od 8. verzie a potom nie celkom do konca. Preto v IE 6-8 sú všetky tieto objekty (HTMLCOllection, DOMElement, TextNode a spolu s dokumentom a oknom) jednoducho prevedené na.

Vo všetkých ostatných prehliadačoch (vrátane IE9) už môžete s výsledkom toString niečo urobiť. Aj keď všetko tiež nie je jednoduché: HTMLCollection teda existuje. okno - potom, potom, potom. Ale už sa môžete pokúsiť z toho niečo vyťažiť.

S DOMElement je to ťažšie: zobrazuje sa ako, - vlastný formát pre každú značku. Ale tu nám pravidelná sezóna pomôže.

Príbeh je približne rovnaký s inými hostiteľskými objektmi (v testoch určovania polohy a navigátora). Všade okrem IE ich možno identifikovať podľa reťazca.

Nevýhody používania Object.prototype.toString ():

1. Táto príležitosť nie je posvätená štandardom. A tu by sme sa mali radšej radovať z toho, že všetko funguje tak dobre, ako lamentovať nad niektorými chybami.

2. Určenie typu analýzou reťazca vráteného metódou, ktorá vôbec nie je na určenie typu a je tiež volaná na predmet, do ktorého nepatrí, zanecháva v duši určité zvyšky.

3. V starom IE, ako vidíte, hostiteľské objekty zvyčajne nie sú identifikované.

Pri použití v spojení s inými nástrojmi je to však celkom funkčný kus.

Konštruktéri

A nakoniec, konštruktéri. Kto môže lepšie povedať o „triede“ objektu v JS, ak nie je jeho konštruktérom?

Null a undefined nemajú ani wrapper objekty, ani konštruktory.

Ostatné skalárne typy majú obaly, respektíve môžete získať konštruktor:

(5) .constructor === Číslo; (Číslo .NaN) .konštruktor === Číslo; (true) .constructor === Boolean; ("reťazec") .constructor === Reťazec;

(5) .constructor === Číslo; (Number.NaN) .constructor === Number; (true) .constructor === Boolean; ("reťazec"). constructor === Reťazec;

Ale instanceof tu nebude fungovať:

5 inštancia čísla; // falošné číslo .NaN inštancia Number; // false true instance of Boolean; // false "string" instanceof String; // nepravda

5 inštancia čísla; // falošné Number.NaN inštancia Number; // false true instance of Boolean; // false "string" instanceof String; // nepravda

(instanceof bude fungovať pre nové trpezlivé číslo (5))

S funkciami (ktoré sú tiež objektmi) instanceof prejde:

console.log ((function () ()) inštancia funkcie); // true console.log ((function () ()) .constructor === Funkcia); // pravda

console.log ((function () ()) inštancia funkcie); // true console.log ((function () ()). constructor === Funkcia); // pravda

Všetky objekty vstavaných tried sú tiež ľahko identifikovateľné ich konštruktérmi: Array, Date, RegExp, Error.

Jeden problém tu vzniká s argumentmi, ktorých konštruktorom je Object.

A druhý so samotným Objektom, respektíve ako naň odkazovať objekt vytvorený pomocou vlastného konštruktora.

Takto je možné definovať iba základný objekt:

obj instanceof Object;

Ako jeden z variantov definície - iterovať všetky ostatné možné typy (pole, chyba ...) a ak sa žiadny nezhoduje - „objekt“.

Konštruktory a hostiteľské objekty

S hostiteľskými objektmi sa veci zhoršujú.

Začnime s tým, že IE až do 7. verzie ich vôbec nepovažuje za normálne objekty. Jednoducho tam nemajú konštruktérov a prototypy (v každom prípade ich programátor nemôže dosiahnuť).

Ostatné prehliadače sú na tom lepšie. Existujú konštruktory a môžete ich použiť na určenie triedy hodnôt. V rôznych prehliadačoch sa iba inak volajú. Napríklad pre HTMLCollection bude konštruktor buď HTMLCollection alebo NodeList, alebo dokonca NodeListConstructor.

Mali by ste tiež definovať základný konštruktor pre DOMElement. Vo FF je to napríklad HTMLElement, z ktorého sa už dedí HTMLDivElement a ďalšie.

FireFox pod verziou 10 a Opera pod verziou 11 žartuje. Konštruktérom zbierky je Object.

konštruktér.názov

Konštruktéri majú aj vlastnosť názvu, ktorá môže byť užitočná.

Obsahuje názov funkcie konštruktora, napríklad (5) .constructor.name === "Číslo".

Ale:
1. V IE vôbec neexistuje, dokonca ani v 9.
2. Prehliadače opäť vytvarujú všetko do hostiteľských objektov (a často túto vlastnosť vôbec nemajú). V Opere má DOMElement názov konštruktora vo všeobecnom Function.prototype.
3. argumenty je opäť „objekt“.

závery

Žiadna z uvedených metód neposkytuje stopercentnú definíciu typu / triedy hodnoty vo všetkých prehliadačoch. Spoločne vám to však umožňujú.

V blízkej budúcnosti sa pokúsim zhromaždiť všetky údaje do tabuliek a uviesť príklad definujúcej funkcie.

JavaScript alebo Js(skrátene) nie je ľahký jazyk a začínajúci vývojári sa o ňom hneď nedozvedia. Najprv sa naučia základy a všetko sa zdá byť farebné a krásne. Keď ideme trochu hlbšie, objavia sa polia JavaScriptu, objekty, spätné volania a podobne, ktoré mozog často vyberie.

V JavaScripte je dôležité správne skontrolovať typ premennej. Povedzme, že chcete vedieť, či je premenná pole alebo objekt? Ako to správne skontrolovať? V tomto konkrétnom prípade existujú triky počas kontroly a o tom bude tento záznam. Začnime hneď.

Kontrola typu premennej

Napríklad musíte skontrolovať, či je premennou objekt, pole, reťazec alebo číslo. Na to môžete použiť typeof, ale nie vždy vám to dá za pravdu a v nasledujúcom príklade ukážem prečo.

Tento príklad som napísal, aby som ilustroval, prečo nie je typeof vždy tou správnou voľbou.

Var _comparison = (string: "string", int: 99, float: 13.555, object: (hello: "hello"), pole: new Array (1, 2, 3)); // Vráti pole s kľúčmi objektu var _objKeys = Object.keys (_comparison); pre (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Výsledok spustenia kódu:

Objekt objektu číslo reťazca číslo

Správny? - Samozrejme, že nie. Existujú dva problémy. Každý z nich bude podrobne popísaný a navrhne sa riešenie.

Prvý problém: float number, výstup ako číslo

Comparison.float nie je číslo a namiesto čísla by mal byť float. Ak to chcete opraviť, môžete vytvoriť funkciu s overením ako v nižšie uvedenom kóde.

Var _floatNumber = 9,22; var _notFloatNumber = 9; console.log (isFloat (_floatNumber)); console.log (isFloat (_notFloatNumber)); console.log (isFloat ("")); funkcia isFloat (n) (návratové číslo (n) === n && n% 1! == 0;)

Funkcia isFloat () kontroluje všetky hodnoty pre čísla s pohyblivou rádovou čiarkou. Najprv skontroluje, či je premenná rovná nčíslo (Číslo (n) === n) a ak áno, vykoná sa ďalšia kontrola na delenie na zvyšok a ak existuje zvyšok, potom na booleovský ( pravda alebo falošný) výsledok (n% 1! == 0).

V príklade vyššie sa vráti pravda, falošný a falošný... Prvý význam je plavák typ, druhý nie je - toto je obyčajné číslo a posledný je len prázdny reťazec, ktorý nevyhovuje pravidlám.

Druhý problém: pole bolo definované ako objekt

V úplne prvom prípade bolo pole zobrazené ako objekt a to nie je príliš dobré, pretože niekedy musíte použiť tento konkrétny typ a nič iné.

Existuje niekoľko spôsobov, ako testovať premennú pre typ poľa.

Prvá možnosť (dobrá možnosť). Pomocou inštancie () skontrolujeme, či údaje patria do poľa.

Údaje Var = nové pole („ahoj“, „svet“); var isArr = dátová inštancia poľa;

Druhá možnosť (dobrá možnosť). Metóda Array.isArray () vracia logickú hodnotu, ktorá bude závisieť od toho, či je premenná pole alebo nie ().

Údaje Var = nové pole („ahoj“, „svet“); var isArr = Array.isArray (údaje);

Tretia možnosť (najlepšia, ale najdlhšia). Z dôvodu pohodlia z toho môžete urobiť funkciu. Používame Object. Ak výsledok Object.prototype.toString.call (údaje) nie je rovnaký, premenná nie je pole ().

Údaje Var = nové pole („ahoj“, „svet“); var isArr = Object.prototype.toString.call (údaje) == ""; console.log (isArr);

Posledný výsledok ako praktická funkcia:

Funkcia isArray (údaje) (návrat Object.prototype.toString.call (data) == "")

Teraz môžete zavolať funkciu isArray () a ako argument nastaviť pole alebo niečo iné a uvidíte výsledok.

Doslov

Záznam sa ukázal byť dosť veľký, ako sa pôvodne predpokladalo. Som s ním však spokojný, pretože stručne a zrozumiteľne popisuje ťažkosti pri kontrole premenných v JavaScripte a spôsob, ako ich obísť.

Ak máte ďalšie otázky, napíšte ich nižšie k tomuto záznamu. Rád pomôžem.

Operátor Typ vráti reťazec označujúci typ operandu.

Syntax

Operand nasleduje typ operátora:

Typ operand

možnosti

operand je výraz, ktorý predstavuje objekt alebo primitív, ktorého typ má byť vrátený.

Popis

Nasledujúca tabuľka uvádza možné návratové hodnoty typu typeof. Viac informácií o typoch a primitívach je na stránke.

Príklady

// typ čísiel 37 === "číslo"; typ 3.14 === "číslo"; typeof (42) === "číslo"; typ matematiky.LN2 === "číslo"; typ nekonečna === "číslo"; typ NaN === "číslo"; // napriek tomu, že ide o typ čísla (1) === "číslo"; // tento záznam nikdy nepoužívajte! // Reťazce typeof "" === "string"; typ "bla" === "reťazec"; typ "1" === "reťazec"; // všimnite si, že číslo v reťazci je stále typu string typeof (typeof 1) === "string"; // typeof v tomto prípade vždy vráti reťazec typeof String ("abc") === "string"; // tento záznam nikdy nepoužívajte! // Booleans typeof true === "boolean"; typeof false === "boolean"; type of Boolean (true) === "boolean"; // tento záznam nikdy nepoužívajte! // Symboly typeof Symbol () === "symbol" typeof Symbol ("foo") === "symbol" typeof Symbol.iterator === "symbol" // Nedefinovaný typof undefined === "undefined"; typeof deklarovanýButUndefinedVariable === "nedefinovaný"; typeof undeclaredVariable === "nedefinované"; // Objekty typeof (a: 1) === "objekt"; // pomocou Array.isArray alebo Object.prototype.toString.call // rozlišujte medzi bežnými objektmi a poľami typeof === "object"; typeof new Date () === "objekt"; // Čo je uvedené nižšie, vedie k chybám a problémom. Nepoužívať! typeof new Boolean (true) === "objekt"; typ nového čísla (1) === "objekt"; typeof new String ("abc") === "objekt"; // Funkcie typeof function () () === "function"; typ triedy C () === "funkcia"; typeof Math.sin === "funkcia";

nulový

// Toto je definované od narodenia JavaScript typeof null === "object";

V prvej implementácii JavaScriptu boli hodnoty reprezentované párom typu značky a hodnoty. Typ značky pre objekty bol 0. null bol reprezentovaný ako nulový ukazovateľ (0x00 na väčšine platforiem). Preto bol typ značky pre null nulový, takže návratová hodnota typeof je falošná. ()

Oprava bola navrhnutá v ECMAScript (prostredníctvom deaktivácie), ale bola odmietnutá. Výsledkom bude typeof null === "null".

Použitie nového operátora

// Všetky funkcie konštruktora vytvorené pomocou "new" budú typu "object" var str = new String ("String"); var num = nové číslo (100); typ str; // Vráti "object" typeof num; // Vráti "objekt" // Existuje však výnimka pre konštruktor funkcií var func = new Function (); typ funkcie; // Vráti "funkciu"

Regulárne výrazy

Volateľné regulárne výrazy boli v niektorých prehliadačoch neštandardným doplnkom.

Typeof / s / === "funkcia"; // Chrome 1-12 Nie je kompatibilný s ECMAScript 5.1 typeof / s / === "objekt"; // Vyhovuje Firefoxu 5+ ECMAScript 5.1

Chyby súvisiace s dočasnými mŕtvymi zónami

Pred ECMAScript 2015 bolo zaručené, že operátor typeof vráti reťazec pre akýkoľvek operand, s ktorým bol volaný. To sa zmenilo pridaním vyhlásení o zdvihu let a const s blokovaným rozsahom. Teraz, ak sú premenné deklarované pomocou let a const a v bloku deklarácie premenných je pre ne vyvolaný typeof, ale pred deklaráciou je vyvolané ReferenceError. Správanie sa líši od nedeklarovaných premenných, pre ktoré typeof vráti „nedefinované“. Premenné s rozsahom bloku sa nachádzajú v „dočasnej zóne“, ktorá trvá od začiatku bloku do vyhlásenia premennej. V tejto zóne pokus o prístup k premenným vyvoláva výnimku.

Typeof undeclaredVariable === "nedefinované"; typ newLetVariable; nech newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "ahoj"; // ReferenceError

Výnimky

Všetky aktuálne prehliadače majú neštandardný objekt document.all hostiteľa typu Undefined.

Typeof document.all === "nedefinované";

Aj keď špecifikácia umožňuje názvy vlastných typov pre neštandardné exotické objekty, vyžaduje sa, aby sa tieto názvy líšili od preddefinovaných. Situácia, v ktorej document.all nie je definovaná, by sa mala považovať za výnimočné porušenie pravidiel.

Špecifikácia

Špecifikácia	Postavenie	Komentáre (1)
Najnovší návrh ECMAScript (ECMA-262)	Návrh
ECMAScript 2015 (6. vydanie, ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
ECMAScript 5.1 (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
3. vydanie ECMAScript (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné
1. vydanie ECMAScript (ECMA-262) Definícia „Typu operátora“ v tejto špecifikácii.	Štandardné	Pôvodná definícia. Implementované v JavaScripte 1.1

Kompatibilita prehliadača

Aktualizujte údaje o kompatibilite na GitHub

	Počítače						Mobilné						Server
	Chrome	Hrana	Firefox	internet Explorer	Opera	Safari	Webview v systéme Android	Chrome pre Android	Firefox pre Android	Opera pre Android	Safari v systéme iOS	Internet Samsung	Node.js
Typ	Chrome Plná podpora 1	Hrana Plná podpora 12	Firefox Plná podpora 1	IE Plná podpora 3	Opera Plná podporaÁno	Safari Plná podporaÁno	WebView Android Plná podpora 1	Chrome Android Plná podpora 18	Firefox pre Android Plná podpora 4	Opera Android Plná podporaÁno	Safari iOS Plná podporaÁno	Internetový telefón Samsung pre Android Plná podpora 1.0	nodejs Plná podporaÁno