Javascript kontrollib muutuja tüüpi. Hankige operaatori tüüp

a = (b> 0) && (c + 1! = d); lipp =! (olek = 0);

Tabel 14.5. Loogilised operaatorid

Operaatori kirjeldus

! EI (loogiline inversioon)

&& JA (loogiline korrutamine)

|| VÕI (loogiline liitmine)

Tabel 14.6. AND- ja OR-operaatorite käivitamise tulemused

Operand 1	Operand 2

Tabel 14.7. Avalduse NOT tulemused

Hankige operaatori tüüp

Hankige tüübioperaator typeof tagastab stringi, mis kirjeldab operandi andmetüüpi. Operand, mille tüüpi soovite teada, on selle operaatori järel ja suletud sulgudesse:

s = typeof ("str");

Selle avaldise tulemusel sisaldab muutuja s muutumat stringi "string", mis tähistab stringi tüüpi.

Kõik väärtused, mille operaatori typeof saab tagastada, on loetletud tabelis. 14.8.

	Tabel 14.8. Operaatori tüübi tagastatud väärtused

Andmetüüp		Tagastatud string

String

Numbriline



		Tabel 14.8 (lõpp)

Andmetüüp	Tagastatud string

Loogiline

Andmetüüpide ühilduvus ja teisendamine

Nüüd on aeg kaaluda veel kahte olulist küsimust: andmetüüpide ühilduvus ja teisendamine ühelt tüübilt teisele.

Mis juhtub, kui lisate kaks numbrit? Täpselt nii - veel üks arvväärtus. Ja kui lisate numbri ja stringi? Raske öelda ... Siin seisab JavaScript silmitsi andmetüüpide kokkusobimatuse probleemiga ja püüab neid tüüpe ühildada, teisendades ühe neist teiseks. Kõigepealt proovib see stringi teisendada numbriks ja kui see õnnestub, täidab see lisamise. Kui see ei õnnestu, teisendatakse number stringiks ja kaks saadud stringi liidetakse. Näiteks veebiskripti käivitamine loendis 14.6 teisendab b väärtuse numbriliseks, kui see lisatakse a-le; seega sisaldab muutuja c väärtust 23.

Nimekiri 14.6

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

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

d = "JavaScript"; e = 2;

Kuna muutuja d väärtust ei saa arvuks teisendada, teisendatakse e väärtus stringiks ja tulemus - f väärtus muutub

Boole'i väärtused teisendatakse vastavalt kas arv- või stringiväärtusteks. Tõene teisendatakse numbriks 1 või stringiks "1" ja vale teisendatakse väärtuseks 0 või "0". Seevastu arv 1 teisendatakse tõeseks ja arv 0 vääraks. Samuti teisendatakse vale

väärtused on null ja määratlemata.

	III osa. Veebilehtede käitumine. Veebiskriptid

On näha, et JavaScript üritab isegi valesti kirjutatud väljendeid õigesti käivitada. Mõnikord see toimib, kuid sagedamini ei toimi kõik plaanipäraselt ning lõpuks katkestatakse veebiskripti täitmine vea avastamise tõttu täiesti teises kohas, absoluutselt õiges operaatoris. Seetõttu on parem selliseid juhtumeid mitte lubada.

Operaatori prioriteet

Viimane küsimus, mida siin vaatame, on operaatori prioriteet. Nagu me meenutame, mõjutab ülimuslikkus avaldises olevate lausete täitmise järjekorda.

Olgu järgmine väljend:

Sel juhul lisatakse kõigepealt muutuja b väärtusele c väärtus ja seejärel lahutatakse summast 10. Selle avaldise operaatoritel on sama prioriteet ja seetõttu täidetakse neid rangelt vasakult paremale.

Nüüd kaaluge sellist väljendit:

Siin korrutatakse kõigepealt c väärtus 10-ga ja alles seejärel lisatakse saadud b väärtus b. Korrutamisoperaator on liitmisoperaatori ees ülimuslik, seega rikutakse ranget vasakult paremale järjestamist.

Kõige madalam on ülekandeoperaatorite tähtsus. Seetõttu hinnatakse kõigepealt väljendit ennast ja seejärel määratakse selle tulemus muutujale.

IN Üldiselt on kõigi operaatorite täitmise põhimõte järgmine: kõigepealt täidetakse suurema prioriteediga operaatorid ja alles siis madalama prioriteediga operaatorid. Sama prioriteediga operaatorid täidetakse kuvatavas järjekorras (vasakult paremale).

