Javascript kontroluje typ proměnné. Získejte typ operátora

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

Tabulka 14.5. Logické operátory

Popis operátora

! NE (logická inverze)

&& AND (logické násobení)

|| NEBO (logické sčítání)

Tabulka 14.6. Výsledky provádění operátorů AND a OR

Operand 1	Operand 2

Tabulka 14.7. Výsledky prohlášení NOT

Získejte typ operátora

Získejte operátor typu typeof vrací řetězec popisující datový typ operandu. Operand, jehož typ chcete znát, je umístěn za tímto operátorem a je uzavřen v závorkách:

s = typeof ("str");

V důsledku tohoto výrazu bude proměnná s obsahovat řetězec „řetězec“ označující typ řetězce.

Všechny hodnoty, které může operátor typeof vrátit, jsou uvedeny v tabulce. 14.8.

	Tabulka 14.8. Hodnoty vrácené operátorem typeof

Datový typ		Vrácený řetězec

Tětiva

Numerické



		Tabulka 14.8 (konec)

Datový typ	Vrácený řetězec

Logický

Kompatibilita a převod datových typů

Nyní je načase zvážit další dva důležité problémy: kompatibilitu datových typů a převod z jednoho typu na druhý.

Co se stane, když sečtete dvě čísla dohromady? Správně - ještě jedna číselná hodnota. A pokud přidáte číslo a řetězec? Těžko říct ... Zde se JavaScript potýká s problémem nekompatibility datových typů a snaží se tyto typy zkombinovat převedením jednoho z nich na jiný. Nejprve se pokusí převést řetězec na číslo, a pokud se to podaří, provede přidání. V případě neúspěchu bude číslo převedeno na řetězec a dva výsledné řetězce budou zřetězeny. Například spuštění webového skriptu v seznamu 14.6 převede hodnotu b na číselný typ při přidání do a; proměnná c tedy bude obsahovat hodnotu 23.

Výpis 14.6

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

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

d = "JavaScript"; e = 2;

Ale protože hodnotu proměnné d nelze převést na číslo, hodnota e bude převedena na řetězec a výsledek - hodnota f - se stane

Logické hodnoty jsou podle potřeby převedeny na číselné nebo řetězcové hodnoty. True bude převedeno na číslo 1 nebo řetězec „1“ a false bude převedeno na 0 nebo „0“. Naopak číslo 1 bude převedeno na true a číslo 0 bude převedeno na false. Rovněž bude převedeno false

hodnoty jsou null a nedefinovány.

	Část III. Chování webových stránek. Webové skripty

Je vidět, že JavaScript má potíže se správným provedením i nesprávně napsaných výrazů. Někdy to funguje, ale častěji vše nefunguje podle plánu a nakonec se spuštění webového skriptu přeruší kvůli zjištění chyby na úplně jiném místě, na naprosto správném operátorovi. Proto je lepší se podobným incidentům vyhnout.

Priorita operátora

Poslední problém, na který se zde podíváme, je přednost operátora. Jak si pamatujeme, priorita ovlivňuje pořadí, ve kterém jsou prováděny příkazy ve výrazu.

Nechť je následující výraz:

V tomto případě se nejprve k hodnotě proměnné b přičte hodnota c a poté se ze součtu odečte 10. Operátory tohoto výrazu mají stejnou prioritu, a proto se provádějí striktně zleva doprava.

Nyní zvažte následující výraz:

Zde se nejprve hodnota c vynásobí 10 a teprve potom se k výslednému produktu přičte hodnota b. Operátor násobení má přednost před operátorem sčítání, takže přísné objednávání zleva doprava bude mimo provoz.

Operátoři přiřazení mají nejnižší prioritu. Proto je nejprve vyhodnocen samotný výraz a poté je jeho výsledek přiřazen proměnné.

