Rozhodl jsem se napsat sérii článků s názvem „Složité věci o jednoduchých věcech“. Tato série bude věnována jazyku JavaScript. Proč je to „složité na jednoduchých věcech“? Protože vše, co vám řeknu, vám řeknu s ohledem na vlastnosti interpretu, počínaje datovými typy. To vše bude provedeno proto, abychom později mohli jednoduše mluvit o složitých věcech, například o metodách dědičnosti v JavaScriptu a dalších vzorech.
JavaScript je objektově orientovaný programovací jazyk s prototypovou organizací.
O tom, co znamená „s prototypovou organizací“ si povíme v příštím článku (takový určitě bude), ale dnes zjistíme, proč je „objektově orientovaný“ a zda je vše v JS objekt.
K dosažení svých cílů potřebuje JS pouze 9 typů. Programu je navíc k dispozici pouze 6 z nich, zbývající 3 jsou dostupné pouze na implementační úrovni a používá je specifikace. Na první pohled (a to je první mylná představa) je v JS vše objekt. Takže pět ze šesti typů, které má program k dispozici, jsou takzvaná primitiva a nejsou objekty (níže vysvětlím, proč a jak jsou zaměňovány s objekty). Těchto pět primitiv je:
- řetězec (s='str')
- Číslo (n=10)
- Boolean (b=true)
A to, čemu říkám „filosofické typy“:
- null (v = null)
- nedefinováno (u=nedefinováno)
Filosofické v tom smyslu null znamená, že proměnné není přiřazeno nic, a nedefinováno znamená, že proměnné je přiřazena prázdnota. Jaký je rozdíl mezi „nic“ a „prázdnotou“. v tomto případě- přemýšlejte o tom ve svém volném čase. Teď to neuděláme.
Šestý, k dispozici programu typ (objekt) je:
- Objekt (neplést s konstruktorem Object, nyní mluvíme pouze o abstraktních typech!) je jediným typem, který reprezentuje objekty v JavaScriptu.
Objekt je datová struktura (jejich celá sada), reprezentovaná jako sada párů klíč-hodnota. Hodnota může být libovolný z datových typů – pak to bude vlastnost objektu, nebo i funkce – pak to bude metoda objektu.
Existuje mnoho způsobů, jak pracovat s primitivy. Počínaje tím, že je lze přiřadit k proměnným pomocí literálů nebo pomocí konstruktorů a konče tím, že primitiva nelze do proměnných vůbec deklarovat, pracovat s nimi přímo. Primitiva mohou být také v globálních a lokálních proměnných.
Zde jsou nějaké příklady:
Var v1; //nedefinovaná (prázdná) lokální proměnná var v2="2"; //řetězec lokální proměnná literálu var v3 = new String(2); //místní řetězcová proměnná deklarovaná prostřednictvím konstruktoru. Vytvoří nový objekt typ String v4 = String(2); //string globální proměnná volaná přes konstruktor. Vytvoří proměnnou window.v4 "2".length; // řetězec se nestane proměnnou, ale může být již použit jako Object 34..toString(); //číslo se nestane proměnnou, ale může být již použito jako objekt 12. toString(); //číslo se nestane proměnnou, ale může být již použito jako objekt (22).toString();//číslo se nestane proměnnou, ale již může být použito jako objekt
V posledních 4 příkazech je jasně vidět, jak se primitivum zaměňuje s objektem – vždyť metodu voláme přes tečku – stejně jako objekt. Opravdu se zdá, že tito primitivové jsou předměty.
Mylná představa se ještě zhorší, když zkontrolujeme typ proměnné, např.
Var v = null; typeof v;
A jako odpověď dostáváme „objekt“.
A když napíšeme:
var v = null; v instanceof Object;
Pak bude ve vaší hlavě nepořádek, protože výsledek posledního řádku bude „false“. To znamená, že proměnná v je typu object, ale není zděděna z typu Object. Co to sakra?!
Nejprve mi dovolte vysvětlit úlovek pomocí typeof null. Tento operátor vrací typ objektu. Faktem ale je, že operátor typeof vrací řetězcovou hodnotu převzatou z pevně fixované tabulky, kde je napsáno: „for null – return „object“. Operátor instanceof kontroluje, zda něco patří do zadaného datového typu. Jak to dělá, vám povím v příštím článku, ale ujišťuji vás, že v tomto případě to fungovalo správně, null primitivum není v žádném případě převzato z typu Object - je to primitiv sám o sobě, nižší stupeň rozvoj.
Dobře, vytřídili jsme typeof a instanceof, ale metody se volají na primitivech – stejně jako na objektech! Co když to není předmět?
Tady je ta věc. Existuje něco jako wrapper funkce (konstruktory) (a opět vše bude jasnější v druhém článku). Existují pro všechna primitiva (Number(), Boolean(), String()), stejně jako další. Jejich podstatou je vytvořit z primitiva objekt, který bude mít pomocné metody pro práci s tímto typem primitiva.
Proměnnou lze vytvořit například takto:
Var num = new Number(23.456);
V tomto případě dostaneme objekt z primitivního 23.456.
Pro typ čísla má konstruktor Number() pomocnou metodu toPrecision() - ta určuje počet platných číslic čísla. Pokud například u čísla 23,456 nastavíme počet platných číslic na 4, dostaneme číslo 23,45.
A to je, když se snažíme přistupovat k primitivu jako k objektu:
(23,456). toPrecision(4);
Interpret dočasně zabalí primitivum do objektu voláním new Number(23.456) a poté zavolá metodu toPrecision() na tento objekt, kterou nyní má. Mnoho lidí se tedy mylně domnívá, že vše v JS je objekt.
Existuje také další příklad, který je zavádějící a způsobuje nepochopení toho, co se děje. Zde je kód:
Var str = 'str'; str.test = 'test'; //nenastane žádná chyba, program bude pokračovat v práci, ale console.log(str.test); //nedefinováno
Pokud bychom jako dříve věřili, že str je objekt, byli bychom překvapeni, proč si nepamatoval novou vlastnost test. Nyní však víme, že když se k primitivu přistupuje jako k objektu, dočasně se změní na objekt typu String. Ale po dokončení operace tento obal zmizí a spolu s ním i nová vlastnost test. To je vše, žádná magie.
Ve skutečnosti, když se podíváme dopředu, při zabalování primitiva do předmětu se vybuduje celý řetězec dědičnosti (o tom, jak je to organizováno, si povíme později), ale v podstatě to dostaneme jako „matrjošku“:
Object(Number()). Rodičem jakéhokoli objektu v JS, tak či onak, bude Object. Při volání vlastnosti v objektu prohledává hledání celou tuto „matrjošku“, dokud nenajde tuto vlastnost v jednom z objektů, nebo vrátí nedefinováno, nebo pokud hledalo metodu, vyvolá výjimku. Primitivum má tedy k dispozici také vlastnosti objektu. O tom, jak funguje prototypová dědičnost a její spletitosti, si povíme ve druhém článku.
Abych přidal trochu intrik do druhého článku, který chci vydat, řeknu vám o dalším bodu souvisejícím s funkcemi konstruktoru – převodu typu. JS není striktní zadaný jazyk. To znamená, že v době deklarace proměnné nejsme povinni uvádět, o jaký typ se jedná, a navíc za běhu programu lze do této proměnné umístit data naprosto libovolného typu. Můžeme také použít například řetězcové proměnné v matematických operacích nebo naopak čísla v operaci zřetězení. Příklad:
Var str = "abc"; str+1; // "abc1"
Zde bude primitivum typu číslo - 1 převedeno na řetězcové primitivum. V objektech je tato funkce dostupná voláním metody toString(), v objektech typu number existuje metoda valueOf(), která vrátí primitivum typu number. Ale trochu jsme řekli, že pouze objekty mohou mít metody. Takže v procesu převodu primitiva z jednoho typu na druhý je také zabaleno do objektu? Ujišťuji vás, že není. Tato metoda je volána implicitně, když je funkce konstruktoru volána interpretem bez operátoru new. Co je to za magický operátor nový a co se stane, když se funkce konstruktoru zavolá bez něj, a co je to sakra za konstruktorovou funkci, si povíme v příštím článku. Prozatím mě berte za slovo – převod typu nastane okamžitě – z primitivního na primitivní.
Zatím je samozřejmě více otázek než odpovědí, nicméně věřte, že po přečtení druhého článku bude vše mnohem jasnější. Tady mě hlavně zaujalo a vyvolalo řadu otázek – takříkajíc pohnutých myslí. Ale přesto se dá z tohoto článku něco odnést:
1. Navzdory obecnému přesvědčení „v JS je vše objekt“ – to není pravda, jsme zjistili, že ze 6 datových typů dostupných programátorovi je až 5 primitiv a pouze jeden představuje typ objektu.
2. O objektech jsme se dozvěděli, že se jedná o datovou strukturu, která obsahuje páry klíč-hodnota. Když hodnota může být libovolný z datových typů (a to bude vlastnost objektu) nebo funkce (a to bude metoda objektu).
3. Ale primitiva nejsou předměty. Sice s nimi můžete pracovat jako s objektem (a to způsobuje mylnou představu, že primitiv je objekt), ale...
4. Proměnné lze deklarovat buď jednoduše (doslova) (var a = ‚str‘) nebo pomocí funkce konstruktoru (wrapper) (var a = new String(‘str‘)). V druhém případě již nedostaneme primitiv, ale objekt vytvořený funkcí wrapper String(). (Zjistíme, jaký magický operátor je nový a jaká funkce konstruktoru je dále).
5. Zjistili jsme, že vytvořením obalu nad primitivem (new String(‘str’)) s ním můžete pracovat jako s objektem. Právě tento obal vytváří interpret kolem primitiva, když s ním zkoušíme pracovat jako s objektem, ale po provedení operace je zničen (takže si primitiv nikdy nebude schopen zapamatovat vlastnost, kterou mu přiřadíme a.test = 'test' - vlastnost test zmizí s obalem ).
6. Zjistili jsme, že objekty mají metodu toString(), která vrací řetězcovou reprezentaci objektu (pro typ čísla vrátí valueOf() číselnou hodnotu).
7. Pochopili, že při provádění operací zřetězení nebo matematických operací mohou primitiva předefinovat svůj typ na požadovaný. K tomu používají funkce wrapper svých typů, ale bez nového operátoru (str = String(str)). (Budeme mluvit dále o tom, jaký je rozdíl a jak to funguje)
8. A nakonec jsme se dozvěděli, že typeof přebírá hodnoty z pevně zafixované tabulky (odtud pochází další mylná představa založená na typeof null //object).
Proměnná je pojmenované paměťové místo, do kterého můžete jak ukládat nějaké informace, tak je z něj získávat.
Deklarace (vytváření) proměnných se provádí pomocí klíčové slovo var.
// zpráva - název proměnné var message;
Když vytvoříte proměnnou, můžete jí okamžitě přiřadit hodnotu.
Přiřazení hodnoty proměnné se provádí pomocí operátoru „=“.
// například vytvořte variabilní e-mail a přiřaďte mu řetězec " [e-mail chráněný]"var email = " [e-mail chráněný]"; // nastavte proměnnou email na novou hodnotu email = " [e-mail chráněný]";
Chcete-li získat hodnotu proměnné, jednoduše na ni odkazujte jménem.
// například vypíše hodnotu proměnné email do konzole prohlížeče: console.log(email);
Chcete-li deklarovat více než jednu proměnnou pomocí jednoho klíčového slova var, musíte použít čárku.
Var cena = 78,55, množství = 10, zpráva;
JavaScript je dynamicky nebo slabě typovaný jazyk. To znamená, že když je proměnná deklarována, nemusí specifikovat datový typ, který může přijmout. Proto můžete nejprve umístit hodnotu jednoho datového typu do proměnné a poté jinou.
Var output = "úspěch"; // proměnná má datový typ string output = 28; // stejná proměnná, ale již datového typu „číslo“ output = true; // stejná proměnná, ale již ukládá booleovskou hodnotu
Hodnotu proměnné lze měnit neomezeně mnohokrát.
// je vytvořena proměnná stáří var age; // proměnnému věku je přiřazena hodnota 67 věk = 67; // proměnný věk je nastaven na "Důchodový věk" age = "Důchodový věk"; // variabilní věk je nastaven na 55 věk = 55;
Dobrou praxí při vývoji klientských aplikací je použití pouze jednoho datového typu v dané proměnné, tzn. nezapisujte hodnoty do proměnné, která má Různé typy data. Abychom pochopili, jaký typ dat by se měl v proměnné očekávat, při vytváření proměnné se doporučuje ji okamžitě inicializovat konkrétní hodnotou.
Název proměnné se může skládat z písmen, číslic a symbolů $ a _. V tomto případě nesmí být prvním znakem proměnné číslo. Kromě toho nemůžete použít vyhrazená slova jako názvy proměnných.
// vytvoření dvou proměnných, první proměnná se jmenuje phone, druhá je zpráva; var telefon, zpráva;
Na velikosti písmen v názvu proměnné záleží. To znamená, že například proměnná telefon a telefon jsou dvě různé proměnné.
Pokud se nepoužívá přísný režim, můžete vytvořit proměnnou s počáteční hodnotou bez klíčového slova var.
Cena = 250,00; // vytvořil proměnnou a inicializoval ji číslem 250.00 procent = "20%"; // vytvořil proměnnou a inicializoval ji řetězcem „20%“
Ale vytváření proměnných tímto způsobem se nedoporučuje.
Typy datV JavaScriptu lze datové typy rozdělit na primitivní a objektové.
Proměnné obsahující primitivní datové typy ukládají svou hodnotu explicitně.
V JavaScriptu existuje 5 primitivních datových typů:
- číslo;
- tětiva;
- booleovský typ (boolean);
- nula;
- nedefinováno.
Pokud je jedné proměnné přiřazena hodnota jiné, která obsahuje primitivní datový typ, obdrží vlastní kopii této hodnoty.
Var x = 77, y = x; x = 55; y; // 77
Proměnné obsahující objekt ve skutečnosti neukládají objekt samotný, ale odkaz na něj.
Pokud je jedné proměnné přiřazena hodnota jiné, která obsahuje objekt (odkaz na něj), obdrží na něj také odkaz. V důsledku této operace budou tyto dvě proměnné obsahovat odkaz na stejný objekt.
// příklad 1 (s datovým typem "objekt") var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // nastaví vlastnost x objektu na novou hodnotu coord2.x; // 55, protože coord1 a coord2 obsahují odkaz na stejný objekt // příklad 2 (s datovým typem pole) var coord1 = , coord2 = coord1; coord1 = 55; // nastaví prvek s indexem 0 na novou hodnotu coord2; // 55, protože coord1 a coord2 obsahují odkaz na stejný objekt // příklad 3 (s datovým typem "datum") var date1 = new Date(2018,00,01), date2 = date1; datum2 = datum2.setDate(datum2.getDate()+7); // zvětšit datum o 7 dní date1; // 01.07.2018, protože datum1 a datum2 obsahují odkaz na stejný objekt
ČísloČíselný datový typ v JavaScriptu je obecný. Používá se k reprezentaci celých čísel i zlomků.
Var int = 5; // integer var float = 5,98; // zlomkové číslo
Formát pro reprezentaci čísel v JavaScriptu je v souladu se standardem IEEE 754-2008.
Celá čísla v JavaScriptu lze specifikovat nejen v desítková soustava zápisu, ale i v osmičkovém (0) popř hexadecimální soustava radix (0x) pomocí předpon uvedených v závorkách:
Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
Je možné psát čísla v exponenciálním tvaru:
Var num = 2e3; // exponenciální zápis čísla 2*10^3 (2000) num = 2e-3; // exponenciální zápis čísla 2*10^-3 (0,002) num = 3,2e3; // 3200 num = 1,5e-2; // 0,015
Kromě čísel obsahuje číselný datový typ také speciální číselné hodnoty:
- Infinity (kladné nekonečno);
- -Nekonečno (záporné nekonečno);
- NaN (není číslo).
Speciální hodnota Infinity znamená velmi velké kladné číslo, tzn. číslo, které nelze zobrazit v JavaScriptu, protože je příliš velké.
Zvláštní významy -Nekonečno znamená naopak velmi velké záporné číslo, tzn. číslo, které nemůže být reprezentováno JavaScriptem, protože je také příliš velké.
Příklad výrazů, které vrátí speciální číselné hodnoty jako výsledek jejich výpočtu:
5/0; // Nekonečno -5/0; // -Infinity Math.pow(10,399); // Nekonečno (10 na 399) Math.pow(10,399); // -Nekonečno (-10 na 399)
Hodnota NaN je vrácena jako výsledek provádění matematických operací, které JavaScript nedokáže vypočítat.
5 - "Ahoj"; // NaN (odečtěte řádek od čísla 5) 1000 / "20px"; // NaN (číslo děleno řetězcem) true * "1rem"; // NaN (logická hodnota true vynásobená řetězcem)
Co je velmi zajímavé, je, že hodnota NaN v JavaScriptu se nerovná ničemu včetně sebe sama.
NaN == NaN; // false NaN === NaN; //Nepravdivé
Booleovský typ data (logická)Boolean je primitivní datový typ, který má pouze dvě hodnoty: true a false.
Var a = pravda; var b = nepravda;
TětivaString je datový typ, který se v JavaScriptu používá k reprezentaci textu.
Řetězec JavaScriptu se může skládat z 0 nebo více postavy.
JavaScript vždy používá jako formát řetězce Unicode.
Vytvoření řetězce (řetězcového literálu) se provádí uzavřením textu do jednoduchých nebo dvojitých uvozovek.
"JavaScript"; "ECMAScript";
V JavaScriptu není žádný rozdíl mezi jednoduchými a dvojitými uvozovkami.
Ale v některých případech má smysl používat jednoduché uvozovky spíše než dvojité a naopak.
Pokud například řetězec obsahuje dvojité uvozovky, je vhodnější jej uzavřít do jednoduchých uvozovek. Tím odpadne nutnost dávat v něm dvojité uvozovky.
""ECMAScript""; // bez escapování (pomocí jednoduchých uvozovek) "\"ECMAScript\""; // s útěkem
Řetězec v JavaScriptu může obsahovat Speciální symboly. Například \n (odřádkování), \t (tabulátor), \r (návrat vozíku) atd.
"Toto je věta.\nA toto je také věta, ale bude začínat na novém řádku.";
Pomocí řetězců můžete provádět operace sčítání (sjednocení) nebo jinými slovy zřetězení. K tomu slouží operátor „+“. Smyslem této operace je připojit druhý řádek na konec prvního.
"Miluji" + "JavaScript"; // Miluji JavaScript
Hodnota je "undefined"undefined je speciální primitivní datový typ, který má jednu hodnotu rovnou undefined .
Tento datový typ má deklarovanou proměnnou, které ještě nebyla přiřazena hodnota.
Var num; //nedefinováno
Hodnota undefined bude vrácena také při přístupu k neexistující vlastnosti objektu.
Var obj = (); // prázdný objekt obj.prop; //nedefinováno
"nulová" hodnotanull je speciální primitivní datový typ, který má jednu hodnotu rovnou null .
null je jen speciální hodnota, která má význam „nic“ nebo „neznámá hodnota“, tzn. jasně to nic neznamená.
ObjektObjekt je datová struktura sestávající z párů název-hodnota.
Vytvoření objektu pomocí objektového doslovného zápisu se provádí následovně:
( název_1: hodnota_1, název_2: hodnota_2, název_3: hodnota_3, ... )
Jak vidíte, název se od hodnoty odděluje dvojtečkou a dvojice se od sebe oddělují čárkou.
Navíc, pokud je hodnotou dvojice funkce, pak se nazývá metoda tohoto objektu. Všechny ostatní páry, tzn. páry, ve kterých funkce není použita jako hodnota, se nazývají vlastnosti objektu.
Jinými slovy, objekt je datová struktura sestávající z vlastností a metod.
Var osoba = ( jméno: "Vitaly", věk: 27, getAge: function () ( return "Age: " + this.age; ) )
Přístup k vlastnostem objektu se provádí pomocí tečky nebo pomocí zápisu v závorkách.
// zobrazení hodnoty vlastnosti age v konzoli prohlížeče // 1. metoda (přes tečku) console.log(person.age); // Metoda 2 (pomocí závorek) console.log(person["věk"]); // volání metody getAge; hodnota, kterou vrátí, bude odeslána do konzole console.log(person.getAge());
typ operátoraOperátor typeof se používá k získání informací o datovém typu výrazu jako řetězce.
Syntaxe operátoru typeof (volba bez závorek):
Typ výrazu
Typ syntaxe operátoru (pomocí závorek):
Typ (výraz)
Jméno proměnné, věk = 37, e-mail = " [e-mail chráněný]", isLicense = true, interest: null, lastExperience: ( období: "červen 2011 - červen 2018", místo: "ISACA, Moskva", pozice: "Web designer" ), getExperience: function() ( return lastExperience.period + " ("+ poslední zkušenost.pozice + " - " + poslední zkušenost.místo + ")"; ); typ jména; // "nedefinovaný" typ věku; // "číslo" typ jeLicence; // "booleovský" typ zájmu; / / "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) je chyba, která se v jazyce vyskytuje od jeho první implementace; nebyla opraveno, aby byla zachována kompatibilita a to je třeba vzít v úvahu při psaní skriptů; null je primitivní datový typ, není to objekt */ /* (2) - je velmi vhodné, aby operátor typeof odděloval funkce odděleně; funkce v JavaScipt je také objekt; to lze snadno ověřit provedením následující konstrukce: */ typeof getExperience.__proto__.__proto__ // "objekt" (prototyp funkce je objekt)
KonstantyS vydáním ECMAScript 6 bylo možné vytvářet konstanty. To se provádí pomocí klíčového slova const.
Const COLOR_RED = "#ff0000";
Konstanta je proměnná, jejíž hodnota je chráněna před změnou. Tito. Při pokusu o změnu hodnoty dojde k chybě.
Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Přiřazení konstantní proměnné.
Pokud například konstanta obsahuje objekt, pak jej nelze změnit, respektive odkaz na něj. Ale vlastnosti tohoto objektu lze změnit.
Const COLORS = ( červená: "#ff0000", zelená: "#00ff00", modrá: "#00ff00" ) COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Přiřazení konstantní proměnné. COLORS.green = "#4caf50";
Stejně jako v jakémkoli jiném programovacím jazyce se datové typy v JS dělí na:
–literály a proměnné
–pole, funkce a objekty
Doslovy:
Literály jsou nejprimitivnější jednotky v jakémkoli programovacím jazyce, jako jsou čísla a symboly. V JavaScriptu jsou literály rozděleny na číselné a řetězcové:
Číselné literály Řetězcové literály
4.5e+2 "Datové typy v JavaScriptu"
Literály v kódu JS můžete použít pro operace přiřazení a porovnání:
var pi = "číslo PI";
if(q == "b") q = b + 1;
Proměnné:
Co je to programovací jazyk bez proměnných? Obecně lze proměnné bezpečně nazvat základem jakéhokoli programovacího jazyka. Bez použití proměnných nelze provést téměř žádnou funkci, žádnou smyčku nebo příkaz.
JavaScript vám umožňuje přiřadit tomuto datovému typu nejen doslovné hodnoty, ale také celé pole, celou funkci nebo název objektu. Proměnné můžete nastavit buď jednoduše kdekoli v programu, nebo pomocí operátoru var:
id = window.close();
var arr = new Array();
ob = dokument.formy;
V JavaScriptu existují dva hlavní typy polí:
zabudovaný do interpretru (document.forms, document.images,...)
definované uživatelem
Pole je vytvořeno pomocí nové Array();
a = new Array(); b = new Array(15); c = new Array(15,33,"value 3");
V prvním případě je proměnné a přiřazeno prázdné pole, ve druhém je proměnné b přiřazeno pole, jehož první hodnotou je číslo 15, a nakonec ve třetím případě je proměnné c přiřazeno pole 3 hodnot, tj. třetí z nich je řetězcový literál.
Existuje několik základních metod pro zpracování polí v JS:
připojit se(); obrátit();seřadit();
Níže je uveden seznam hlavních operátorů, které budeme zvažovat:
var; (...); li; zatímco; pro; pro ... v; přestávka; pokračovat; vrátit se.
3. Proměnné a operátor přiřazení v JavaScriptu.Základním operátorem přiřazení je obyčejná ekvalizace =, která dává levému operandu hodnotu pravého operandu.
Zbývající operátory jsou zkratky následujících tvarů: Zkratka Operátor Význam
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
x>y
x >>>= y x = x >>> y
x &= y x = x & y
x ^= y x = x ^ y
x |= y x = x | y
4. Operátoři v JavaScriptu.Operátory se používají k řízení toku příkazů v JavaScriptu. Jeden objekt může být rozdělen do více řádků, nebo naopak může být na jednom řádku více příkazů.
Musíte vědět následující, za prvé, bloky příkazů, jako jsou definice funkcí, musí být uzavřeny ve složených závorkách. Za druhé, středník slouží jako oddělovač jednotlivých příkazů. Pokud vynecháte středník, bude chování programu nepředvídatelné.
Protože JavaScript nemá přísné požadavky na formátování textu programu, můžete pro lepší čitelnost textu vkládat zalomení řádků a znaky pro odsazení.
V JavaScriptu se používají následující operátory:
break, comment, continue , for , for...in , function , if... else
JavaScript nebo JS(zkráceně) není jednoduchý jazyk a začínající vývojáři se o něm hned tak nedozví. Nejprve se naučí základy a vše se jim zdá barevné a krásné. Když půjdeme trochu hlouběji, objeví se pole JavaScriptu, objekty, zpětná volání a všechno podobné, což vám často vyrazí dech.
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í triky při ověřování a o nich bude tento příspěvek. Začněme hned.
Kontrola typu proměnnéNapříklad potřebujete zkontrolovat, zda je proměnná objekt, pole, řetězec nebo číslo. Můžete k tomu použít typeof, ale ne vždy bude říkat pravdu a v příkladu níže ukážu proč.
Napsal jsem tento příklad, abych jasně ukázal, proč typeof není vždy tou správnou volbou.
Var _comparison = ( string: "string", int: 99, float: 13.555, object: (ahoj: "ahoj"), pole: new Array(1, 2, 3) ); // Vrátí pole s klíči objektu var _objKeys = Object.keys(_comparison); for(var i = 0; i colorArray.length - 1)( i = 0; ) ) Změnit pozadí
Uvnitř prvku.
Prvek lze vložit kamkoli do dokumentu. Uvnitř tagu je kód, který se provede ihned po načtení prohlížečem, nebo obsahuje popis funkce, která se provede v okamžiku, kdy je volána. Popis funkce lze umístit kamkoli, hlavní je, že v době, kdy je volána, je již načten kód funkce.
Kód JavaScript se obvykle umístí do záhlaví dokumentu (prvku) nebo za úvodní značku. Pokud je skript použit po načtení stránky, například kód čítače, je lepší jej umístit na konec dokumentu:
document.write("Zadejte své jméno");
2. Datové typy a proměnné v JavaScriptuPočítače zpracovávají informace – data. Data mohou být prezentována v různých formách nebo typech. Většina funkcí JavaScriptu je implementována prostřednictvím jednoduché sady objektů a datových typů. Funkce řetězců, čísel a logiky jsou založeny na řetězcových, číselných a booleovských typech dat. jiný funkčnost, včetně regulárních výrazů, dat a matematických operací, se provádí pomocí objektů RegExp, Date a Math.
Literály v JavaScriptu jsou speciální třída datového typu, pevné hodnoty jednoho ze tří datových typů – řetězec, číselný nebo booleovský:
"toto je řetězec" 3.14 true alert("Ahoj"); // "Ahoj" je doslovný var myVariable = 15; // 15 je doslovné
Primitivní datový typ je instance určitý typ data jako řetězec, numerická, booleovská, null a nedefinovaná.
2.1. Proměnné v JavaScriptuÚdaje zpracovány JavaScript skript, jsou proměnné. Proměnné jsou pojmenované kontejnery, které ukládají data (hodnoty) v paměti počítače, které se mohou během provádění programu měnit. Proměnné mají název, typ a hodnotu.
Název proměnné nebo identifikátor může obsahovat pouze písmena a-z, A-Z, čísla 0-9 (číslo nemůže být prvním znakem v názvu proměnné), symbol $ (může být pouze první znak v názvu proměnné nebo funkce) a znak podtržítka _, mezery nejsou povoleny. Délka názvu proměnné není omezena. Je možné, ale nedoporučuje se psát názvy proměnných písmeny ruské abecedy, k tomu musí být napsány v Unicode.
Jako název proměnné nemůžete použít klíčová slova JavaScriptu. Názvy proměnných v JavaScriptu rozlišují velká a malá písmena, což znamená, že proměnná var message; a var Zpráva; - různé proměnné.
Proměnná je vytvořena (deklarována) pomocí klíčového slova var následovaného názvem proměnné, například var message; . Před použitím musíte proměnnou deklarovat.
Proměnná je inicializována hodnotou pomocí operátoru přiřazení = , například var message="Hellow"; , tj. vytvoří se proměnná zprávy a do ní se uloží její počáteční hodnota "Ahoj". Proměnná může být deklarována bez hodnoty, v takovém případě je jí přiřazena výchozí hodnota undefined . Hodnota proměnné se může během provádění skriptu změnit. Na stejném řádku lze deklarovat různé proměnné oddělené čárkou:
Var message="Ahoj", number_msg = 6, time_msg = 50;
2.2. Variabilní datové typyJavaScript je netypovaný jazyk, datový typ pro konkrétní proměnnou není nutné při deklaraci uvádět. Datový typ proměnné závisí na hodnotách, které přijímá. Typ proměnné se může měnit během datových operací (dynamické přetypování). Převody typů se provádějí automaticky v závislosti na kontextu, ve kterém jsou použity. Například ve výrazech obsahujících číselné a řetězcové hodnoty s operátorem + JavaScript převede číselné hodnoty na řetězcové hodnoty:
Zpráva Var = 10 + "dní před dovolenou"; // se vrátí "10 dní do dovolené"
Datový typ proměnné můžete získat pomocí operátoru typeof. Tento operátor vrací řetězec, který identifikuje odpovídající typ.
Typ 35; // return "number" typeof "text"; // vrátí "string" typeof true; // return "boolean" typeof ; // return "object" typeof undefined; // vrátí "undefined" typeof null; // vrátí "objekt"
Všechny datové typy v JavaScriptu jsou rozděleny do dvou skupin – jednoduché datové typy (primitivní datové typy) a složené datové typy (složené datové typy).
Mezi jednoduché datové typy patří řetězec, numerický, booleovský, null a underfined.
2.2.1. Typ řetězcePoužívá se k uložení řetězce znaků uzavřených do dvojitých nebo jednoduchých uvozovek. Prázdná sada znaků uzavřená v jednoduchých nebo dvojitých uvozovkách je prázdný řetězec. Číslo uzavřené v uvozovkách je také řetězec.
Var peníze = ""; // prázdný řetězec, nula znaků var work = "test"; var den = "neděle"; var x = "150";
Do řetězce s dvojitými uvozovkami můžete vložit jednu uvozovku a naopak. Uvozovky stejného typu jsou uvozeny pomocí znaku zpětného lomítka \ (tzv. sekvence escape):
Document.writeln("\"Dobré ráno, Ivane Ivanoviči!\"\n"); // zobrazí "Dobré ráno, Ivane Ivanoviči!"
Řetězce lze porovnávat a také kombinovat pomocí operátoru zřetězení + . Díky automatickému odlévání typu můžete kombinovat čísla a řetězce. Řetězce jsou trvalé, jakmile je řetězec vytvořen, nelze jej upravit, ale lze vytvořit nový řetězec zřetězením jiných řetězců.
2.2.2. Číselný typ (číslo)Používá se pro číselné hodnoty. V JavaScriptu existují dva typy čísel: celá čísla (celé číslo) a čísla s plovoucí desetinnou čárkou (číslo s plovoucí desetinnou čárkou). Celočíselné hodnoty mohou být kladné, například 1, 2, záporné, například –1, –2 nebo nula. 1 a 1.0 jsou stejné hodnoty. Většina čísel v JavaScriptu je zapsána v desítkové soustavě, ale lze použít i osmičkové a šestnáctkové soustavy.
V desítkové soustavě se hodnoty číselných proměnných zadávají pomocí arabských číslic 1, 2, 3, 4, 5, 6, 7, 8, 9, 0.
V osmičkovém formátu je číslo posloupnost obsahující číslice 0 až 7, začínající předponou 0.
U hexadecimálního formátu se přidá předpona 0x (0X), po níž následuje sekvence čísel od 0 do 9 nebo písmen od a (A) do f (F), odpovídající hodnotám od 10 do 15.
Var a = 120; // celé číslo desítková číselná hodnota var b = 012; // osmičkový formát var c = 0xfff; // hexadecimální formát var d = 0xACFE12; // hexadecimální formát
Čísla s plovoucí desetinnou čárkou jsou čísla se zlomkovou desetinnou částí nebo jsou to čísla vyjádřená ve vědeckém zápisu. Vědecký zápis čísel má následující tvar: číslo se zlomkovou desetinnou částí, za nímž následuje písmeno e, které může být uvedeno jak velkým, tak malým písmenem, dále nepovinné znaménko + nebo - a exponent celého čísla.
Var a = 6,24; // reálné číslo var b = 1,234E+2; // reálné číslo, ekvivalentní 1,234 X 10² var c = 6,1e-2; // reálné číslo, ekvivalentní 6,1 X 10‾²
2.2.3. Booleovský typTento typ má dvě hodnoty, true, false. Používá se k porovnání a testování podmínek.
Var answer = potvrdit("Líbil se vám tento článek?\n Klikněte na OK. Pokud ne, klikněte na Storno."); if (odpověď == pravda) (upozornění("Děkuji!"); )
Existují také speciální typy jednoduchých hodnot:
nulový typ - tenhle typ má jedinou hodnotu null, která se používá k reprezentaci neexistujících objektů.
undefined type - typ proměnné underfined znamená absenci počáteční hodnoty proměnné a také neexistující vlastnost objektu.
Složené datové typy se skládají z více než jedné hodnoty. Patří sem objekty a speciální typy objektů – pole a funkce. Objekty obsahují vlastnosti a metody, pole jsou indexovanou kolekcí prvků a funkce se skládají z kolekce příkazů.
2.3. Globální a lokální proměnnéProměnné podle rozsahu se dělí na globální a lokální. Rozsah je část skriptu, ve které je název proměnné přidružen k této proměnné a vrací její hodnotu. Proměnné deklarované v těle funkce se nazývají lokální proměnné a lze je použít pouze v rámci dané funkce. Lokální proměnné se vytvářejí a ničí spolu s odpovídající funkcí.
Proměnné deklarované uvnitř prvku nebo uvnitř funkce, ale bez použití klíčového slova var, se nazývají globální. Lze k nim přistupovat, pokud je stránka načtena v prohlížeči. Tyto proměnné mohou být použity všemi funkcemi, což jim umožňuje vyměňovat si data.
Globální proměnné končí v globálním jmenném prostoru, kde dochází k interakci jednotlivých komponent programu. Nedoporučuje se deklarovat proměnné tímto způsobem, protože podobné názvy proměnných již mohou být používány jiným kódem, což způsobí zhroucení skriptu.
Globální prostor v JavaScriptu je reprezentován objektem globálního okna. Přidání nebo změna globálních proměnných automaticky aktualizuje globální objekt. Aktualizace globálního objektu zase automaticky aktualizuje globální obor názvů.
Pokud mají globální a lokální proměnná stejný název, bude mít lokální proměnná přednost před globální.
Lokální proměnné deklarované v rámci funkce v různých blocích kódu mají stejný rozsah. Je však doporučeno umístit všechny deklarace proměnných na začátek funkce.