IN vaheleht. 14.9 loetleb kõik operaatorid, keda uurisime, prioriteedi kahanevas järjekorras.

		Tabel 14.9. Operaatori ülimuslikkus (kahanev järjestus)

	Operaatorid	Kirjeldus

	++ - - ~! tüüp	Kasv, kahanemine, märgimuutus, loogiline EI, tüübi järeldus

		Korrutamine, jagamine, ülejäänu võtmine

		Stringide liitmine ja liitmine, lahutamine


		Võrdlusoperaatorid
		Võrdlusoperaatorid


		Loogiline JA

Peatükk 14. Sissejuhatus veebiprogrammeerimisse. JavaScripti keel

		Tabel 14.9 (lõpp)

Operaatorid	Kirjeldus

	Loogiline VÕI

	Tingimuslik operaator (vt allpool)

= <оператор>=	Ülesanne, lihtne ja keeruline

TÄHELEPANU!

Pidage seda tabelit meeles. Vale lause täitmise korraldus võib põhjustada raskesti tuvastatavaid vigu, mille puhul pealtnäha täiesti õige avaldis annab vale tulemuse.

Aga mis siis, kui peame avalduste tavapärase täitmise korra rikkuma? Kasutame sulge. Selle tähisega täidetakse kõigepealt sulgudes olevad avaldused:

a = (b + c) * 10;

Siin viiakse kõigepealt läbi muutujate b ja c väärtuste liitmine ning seejärel korrutatakse saadud summa 10-ga.

Samuti on ülimuslikud sulgudesse suletud operaatorid. Seetõttu kasutatakse sageli mitut sisestatud sulu:

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

Siin täidetakse avaldused järgmises järjestuses:

1. Liit b ja c.

2. Korrutage saadud summa 10-ga.

3. Lahutades tootest d.

4. Jagades erinevuse 2-ga.

5. Lisage jagatisele 9.

Sulgude eemaldamisel toimige järgmiselt.

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

siis on operaatorite täitmise järjekord järgmine:

1. c ja 10 korrutamine.

2. d jagamine 2-ga.

3. Liit b ning tooted c ja 10.

4. Saadud summast jagamise jagatis lahutatakse d 2 võrra.

5. Saadud erinevuse lisamine 9.

Tulemus on ju hoopis teine?

Määratlemata: "määratlemata"
Null: "objekt"
Boolean: "boolean"
Number: "number"
String: "string"
Funktsioon: "funktsioon"
Kõik muu: "objekt"

Sellele tabelile tuleks lisada järgmised märkused:

1. nulltüüp === "objekt".

Teoreetiliselt on see peen mõte. Staatiliselt sisestatud keeltes ei pruugi objektitüübi muutuja sisaldada objekti (NULL, null, null pointer).

Praktikas on see JavaScripti jaoks ebamugav. Nii et ES 5.1 arendajad teevad intuitiivsema asja: typeof null === "null".

Kuid kuna meil on seni ES3, siis ärge tehke näiteks järgmist:

/ * Funktsioon otsib mõnda objekti ja tagastab selle või nulli, kui midagi ei leita * / function search () () var obj = search (); if (typeof obj === "objekt") (// kas leidsime objekti tegelikult (FAIL) obj.method ();)

2. Ärge unustage ümbrisobjekte (typeof new Number (5) === "object").

3. Ja ärge unustage brauserite õigust host-objektidega midagi teha.

Ärge imestage, et Safari arvab visalt, et HTMLCollection on funktsioonitüüp ja IE enne versiooni 9 hoidis meie lemmik alarm () funktsiooni objektina. Ka Chrome arvas varem, et RegExp on funktsioon, kuid nüüd näib ta seda objektiga tajunud ja sellele reageerinud.

toString ()

Väärtuse tüübi proovimine selle toString () meetodi tulemuse põhjal on mõttetu. Kõigis "klassides" määratletakse see meetod uuesti omaette.

Meetod sobib silumisteabe kuvamiseks, kuid muutuja tüüpi ei saa sellega määrata.

Object.prototype.toString ()

Kuigi toString määratletakse konkreetsetes "klassides" uuesti, on selle algne juurutamine siiski objektilt. Proovime seda kasutada:

console.log (Object .prototype .toString .call (väärtus));

konsool.log (Object.prototype.toString.call (väärtus));

Clinton lahjendab seda koormat

Irooniline, et see meetod töötab üllatavalt hästi.

Skalaartüüpide korral tagastab ,,,.

Naljakas on see, et isegi uus arv (5), mille tüüp tüüp siin ebaõnnestus, naaseb.

Meetod nurjub nullil ja määratlemata. Erinevad brauserid naasevad, mõnikord oodatakse ja mõnikord ka üldiselt. Kuid ilma nendeta on lihtne kindlaks määrata nende kahe väärtuse tüüp.

Lõbu algab siis, kui jõuame objektide juurde (need, kellel on typeof === "objekt").

sisseehitatud objektid töötavad praktiliselt pauguga:

{} —
—
Kuupäev -
Viga -
RegExp -

Argumentide loendist jääb välja ainult see, et siis.
Peremeesobjektidega läheb asi jälle hullemaks.

IE-s hakkasid DOM-i objektid muutuma "normaalseteks" objektideks alles alates 8. versioonist ja siis mitte päris lõpuni. Seetõttu teisendatakse IE 6-8-s kõik need objektid (HTMLCOllection, DOMElement, TextNode ning koos dokumendi ja aknaga) lihtsalt.

Kõigis teistes brauserites (sh IE9) saate toStringi tulemusega juba midagi teha. Kuigi kõik pole ka lihtne: HTMLCollection on olemas. aken - siis, siis, siis. Kuid võite juba proovida sellest midagi saada.

DOMElementiga on keerulisem: seda kuvatakse kujul - iga sildi jaoks oma vorming. Kuid siin aitab meid tavahooaeg.

Lugu on umbes sama teiste hostobjektidega (asukoha ja navigaatori testides). Kõikjal, välja arvatud IE, saab neid tuvastada nende stringi järgi.

Object.prototype.toString () kasutamise miinustest:

1. See võimalus ei ole pühitsetud standardiga. Ja siin peaksime pigem rõõmustama, et kõik töötab nii hästi, ja mitte hädaldama mõne puuduse pärast.

2. Tüübi määramine tagastatava stringi parsimise abil meetodi abil, mis ei ole üldse tüübi määramiseks ja mida kutsutakse ka objektile, kuhu see ei kuulu, jätab hingele mõned jäägid.

3. Vana IE-s, nagu näete, hostobjekte tavaliselt ei tuvastata.

Kuid see on üsna tööriist, kui seda kasutatakse koos teiste tööriistadega.

Konstruktorid

Ja lõpuks, konstruktorid. Kes oleks parem öelda JS-is oleva objekti "klassi" kohta, kui mitte selle konstruktor?

Nullil ja määratlemata pole pakendobjekte ega konstruktoreid.

Ülejäänud skalaartüüpidel on vastavalt ümbrised, saate hankida konstruktori:

(5) .konstruktor === arv; (Arv .NaN) .konstruktor === arv; (tõene) .konstruktor === Boolean; ("string") .konstruktor === String;

(5) .konstruktor === arv; (Arv.NaN) .konstruktor === arv; (tõene) .konstruktor === Boolean; ("string"). konstruktor === String;

Kuid instanceof ei tööta siin:

5 eksemplari Number; // valenumber .NaN arvu eksemplar; // Boole'i väär tõene eksemplar; // vale "string" Stringi eksemplar; // vale

5 eksemplari Number; // valenumber.NaN arvu eksemplar; // Boole'i väär tõene eksemplar; // vale "string" Stringi eksemplar; // vale

(instanceof töötab kaua kannatanud uue numbri (5) jaoks)

Funktsioonidega (mis on ka objektid) möödub instanceof:

console.log ((function () ()) Function-i eksemplar); // true console.log ((function () ()) .constructor === Funktsioon); // tõsi

console.log ((function () ()) Function-i eksemplar); // true console.log ((function () ()). konstruktor === Funktsioon); // tõsi

Kõik sisseehitatud klasside objektid on nende konstruktorite poolt ka hõlpsasti tuvastatavad: Massiiv, Kuupäev, RegExp, Viga.

Üks probleem tekib siin argumentidega, mille konstruktor on Object.

Ja teine objekti enda või õigemini selle kohta, kuidas sellele kohandatud konstruktori kaudu loodud objekti viidata.

Ainult põhiobjekti saab määratleda nii:

obj instanceof Object;

Ühe määratlusvariandina - kõigi teiste võimalike tüüpide (massiiv, tõrge ...) kordamiseks ja kui ükski neist ei sobi - "objekt".

Konstruktorid ja hostobjektid

Peremeesobjektidega läheb asi hullemaks.

Alustame sellest, et IE kuni versioon 7 (kaasa arvatud) ei pea neid üldse tavalisteks objektideks. Neil pole seal lihtsalt konstruktoreid ja prototüüpe (igal juhul ei saa programmeerija nendeni jõuda).

Teistel brauseritel läheb paremini. Konstruktoreid on ja nende abil saate väärtusklassi määrata. Ainult neid nimetatakse erinevates brauserites erinevalt. Näiteks HTMLCollectioni jaoks on konstruktoriks kas HTMLCollection või NodeList või isegi NodeListConstructor.

Samuti peaksite määrama DOMElementi baaskonstruktori. FF-is on see näiteks HTMLElement, kust HTMLDivElement ja teised on juba päritud.

FireFox allpool 10. versiooni ja Opera all 11. Kollektsiooni konstruktor on olemas - Object.

konstruktor.nimi

Ehitajatel on ka nimiomadus, mis võib olla kasulik.

See sisaldab konstruktori funktsiooni nime, näiteks (5) .constructor.name === "Number".

Aga:
1. IE-s pole see üldse, isegi 9. kohal.
2. Brauserid kujundavad jälle kõik hostobjektideks (ja sageli pole neil seda omadust üldse). Ooperis on DOMElementil konstruktori nimi üldiselt Function.prototype.
3. argumendid on jällegi "objekt".

järeldused

Ükski esitatud meetoditest ei määra kõigis brauserites sajaprotsendiliselt väärtuse tüüpi / klassi. Kuid kokkuvõttes võimaldavad need teil seda teha.

Lähitulevikus püüan koguda kõik andmed tabelitesse ja tuua näide määratlevast funktsioonist.

JavaScripti või Js(lühendatud) ei ole lihtne keel ja algajad arendajad ei saa sellest kohe teada. Alguses õpivad nad põhitõdesid ja kõik tundub värvikas ja ilus. Veidi sügavamale minnes ilmuvad JavaScripti massiivid, objektid, tagasihelistused jms, mille aju sageli välja võtab.

JavaScripti puhul on oluline muutuja tüüp õigesti kontrollida. Oletame, et soovite teada, kas muutuja on massiiv või objekt? Kuidas seda õigesti kontrollida? Sel konkreetsel juhul on kontrolli käigus trikke ja sellest see sissekanne räägibki. Alustame kohe.

Muutuja tüübi kontrollimine

Näiteks peate kontrollima, kas muutuja on objekt, massiiv, string või number. Selleks võite kasutada typeof-i, kuid see ei anna teile alati tõde ja allpool toodud näites näitan, miks.

Kirjutasin selle näite, et illustreerida, miks typeof pole alati õige valik.

Var _comparison = (string: "string", int: 99, float: 13.555, objekt: (tere: "tere"), array: uus massiiv (1, 2, 3)); // Tagastab massiivi objekti võtmetega var _objKeys = Object.keys (_comparison); jaoks (var i = 0; i<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Koodi täitmise tulemus:

Stringi number number objekti objekt

Eks? - Muidugi mitte. On kaks probleemi. Kõiki neist kirjeldatakse üksikasjalikult ja pakutakse välja lahendus.

Esimene probleem: ujukinumber, väljund arvuna

Comparison.float ei ole number ja see peaks olema numbri asemel ujuk. Selle parandamiseks saate luua valideerimisega funktsiooni nagu allpool toodud koodis.

Var _floatNumber = 9,22; var _notFloatNumber = 9; console.log (isFloat (_floatNumber)); console.log (isFloat (_notFloatNumber)); console.log (isFloat ("")); funktsioon isFloat (n) (return Number (n) === n && n% 1! == 0;)

Funktsioon isFloat () kontrollib kõiki väärtusi ujukomaarvude osas. Esiteks kontrollib see, kas muutuja on võrdne väärtusega n number (arv (n) === n) ja kui jah, siis tehakse veel üks jagamise kontroll ülejäänuga ja kui on järelejäänud osa, siis logiarv ( tõsi või vale) tulemus (n% 1! == 0).

Ülaltoodud näites naaseb tõsi, vale ja vale... Esimene tähendus on ujuk tüüp, teine ei ole - see on tavaline number ja viimane on lihtsalt tühi string, mis ei vasta reeglitele.

Teine probleem: massiiv määrati objektina

Kõige esimeses näites kuvati massiiv objektina ja see pole eriti hea, sest mõnikord peate kasutama just seda tüüpi ja mitte midagi muud.

Massiivi tüübi muutuja testimiseks on mitu võimalust.

Esimene võimalus (hea variant). Kontrollime, kas andmed kuuluvad massiivi, kasutades instanceof ().

Var data = uus massiiv ("tere", "maailm"); var isArr = massiivi andmete eksemplar;

Teine võimalus (hea variant). Meetod Array.isArray () tagastab tõeväärtuse, mis sõltub sellest, kas muutuja on massiiv või mitte ().

Var andmed = uus massiiv ("tere", "maailm"); var isArr = Array.isArray (andmed);

Kolmas variant (parim, kuid pikim). Mugavuse huvides saate selle muuta funktsiooniks. Objekti kasutades teeme. Kui objekti Object.prototype.toString.call (andmed) tulemus ei ole võrdne, pole muutuja massiiv ().

Var data = uus massiiv ("tere", "maailm"); var isArr = Object.prototype.toString.call (andmed) == ""; konsool.log (isArr);

Viimane tulemus mugavusfunktsioonina:

Funktsioon isArray (andmed) (tagastab Object.prototype.toString.call (andmed) == "")

Nüüd saate kutsuda funktsiooni isArray () ja seada argumendiks massiivi või midagi muud ja näha tulemust.

Järelsõna

Salvestus osutus üsna mahukaks, kui see algselt mõeldud oli. Kuid olen sellega rahul, sest see kirjeldab lühidalt ja selgelt JavaScripti muutujate kontrollimisega seotud raskusi ja kuidas neist mööda saada.

Kui teil on veel küsimusi, kirjutage need selle kirje alla. Aitan meeleldi.

Operaator tüüp tagastab stringi, mis näitab operandi tüüpi.

Süntaks

Operand järgib operaatori tüüpi:

Tüüp operand

Parameetrid

operand on avaldis, mis tähistab objekti või ürgset, mille tüüp tuleb tagastada.

Kirjeldus

Järgmises tabelis on loetletud typeofi võimalikud tagastusväärtused. Lisateave tüüpide ja primitiivide kohta on lehel.

Näited

// Numbrite tüüp 37 === "number"; typeof 3,14 === "arv"; typeof (42) === "arv"; Mathof.LN2 === "arv" tüüp; lõpmatuse tüüp === "arv"; NaN tüüp === "arv"; // kuigi see on "Not-A-Number" tüüpi number (1) === "number"; // ära kunagi seda sissekannet kasuta! // Stringide tüüp "" === "string"; "bla" tüüp === "string"; "1" === "stringi" tüüp; // pange tähele, et stringi sees olev number on ikka tüüpi string typeof (typeof 1) === "string"; // typeof tagastab alati stringi, sellisel juhul typeof String ("abc") === "string"; // ära kunagi seda sissekannet kasuta! // Booleans typeof true === "boolean"; typeof false === "tõeväärtus"; tõeväärtuse tüüp (true) === "tõeväärtus"; // ära kunagi seda sissekannet kasuta! // Sümbolid typeof Symbol () === "sümbol" typeof Sümbol ("foo") === "sümbol" typeof Symbol.iterator === "sümbol" // Määratlematu typeof undefined === "undefined"; typeof deklareeritudButUndefinedVariable === "määratlemata"; typeof undeclaredVariable === "määratlemata"; // Objektide tüüp (a: 1) === "objekt"; // kasutage Array.isArray või Object.prototype.toString.call // tavaliste objektide ja massiivide eristamiseks typeof === "object"; type of new Date () === "objekt"; // Allpool olev toob kaasa vigu ja probleeme. Ära kasuta! type of new Boolean (true) === "objekt"; uue numbri tüüp (1) === "objekt"; typeof new String ("abc") === "objekt"; // Funktsioonid typeof function () () === "function"; klassi C tüüp () === "funktsioon"; typeof Math.sin === "funktsioon";

null

// Seda on defineeritud alates sünnist JavaScripti tüüp null === "objekt";

Esimeses JavaScripti juurutamises olid väärtused esindatud sildi tüübi ja väärtuste paariga. Objektide märgendi tüüp oli 0. null tähistati nullkursorina (0x00 enamikul platvormidel). Seega nulli sildi tüüp oli null, seega on typeofi tagastusväärtus vale. ()

ECMAScriptis soovitati parandust (blokeerimise kaudu), kuid see lükati tagasi. Selle tulemuseks oleks typeof null === "null".

Uue operaatori kasutamine

// Kõik "new" -ga loodud konstruktori funktsioonid on tüüpi "objekt" var str = new String ("String"); var num = uus arv (100); strofi tüüp; // Annab vastuseks "objekti" tüübi number; // Annab vastuseks "objekti" // Kuid funktsiooni konstruktoril on erand var func = new Function (); funktsiooni tüüp; // Tagastab funktsiooni

Regulaaravaldised

Helistatavad regulaaravaldised olid mõnes brauseris mittestandardne lisand.

Typeof / s / === "funktsioon"; // Chrome 1-12 Ei ühildu ECMAScript 5.1-ga typeof / s / === "object"; // Firefox 5+ ECMAScript 5.1 ühilduv

Ajutiste surnud tsoonidega seotud vead

Enne ECMAScript 2015 tagati operaatori tüübile stringi tagastamine mis tahes operandi jaoks, millega seda kutsuti. See muutus, lisades plokk-ulatusega mitte-tõstetavad let- ja const-deklaratsioonid. Kui nüüd deklareeritakse muutujad let ja const abil ning muutuja deklaratsiooniplokis kutsutakse neile typeof, kuid enne deklaratsiooni, siis visatakse ReferenceError. Käitumine erineb deklareerimata muutujatest, mille tüüp typeof tagastab "määratlemata". Blokeeritud ulatusega muutujad asuvad "ajutises surnud tsoonis", mis kestab ploki algusest kuni muutuja deklareerimiseni. Selles tsoonis loob muutujatele juurdepääsu katse erandi.

Deklareerimata muutuja tüüp === "määratlemata"; typeof newLetVariable; lase uusLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "tere"; // ReferenceError

Erandid

Kõigil praegustel brauseritel on mittestandardne document.all hostobjekt tüüpi Defineerimata.

Dokumendi tüüp.all === "määratlemata";

Ehkki spetsifikatsioon lubab mittestandardsete eksootiliste objektide kohandatud tüübinimesid, on nõutav, et need nimed erinevad eelnevalt määratletud nimedest. Olukorda, kus document.all on määratlemata, tuleks pidada reeglite erakorraliseks rikkumiseks.

Spetsifikatsioonid (redigeeri)

Spetsifikatsioon	Staatus	Kommentaarid (1)
ECMAScript uusim mustand (ECMA-262)	Mustand
ECMAScript 2015 (6. väljaanne, ECMA-262) Selles spetsifikatsioonis "Operaatori tüübi" määratlus.	Standard
ECMAScript 5.1 (ECMA-262) Selles spetsifikatsioonis "Operaatori tüübi" määratlus.	Standard
ECMAScript 3. väljaanne (ECMA-262) Selles spetsifikatsioonis "Operaatori tüübi" määratlus.	Standard
ECMAScript 1. väljaanne (ECMA-262) Selles spetsifikatsioonis "Operaatori tüübi" määratlus.	Standard	Algne määratlus. Rakendatud JavaScripti 1.1

Brauseri ühilduvus

GitHubi ühilduvusandmete värskendamine

	Arvutid						Mobiilne						Server
	Chrome	Edge	Firefox	Internet Explorer	Ooper	Safari	Androidi veebivaade	Chrome Androidile	Firefox Androidile	Opera Androidile	Safari iOS-is	Samsungi Internet	Node.js
tüüp	Chrome Täielik tugi 1	Edge Täielik tugi 12	Firefox Täielik tugi 1	IE Täielik tugi 3	Ooper Täielik tugi Jah	Safari Täielik tugi Jah	Veebivaatega Android Täielik tugi 1	Chrome Android Täielik tugi 18	Firefox Android Täielik tugi 4	Opera Android Täielik tugi Jah	Safari iOS Täielik tugi Jah	Samsung Internet Android Täielik tugi 1.0	nodejs Täielik tugi Jah