PROTI Obecně platí, že základní princip provedení všech operátorů je následující: nejprve se spustí operátoři s vyšší prioritou a teprve poté operátoři s nižší prioritou. Operátory se stejnou prioritou jsou prováděny v pořadí, v jakém se zobrazují (zleva doprava).

PROTI tab. 14.9 uvádí všechny operátory, které jsme studovali, v sestupném pořadí podle jejich priority.

		Tabulka 14.9. Priorita operátora (sestupně)

	Operátoři	Popis

	++ - - ~! Typ	Přírůstek, úbytek, změna znaménka, logické NE, odvození typu

		Násobení, dělení, přičemž zbytek

		Sčítání a zřetězení řetězců, odčítání


		Operátory porovnání
		Operátory porovnání


		Logické AND

Kapitola 14. Úvod do webového programování. Jazyk JavaScript

		Tabulka 14.9 (konec)

Operátoři	Popis

	Logické NEBO

	Podmíněný operátor (viz níže)

= <оператор>=	Zadání, jednoduché a složité

POZORNOST!

Zapamatujte si tuto tabulku. Nesprávné pořadí provedení příkazu může vést k těžko rozpoznatelným chybám, ve kterých zdánlivě naprosto správný výraz dává špatný výsledek.

Ale co když potřebujeme porušit normální pořadí provádění příkazů? Použijme závorky. S tímto zápisem se nejprve provedou příkazy uzavřené v závorkách:

a = (b + c) * 10;

Zde se nejprve provede sčítání hodnot proměnných b a c a poté se výsledný součet vynásobí 10.

Přednost mají také operátoři uzavření v závorkách. Proto se často používá více vnořených závorek:

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

Zde budou příkazy provedeny v následujícím pořadí:

1. Sčítání b a c.

2. Výslednou částku vynásobte 10.

3. Odečtení d od produktu.

4. Vydělením rozdílu 2.

5. Přidejte 9 do kvocientu.

Pokud odstraníte závorky:

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

pak bude pořadí provedení operátorů následující:

1. Násobení c a 10.

2. Dělení d 2.

3. Přídavek b a produkty c a 10.

4. Odečtení kvocientu od dělení od výsledného součtu d do 2.

5. Přidání 9 k výslednému rozdílu.

Výsledek je úplně jiný, že?

Undefined: "undefined"
Null: "objekt"
Boolean: "boolean"
Číslo: "číslo"
Řetězec: "řetězec"
Funkce: "funkce"
Všechno ostatní: „objekt“

Do této tabulky by měly být přidány následující poznámky:

1. typeof null === "objekt".

Teoreticky je to jemný bod. Ve staticky zadaných jazycích nesmí proměnná typu objektu obsahovat objekt (NULL, nula, null pointer).

V praxi je to v JavaScriptu nepohodlné. Vývojáři ES 5.1 tedy udělají intuitivnější věc: typeof null === "null".

Ale protože zatím máme ES3, nenechte se mýlit například v tomto:

/ * Funkce vyhledá nějaký objekt a vrátí jej nebo null, pokud není nic nalezeno * / funkce search () () var obj = search (); if (typeof obj === "object") (// skutečně jsme našli objekt (FAIL) obj.method ();)

2. Nezapomeňte na objekty typu wrapper (typeof new Number (5) === "object").

3. A nezapomeňte na právo prohlížečů dělat cokoli s hostitelskými objekty.

Nenechte se překvapit, že Safari si tvrdohlavě myslí, že HTMLCollection je typ funkce, a IE před verzí 9 si jako objekt ponechal naši oblíbenou funkci alert (). Také Chrome dříve považoval RegExp za funkci, ale nyní se zdá, že to vycítil a odpověděl na to objektem.

toString ()

Pokoušet se zjistit typ hodnoty z výsledku metody toString () nemá smysl. Ve všech „třídách“ je tato metoda předefinována na vlastní.

Metoda je vhodná pro zobrazení informací o ladění, ale typ proměnné podle ní nelze určit.

Object.prototype.toString ()

Ačkoli je toString předefinován v rámci konkrétních „tříd“, stále máme jeho původní implementaci z Object. Zkusme to použít:

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

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

Clinton tuto zátěž ředí

Kupodivu tato metoda funguje překvapivě dobře.

U skalárních typů vrací ,,,.

Vtipné na tom je, že se vrací i nové číslo (5), na kterém se nezdařil typeof.

Metoda selže na null a undefined. Vracejí se různé prohlížeče, někdy očekávané a někdy obecně. Je však snadné určit typ těchto dvou hodnot bez něj.

Zábava začíná, když se dostaneme k objektům (k těm s typeof === "objekt").

vestavěné objekty fungují prakticky bez problémů:

{} —
—
Datum -
Chyba -
RegExp -

Jediná věc, která ze seznamu argumentů vypadává, je, že.
S hostitelskými objekty se věci opět zhoršují.

V IE se objekty DOM začaly stávat „normálními“ objekty až od 8. verze, a pak ne úplně do konce. V IE 6-8 jsou tedy všechny tyto objekty (HTMLCOllection, DOMElement, TextNode a spolu s dokumentem a oknem) jednoduše převedeny.

Ve všech ostatních prohlížečích (včetně IE9) už můžete s výsledkem toString něco udělat. Ačkoli vše také není snadné: HTMLCollection tedy existuje. okno - pak, pak, pak. Ale už se můžete pokusit z toho něco dostat.

S DOMElement je to obtížnější: zobrazuje se jako - vlastní formát pro každou značku. Ale tady nám pomůže pravidelná sezóna.

Příběh je přibližně stejný s jinými hostitelskými objekty (v testech umístění a navigátoru). Všude kromě IE je lze identifikovat podle řetězce.

Nevýhody používání Object.prototype.toString ():

1. Tato příležitost není posvěcena standardem. A zde bychom se měli spíše radovat, že vše funguje tak dobře, a ne lamentovat nad některými nedostatky.

2. Určení typu rozebráním řetězce vráceného metodou, která vůbec není pro určení typu a je také vyvolána na předmět, ke kterému nepatří, zanechává na duši určité zbytky.

3. Ve starém IE, jak vidíte, hostitelské objekty obvykle nejsou identifikovány.

Při použití ve spojení s jinými nástroji je to však docela funkční kus.

Konstruktéři

A nakonec konstruktéři. Kdo lepší by měl říci o „třídě“ objektu v JS, když ne o jeho konstruktoru?

Null a undefined nemají ani wrapper objekty, ani konstruktory.

Zbytek skalárních typů má obálky, respektive můžete získat konstruktor:

(5) .constructor === Číslo; (Number .NaN) .constructor === Number; (true) .constructor === Boolean; ("řetězec") .constructor === Řetězec;

(5) .constructor === Číslo; (Number.NaN) .constructor === Number; (true) .constructor === Boolean; ("řetězec"). konstruktor === Řetězec;

Ale instanceof zde nebude fungovat:

5 instanceof Number; // false Number .NaN instanceof Number; // false true instance of Boolean; // false "string" instanceof String; // Nepravdivé

5 instanceof Number; // false Number.NaN instanceof Number; // false true instance of Boolean; // false "string" instanceof String; // Nepravdivé

(instanceof bude fungovat pro trpělivé nové číslo (5))

S funkcemi (což jsou také objekty) projde instanceof:

console.log ((function () ()) instanceof funkce); // true console.log ((function () ()) .constructor === Funkce); // skutečný

console.log ((function () ()) instanceof funkce); // true console.log ((function () ()). constructor === Funkce); // skutečný

Všechny objekty vestavěných tříd jsou také snadno identifikovány jejich konstruktory: Array, Date, RegExp, Error.

Zde vzniká jeden problém s argumenty, jejichž konstruktorem je Object.

A druhý se samotným Object, respektive jak na něj odkazovat objekt vytvořený pomocí vlastního konstruktoru.

Tímto způsobem lze definovat pouze základní objekt:

obj instanceof Object;

Jako jedna z variant definice - iterovat všechny ostatní možné typy (pole, chyba ...) a pokud žádná neodpovídá - „objekt“.

Konstruktory a hostitelské objekty

S hostitelskými objekty se věci zhoršují.

Začněme tím, že IE až do 7. verze je vůbec nepovažuje za normální objekty. Jednoduše tam nemají konstruktory a prototypy (každopádně na ně programátor nedosáhne).

Jiné prohlížeče jsou na tom lépe. Existují konstruktory a můžete je použít k určení třídy hodnot. Pouze se v různých prohlížečích nazývají odlišně. Například pro HTMLCollection bude konstruktor buď HTMLCollection nebo NodeList, nebo dokonce NodeListConstructor.

Měli byste také definovat základní konstruktor pro DOMElement. Ve FF je to například HTMLElement, ze kterého jsou již zděděny HTMLDivElement a další.

FireFox pod verzí 10 a Opera pod verzí 11 vyvolávají žert. Konstruktorem kolekce je Object.

jméno konstruktora

Konstruktory mají také vlastnost name, která může být užitečná.

Obsahuje název funkce konstruktoru, například (5) .constructor.name === "Číslo".

Ale:
1. V IE vůbec neexistuje, dokonce ani v 9.
2. Prohlížeče opět vše vytvarují do Host-objektů (a často tuto vlastnost vůbec nemají). V Opeře má DOMElement obecný název konstruktoru Function.prototype.
3. argumenty je opět „objekt“.

závěry

Žádná z uvedených metod neposkytuje stoprocentní definici typu / třídy hodnoty ve všech prohlížečích. Společně vám to však umožňují.

V blízké budoucnosti se pokusím shromáždit všechna data do tabulek a uvést příklad definující funkce.

JavaScript nebo Js(zkráceně) není snadný jazyk a začínající vývojáři se o něm hned nedozvědí. Zpočátku se učí základům a vše vypadá barevně a krásně. Když půjdeme trochu hlouběji, objeví se pole JavaScript, objekty, zpětná volání a podobně, které mozek často vyjme.

V JavaScriptu je důležité správně zkontrolovat typ proměnné. Řekněme, že chcete vědět, zda je proměnná pole nebo objekt? Jak to správně zkontrolovat? V tomto konkrétním případě existují při kontrole triky a o tom bude tento záznam. Začněme hned.

Kontrola typu proměnné

Například musíte zkontrolovat, zda je proměnná objekt, pole, řetězec nebo číslo. K tomu můžete použít typeof, ale ne vždy to dá pravdu a v níže uvedeném příkladu ukážu proč.

Napsal jsem tento příklad, abych ilustroval, proč typeof není vždy tou správnou volbou.

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

Výsledek spuštění kódu:

Objekt objektu číslo řetězce číslo

Že jo? - Samozřejmě že ne. Existují dva problémy. Každý z nich bude podrobně popsán a bude navrženo řešení.

První problém: float number, výstup jako číslo

Comparison.float není číslo a místo čísla by měl být float. Chcete -li to opravit, můžete vytvořit funkci s ověřením jako v níže uvedeném kódu.

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

Funkce isFloat () kontroluje u všech hodnot čísla s plovoucí desetinnou čárkou. Nejprve zkontroluje, zda je proměnná rovná n number (Number (n) === n) a pokud ano, provede se další kontrola rozdělení se zbytkem, a pokud existuje zbytek, pak logická hodnota ( skutečný nebo Nepravdivé) výsledek (n% 1! == 0).

Ve výše uvedeném příkladu se vrátí skutečný, Nepravdivé a Nepravdivé... První význam je plovák typ, druhý není - toto je obyčejné číslo a poslední je jen prázdný řetězec, který neodpovídá pravidlům.

Druhý problém: pole bylo definováno jako objekt

V úplně prvním příkladu bylo pole zobrazeno jako objekt a to není moc dobré, protože někdy potřebujete použít právě tento typ a nic jiného.

Existuje několik způsobů, jak testovat proměnnou pro typ pole.

První možnost (dobrá volba). Zkontrolujeme, zda data patří do pole pomocí instanceof ().

Var data = nové pole („ahoj“, „svět“); var isArr = datová instance pole;

Druhá možnost (dobrá volba). Metoda Array.isArray () vrací logickou hodnotu, která bude záviset na tom, zda je proměnná pole nebo ne ().

Var data = nové pole („ahoj“, „svět“); var isArr = Array.isArray (data);

Třetí možnost (nejlepší, ale nejdelší). Pro pohodlí můžete z této funkce udělat funkci. Používáme Object. Pokud výsledek Object.prototype.toString.call (data) není stejný, pak proměnná není pole ().

Var data = nové pole („ahoj“, „svět“); var isArr = Object.prototype.toString.call (data) == ""; console.log (isArr);

Poslední výsledek jako praktická funkce:

Funkce isArray (data) (návrat Object.prototype.toString.call (data) == "")

Nyní můžete zavolat funkci isArray () a jako argument nastavit pole nebo něco jiného a uvidíte výsledek.

Doslov

Záznam se ukázal být poměrně velký, než byl původně zamýšlen. Ale jsem s ním spokojený, protože stručně a jasně popisuje potíže při kontrole proměnných v JavaScriptu a způsob, jak je obejít.

Pokud máte ještě nějaké dotazy - napište je níže k tomuto záznamu. Rád pomůžu.

Operátor Typ vrací řetězec označující typ operandu.

Syntax

Operand následuje typ operátoru:

Typ operand

Možnosti

operand je výraz, který představuje objekt nebo primitiv, jehož typ má být vrácen.

Popis

Následující tabulka uvádí možné návratové hodnoty typeof. Další informace o typech a primitivách jsou na stránce.

Příklady

// Čísla typeof 37 === "number"; typeof 3.14 === "číslo"; typeof (42) === "číslo"; typ Math.LN2 === "číslo"; typeof Infinity === "číslo"; typ NaN === "číslo"; // přestože se jedná o typ čísla „Not-A-Number“ (1) === „číslo“; // tento záznam nikdy nepoužívejte! // Řetězce typeof "" === "string"; typeof "bla" === "string"; typeof "1" === "řetězec"; // všimněte si, že číslo uvnitř řetězce je stále typu string typeof (typeof 1) === "string"; // typeof v tomto případě vždy vrátí řetězec typeof String ("abc") === "string"; // tento záznam nikdy nepoužívejte! // Booleans typeof true === "boolean"; typeof false === "boolean"; typeof boolean (true) === "boolean"; // tento záznam nikdy nepoužívejte! // Symboly typeof Symbol () === "symbol" typeof Symbol ("foo") === "symbol" typeof Symbol.iterator === "symbol" // Nedefinovaný typof undefined === "undefined"; typeof deklarovanýButUndefinedVariable === "undefined"; typeof undeclaredVariable === "undefined"; // Objekty typeof (a: 1) === "objekt"; // použijte Array.isArray nebo Object.prototype.toString.call // k rozlišení mezi běžnými objekty a poli typeof === "objekt"; typeof new Date () === "objekt"; // To, co je níže, vede k chybám a problémům. Nepoužívat! typeof new Boolean (true) === "objekt"; typeof new Number (1) === "objekt"; typeof new String ("abc") === "objekt"; // Funkce typeof funkce () () === "funkce"; typeof třídy C () === "funkce"; typeof Math.sin === "funkce";

nula

// Toto je definováno od narození JavaScript typeof null === "object";

V první implementaci JavaScriptu byly hodnoty reprezentovány dvojicí typu typu a hodnoty. Typ tagu pro objekty byl 0. null byl reprezentován jako nulový ukazatel (0x00 na většině platforem). Typ značky pro null byl tedy nula, takže návratová hodnota typeof je falešná. ()

Oprava byla navržena v ECMAScript (přes deaktivaci), ale byla zamítnuta. To by mělo za následek typeof null === "null".

Pomocí nového operátora

// Všechny funkce konstruktoru vytvořené pomocí "new" budou typu "object" var str = new String ("String"); var num = nové číslo (100); typ str; // Vrací "objekt" typeof num; // Vrací "objekt" // Existuje ale výjimka pro konstruktor funkce var func = new Function (); typ funkce; // Vrací "funkci"

Regulární výrazy

Volatelné regulární výrazy byly v některých prohlížečích nestandardním doplňkem.

Typeof / s / === "funkce"; // Chrome 1-12 Není kompatibilní s ECMAScript 5.1 typeof / s / === "objekt"; // Vyhovuje Firefox 5+ ECMAScript 5.1

Chyby související s dočasnými mrtvými zónami

Před ECMAScript 2015 bylo zaručeno, že operátor typeof vrátí řetězec pro jakýkoli operand, se kterým byl volán. To se změnilo přidáním deklarací let a const bez zdvihu v rozsahu bloku. Nyní, pokud jsou proměnné deklarovány pomocí let and const a je pro ně v bloku deklarace proměnné vyvolán typeof, ale před deklarací je vyvolána ReferenceError. Chování se liší od nedeklarovaných proměnných, pro které typeof vrátí „undefined“. Proměnné s rozsahem bloku jsou v "dočasné mrtvé zóně", která trvá od začátku bloku do deklarace proměnné. V této zóně vyvolá pokus o přístup k proměnným výjimku.

Typeof undeclaredVariable === "undefined"; typ newLetVariable; nechte newLetVariable; // ReferenceError typeof newConstVariable; const newConstVariable = "ahoj"; // ReferenceError

Výjimky

Všechny aktuální prohlížeče mají nestandardní hostitelský objekt document.all typu Undefined.

Typeof document.all === "nedefinováno";

Ačkoli specifikace umožňuje názvy vlastních typů pro nestandardní exotické objekty, je nutné, aby se tyto názvy lišily od předdefinovaných. Situaci, kdy document.all není definována, je třeba považovat za výjimečné porušení pravidel.

Specifikace

Specifikace	Postavení	Komentáře (1)
Nejnovější návrh ECMAScript (ECMA-262)	Návrh
ECMAScript 2015 (6. vydání, ECMA-262) Definice „Typu operátora“ v této specifikaci.	Standard
ECMAScript 5.1 (ECMA-262) Definice „Typu operátora“ v této specifikaci.	Standard
3. vydání ECMAScript (ECMA-262) Definice „Typu operátora“ v této specifikaci.	Standard
1. vydání ECMAScript (ECMA-262) Definice „Typu operátora“ v této specifikaci.	Standard	Původní definice. Implementováno v JavaScriptu 1.1

Kompatibilita prohlížeče

Aktualizujte údaje o kompatibilitě na GitHubu

	Počítače						mobilní, pohybliví						Server
	Chrome	Okraj	Firefox	internet Explorer	Opera	Safari	Webové zobrazení Android	Chrome pro Android	Firefox pro Android	Opera pro Android	Safari na iOS	Internet Samsung	Node.js
Typ	Chrome Plná podpora 1	Okraj Plná podpora 12	Firefox Plná podpora 1	TJ Plná podpora 3	Opera Plná podpora Ano	Safari Plná podpora Ano	WebView Android Plná podpora 1	Chrome Android Plná podpora 18	Firefox pro Android Plná podpora 4	Opera Android Plná podpora Ano	Safari iOS Plná podpora Ano	Samsung Internet Android Plná podpora 1.0	nodejs Plná podpora Ano