Důležité poznámky
nula
V JavaScriptu kromě nedefinovaného existuje null . Znamená to „žádná hodnota“. Pokud například vytvoříte proměnnou, ale nepřiřadíte jí hodnotu, bude mít hodnotu nedefinovanou:
Nechť a; console.log(a); // nedefinováno
Neúmyslně zde nebyl žádný význam. Zjevně prostě ještě nenastal čas dát této proměnné hodnotu.
null je potřeba k explicitnímu, záměrnému označení, že neexistuje žádná hodnota. Můžete říci let a = null; . Například jste uživatele požádali o zadání informací, ale on nic nezadal. V tomto případě je vhodné do výsledku napsat null.
null , na rozdíl od undefined , lze nastavit ručně, předat funkci jako argument a obecně použít jako jakoukoli jinou explicitní hodnotu.
(undefined lze zadat také ručně, ale nikdy byste to neměli dělat: tato hodnota je sémanticky vytvořena pouze proto, aby byla generována počítačem, nikoli programátorem).
Při porovnávání null a undefined musíte být opatrní:
Typeof null; // "object" (ne "null" z historických důvodů) typeof undefined; // "undefined" null === undefined; // false null == undefined; // true null === null; // true null == null; // true !null; // true isNaN(1 + null); //false isNaN(1 + nedefinováno); //skutečný
Srovnání
V tomto kurzu porovnáváme data pomocí tří rovnítek:
A === b; 12 === 12;
Toto srovnání je přímé: jsou tyto údaje absolutně totožné?
JavaScript má uvolněné srovnání se dvěma stejnými znaménky. Ukazují, co se děje uvnitř JavaScriptu, když zpracovává psaní:
1 === "1"; // false 1 == "1"; // true true === 1; // false true == 1; // skutečný
Shrnutí lekce
Psaní v JavaScriptu
JavaScript rozumí typům: číslům, řetězcům, funkcím, booleanům a tak dále. typeof vrátí řetězec obsahující typ:
NaN znamená „ne číslo“, ale typ této hodnoty je číslo .
Proměnná bez hodnoty má speciální význam undefined. Typ takové proměnné není definován:
Dynamické a statické psaní
Kód je převeden do jiné podoby, kterou může počítač spustit. Tento proces se nazývá kompilace a časové období, během kterého k tomuto procesu dochází, je fáze kompilace(čas kompilace).
Po dokončení kompilace se program spustí a zavolá se perioda, po kterou běží fáze provádění(doba běhu).
Staticky typováno jazyky kontrolují typy a hledají chyby při kompilaci.
Dynamicky psané jazyky kontrolují typy a vyhledávají překlepy za běhu.
Jinými slovy: statické psaní znamená kontrolu typů před spuštěním programu; dynamická - kontrola typu za běhu programu.
Slabé a silné psaní
JavaScript často automaticky převádí typy:
JavaScript je slabě napsaný jazyk. Má představu o typech, ale je v nich uvolněný a s hodnotami může pracovat, dalo by se říci, libovolně. Čím silnější je systém psaní, tím přísnější jsou pravidla.
Explicitní konverze v JavaScriptu
Volitelný
Zábava
Přepis lekce
V jedné z předchozích lekcí jsme hovořili o chybách a o tom, jak se s nimi vypořádat. Existuje několik typů chyb a jeden konkrétní typ vám chci připomenout. Zde je malý fragment této lekce:
Podívejte se na tento kód:
Const length = 12; const num = délka(54);
Nejprve jsme vytvořili konstantu. Pamatujte, že je to jako dát něčemu jméno: v našem případě je číslu 12 přiřazena délka názvu . Na dalším řádku zavoláme funkci length a předáme jí argument - číslo 54. Ale počkat! délka není funkce! Je to jen číslo. Čísla nejsou funkce, ani políčka, které provádějí nějakou akci. A JavaScript si bude stěžovat přesně na toto:
→ node test.js /Users/rakhim/test.js:2 const num = length(-54); ^ TypeError: délka není funkce v objektu.
Tento Překlep: Použitý typ objektu je nesprávný. Překladač JavaScriptu vám to neřekne co je něco, ale určitě řekne co to není. délka není funkce.
Chyba při psaní je jako požádat kočku, aby vyprala. Možná jste se na to chtěli zeptat svého přítele.
V programování je „psaní“ klasifikací informací. Toto je obecný termín a různé programovací jazyky zvládají psaní odlišně. Jak již víte, JavaScript dokáže rozlišovat mezi typy. Funkce je jeden typ, Číslo je jiný a číslo nelze použít jen jako funkci.
typeof je speciální operátor, který vrací řetězec, ve kterém je typ zapsán.
Typ 42; // "číslo" typ 3.14; // "číslo" typ NaN; // "číslo" typ "Berry"; // "string" typeof true; // "booleovský" typ false; // "boolean"
42 a 3.14 jsou zjevně čísla, několik kombinací písmen v uvozovkách je řetězec a true a false jsou booleovské hodnoty. To vše jsou typy v JavaScriptu - číslo, řetězec a boolean.
NaN znamená „ne číslo“, ale typ NaN je „číslo“. Ano, já vím. Další zvláštní věc ohledně JavaScriptu. Toto jsou pravidla v tomto jazyce.
Psaní je užitečné. Když se pokusíme spustit číslo, jako by to byla funkce, JavaScript si začne stěžovat a my uvidíme chybu a opravíme ji. Pokud by v JavaScriptu neexistoval zápis typu, skončili bychom buď s nějakým anomálním chováním, nebo se záhadnou chybou. Místo jasného „délka není funkce“ bychom viděli něco jako „Omlouvám se Dave, obávám se, že to nedokážu“.
Co když vytvoříte proměnnou, ale nepřiřadíte jí žádnou hodnotu? Jaký typ to bude v tomto případě? Není to číslo, není to řetězec, není to nic... Protože to nemá žádný význam, že?
JavaScript v tomto případě před vámi dělá něco tajného. Proměnná bez hodnoty má ve skutečnosti zvláštní význam – „nedefinováno“. A typ takové proměnné se nazývá "undefined".
Nechť a; console.log(a); // nedefinovaný typ a; // "nedefinováno"
Například typ čísla má mnoho potenciálních hodnot: 1, 2, -10, 69000 a další čísla. A existuje jen jeden typ nedefinovaného – nedefinovaného.
Pokud jde o psaní v programování, je důležité rozlišovat mezi dvěma pojmy: dynamický vs. statický a slabý vs. silný.
Abychom pochopili rozdíl mezi dynamickým a statickým psaním, musíme se nejprve podívat na to, jak se psané programy stávají běžícími programy.
Kód, který napíšete, je obvykle převeden do podoby, kterou může počítač spustit. Tento proces se nazývá kompilace a časové období, během kterého k tomu dochází, se nazývá „fáze kompilace“ nebo doba kompilace.
Po dokončení kompilace a spuštění programu začne odpočítávání času, které se nazývá „fáze provádění“ nebo doba běhu.
Některé jazyky kontrolují typy a hledají chyby při kompilaci. Mají statické psaní.
Jiné jazyky kontrolují typy a hledají překlepy za běhu. Toto psaní je dynamické.
Jinými slovy: statické psaní znamená kontrolu typů před spuštěním programu, dynamické psaní znamená kontrolu typů za běhu programu.
C#, C++, Java, Go jsou staticky typované jazyky. Pokud v jednom z těchto jazyků vytvoříte číslo a pokusíte se s ním pracovat jako s funkcí, dostanete chybu při kompilaci a program se nespustí – do této fáze se ani nedostane, protože psaní chyba bude zachycena před provedením během kompilace.
JavaScript, Ruby, PHP jsou dynamicky typované jazyky. Jak jste viděli dříve, pokud použijete nesprávný typ, váš program se spustí a chyba bude objevena pouze při spuštění konkrétního řádku kódu. Zde se typy kontrolují za běhu.
Vlastně v JavaScriptu obvykle neexistuje žádná kompilace, ale to je téma na jinou lekci.
Dynamické psaní není o nic horší ani lepší než psaní statické. Oba způsoby mají své výhody i nevýhody. Dynamicky psané jazyky se obvykle snáze učí a lze v nich psát programy, ale jak si dokážete představit, potenciálně to zvyšuje chyby a chyby.
Nyní si povíme něco o slabém a silném psaní. Podívejte se na tento kód JavaScript:
4 + "7"; // "47" 4 * "7"; // 28 2 + true; // 3 nepravda - 3; // -3
Hmmm... Tohle... Ok, co se tady děje? Přidáním čísla 4 k řetězci "7" získáme řetězec "47". JavaScript převede číslo 4 na řetězec "4" a zřetězí dva řetězce - slepí je dohromady. JavaScript prostě bere na sebe, že předpokládá, že to je to, co jsme chtěli. Je hloupé mu to vyčítat – co jsme vlastně chtěli? Přidání čísla do řetězce nemá smysl. Jakýkoli jiný jazyk jako Ruby nebo Python by si jednoduše stěžoval a nic nedělal.
Součin čísla 4 s řetězcem „7“, jak vidíte, je podle JavaScriptu 28. V tomto případě převedl řetězec "7" na číslo 7 a provedl obvyklé násobení.
JavaScript to dělá neustále. Ví o typech různých hodnot, ale když se typy neshodují, snaží se uhodnout a převést jeden typ na jiný, aniž by vás varoval. Někdy je to užitečné, někdy je to ohromující. To se děje proto, že JavaScript je jazyk se slabým typem písma. Má představu o typech, ale říká: "Je to jen hra, proč jsi naštvaný?"
Tento koncept nemá nic společného s dynamickým a statickým psaním, jehož smyslem je KDY kontrolovat typy. Silný vs slabý je JAK VÁŽNĚ kontrolovat typ.
Na rozdíl od dynamiky a statičnosti je síla psaní spektrem. Psaní v PHP je o něco silnější. Python je ještě silnější. A všechno jsou to dynamicky typované jazyky.
JavaScript provádí mnoho implicitních konverzí, ale také nám poskytuje nástroje, abychom mohli provádět explicitní konverze sami. Řetězce můžeme převést na čísla, čísla na řetězce, booleany na řetězce a tak dále:
Číslo("590"); // 590 Číslo("aaa!!"); // NaN Boolean(1); // true Boolean(0); // false String(true); // "true" String(false); // "false" String(44843); // "44843"
Dalo by se předpokládat, že implicitní převod z typu na typ není dobrý nápad. Implicitní znamená skrytý a skrytý znamená obtížně pochopitelný a náchylný k chybám. Chování programu bude méně zřejmé. Píšete méně kódu, ano, ale kód je křehčí a méně srozumitelný.
Pravidla syntaxe pro vytváření názvů proměnných v JavaScriptu jsou:
- Pro názvy proměnných se používají následující symboly: a-z, A-Z, čísla, symbol $ a podtržítko (_).
- Název proměnné nemůže začínat číslem.
- JavaScript rozlišuje velká a malá písmena, což je třeba mít při programování na paměti. itcounter a to C jsou různé proměnné.
- JavaScript nemá žádná omezení ohledně délky názvu proměnné.
Příklady správných názvů proměnných:
- itcounter
- $_itcounter
- it_counter
Nesprávné názvy proměnných:
- 9 pokoj
- it-counter
- #itcounter
- &itcounter
Proměnné jsou deklarovány pomocí příkazu var.
Proměnné mohou ukládat řetězce a čísla. Ve skutečnosti můžete ukládat i jiné typy dat, ale o nich si povíme později.
Řetězcové proměnné
Chcete-li zapsat řetězec do proměnné, musíte její hodnotu uzavřít do uvozovek, dvojitých nebo jednoduchých.
Var $stroka_1 = "Dobrý den!"; var $stroka_2 = "Pozor!";
Do řetězce vytvořeného pomocí jednoduché uvozovky můžete vložit dvojitou uvozovku a naopak.
Var $stroka_1 = ""Dobrý den!" je pozdrav."; var $stroka_2 = ""Pozor!" je varování."; document.write($stroka_1); document.write("
Chcete-li zobrazit uvozovku stejného typu, musí být ukončena znakem zpětného lomítka. Je to jednoduché:
"); document.write($stroka_2);
Hodnoty proměnných lze přiřadit dalším proměnným:
Var $stroka_1 = "\"Dobrý den!\" je pozdrav."; var $stroka_2 = "\"Pozor!\" je varování."; document.write($stroka_1); document.write("
"); document.write($stroka_2); $stroka_2 = $stroka_1; document.write("
"); document.write($stroka_2);
V tomto příkladu jsme nejprve přiřadili jednu řetězcovou hodnotu proměnné $stroka_2, ale poté jsme jí přiřadili hodnotu proměnné $stroka_1.
Zřetězení řetězců
Velmi často je potřeba spojit několik řádků do jednoho. Například náš poslední příklad je příliš těžkopádný.
Kombinování (řetězení) řetězců v JavaScriptu se provádí pomocí znaménka + .
Chcete-li zobrazit 2 proměnné řetězce oddělené značkou
proměnné můžete použít jeden příkaz document.write() .
Var $stroka_1 = ""Dobrý den!" je pozdrav."; var $stroka_2 = ""Pozor!" je varování."; document.write($stroka_1 + "
" + $stroke_2);
Operátor zřetězení + lze také použít v proměnných:
Var $stroka_1 = ""Dobrý den!" je pozdrav."; var $stroka_2 = ""Pozor!" je varování."; var $stroka_3 = $stroka_1 + "
" + $stroka_2; document.write($stroka_3);
Číselné proměnné
Chcete-li vytvořit číselnou proměnnou, jednoduše jí přiřadíte číselnou hodnotu.
Var $count_1 = 23; var $count_2 = 10,34; document.write($count_1 - $count_2);
Nyní další příklad:
Var $count_1 = 23; // Číselná proměnná. var $stroka_1 = "57"; // Řetězcová proměnná. document.write($stroka_1 + $count_1);
Vidíte, že hodnota proměnné $stroka_1 je v uvozovkách, což znamená, že se jedná o textovou proměnnou. Poté přidáme textové a číselné proměnné a získáme řetězec "5723", takto v takových případech funguje JavaScript - přemění číslo na řetězec a přidá ho k sečtenému řetězci.
Booleovské proměnné
Existuje takový typ proměnných - Boolean. Vše je jednoduché, existují pouze dvě hodnoty: true a false, tedy true (true) a false (false).
Tento datový typ se používá při srovnávacích operacích. Zde jsou jednoduché příklady:
- 9 > 1 je pravda.
- 2 > 5 je lež.
Nyní se pokusíme nahradit booleovské hodnoty do aritmetických operací. Shrňme si obě srovnávací operace:
Var $počet = (3 > 2) + (4 > 2); document.write($count);
Tohle je zvláštní příspěvek, já vím. Ale proměnná $count bude rovna 2. V matematickém kontextu je hodnota true = 1 a hodnota false = 0.
Porovnávací operátory se používají v běžně používaném příkazu if v JavaScriptu. Slovo if v angličtině znamená - kdyby.
Var $počet = 100; if ($počet == 100) document.write("Proměnná $počet je 100.");
V tomto příkladu se na obrazovce zobrazí zpráva, protože podmínka příkazu if ($count == 100) je pravdivá. Pokud změníte hodnotu proměnné $count na 99, pak se podmínka ($count == 100) stane nepravdivou a na obrazovce se nic nezobrazí.
Jednoduché typy proměnných
V JavaScriptu jsou proměnné klasifikovány do několika typů. Již jsme se podívali na řetězcové, číselné a booleovské (logické) typy. Zde je širší seznam jednoduchých typů:
- string - řetězcová proměnná.
- číslo - číselná proměnná.
- boolean - booleovská proměnná.
- null je speciální hodnota pro „nic“.
- undefined - typ “žádná hodnota přiřazena”.
Hodnota proměnné null tvoří svůj vlastní samostatný typ null, který se skládá z jediné možné hodnoty null. null je speciální hodnota, která má význam „nic“ nebo „hodnota je neznámá“.
Var $cena = null; // to znamená, že cena není známa.
V JavaScriptu můžete zjistit typ proměnných pomocí příkazu typeof.
Var $počet; document.write(typeof $count + "
"); var $count = true; document.write(typeof $count + "
"); var $count = "true"; document.write(typeof $count + "
"); var $count = 100; document.write(typeof $count + "
"); var $count = null; document.write(typeof $count + "
");
Syntaxe příkazu typeof by mohla být:
- typ $počet
- typeof($count)
Spusťte tedy kód z posledního příkladu a podívejte se na výsledek. Typ proměnné null bude objekt. Toto je chyba v jazyce a pravděpodobně nebude nikdy opravena kvůli nutnosti udržovat stávající skripty JavaScriptu kompatibilní s novými verzemi jazyka.
Objektový typ již není primitivním typem, o tom si povíme v dalších lekcích.
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<= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }
Výsledek spuštění kódu:
Objekt řetězec číslo číslo objektu
Že jo? - Samozřejmě že ne. Problémy jsou dva. Každý z nich bude podrobně popsán a navrženo řešení.
První problém: plovoucí číslo, výstup jako číslo
Comparison.float není číslo a číslo by mělo být číslo s plovoucí desetinnou čárkou. Chcete-li to vyřešit, můžete vytvořit funkci se zaškrtnutím jako v kódu níže.
Var_floatNumber = 9,22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); function isFloat(n)( return Number(n) === n && n % 1 !== 0; )
Funkce isFloat() kontroluje, zda jsou všechny hodnoty s pohyblivou řádovou čárkou. Nejprve se zkontroluje, zda je proměnná rovna nčíslo (Number(n) === n) a pokud ano, tak se provede další kontrola na dělení zbytkem a pokud je tam zbytek, tak boolean ( skutečný nebo Nepravdivé) výsledek (n % 1 !== 0).
Ve výše uvedeném příkladu se vrací skutečný, Nepravdivé A Nepravdivé. První význam je plovák typ, druhý není - je to běžné čí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 přesně tento typ a nic jiného.
Existuje několik způsobů, jak zkontrolovat, zda je proměnná typu pole.
První možnost (dobrá možnost). Zda data patří do pole kontrolujeme pomocí instanceof().
Var data = new Array("ahoj", "svět"); var isArr = instance dat pole;
Druhá možnost (dobrá možnost). Metoda Array.isArray() vrací booleovskou hodnotu, která bude záviset na tom, zda je proměnná pole nebo ne ().
Var data = new Array("ahoj", "svět"); var isArr = Array.isArray(data);
Třetí možnost (nejlepší, ale dlouhá). Pro pohodlí můžete z této metody udělat funkci. Pomocí Object děláme . Pokud se výsledek Object.prototype.toString.call(data) nerovná, pak proměnná není pole ().
Var data = new Array("ahoj", "svět"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);
Poslední výsledek v podobě komfortní funkce:
Funkce isArray(data) ( return Object.prototype.toString.call(data) == "" )
Nyní můžete zavolat funkce isArray() a nastavit pole nebo něco jiného jako argument a vidět výsledek.
Doslov
Nahrávka se ukázala být docela velká, než bylo původně zamýšleno. Ale těší mě, protože celkem stručně a jasně popisuje potíže při kontrole proměnných v JavaScriptu a jak je obejít.
Pokud máte ještě nějaké dotazy, napište je níže pod tento záznam. Rád pomohu.
Typy dat
Datové typy v JavaScriptu lze rozdělit do dvou kategorií: jednoduché typy a objekty. Jednoduché typy v JavaScriptu zahrnují čísla, textové řetězce a logické (neboli booleovské) hodnoty.
Speciální hodnoty null a undefined jsou elementární hodnoty, ale nejsou to čísla, řetězce nebo booleovské hodnoty. Každý z nich definuje pouze jednu hodnotu vlastního speciálního typu.
Jakákoli hodnota v JavaScriptu, která není číslo, řetězec, logická hodnota nebo speciální hodnota null nebo undefined, je objekt. Objekt(tj. člen datového typu objektu) je kolekce vlastností, z nichž každá má název a hodnotu (buď jednoduchý typ, jako je číslo nebo řetězec, nebo typ objektu).
Běžný objekt JavaScriptu je neuspořádaná kolekce pojmenovaných hodnot. JavaScript má navíc speciální typ objektu známý jako pole A, které představuje uspořádanou kolekci očíslovaných hodnot. JavaScript má speciální syntaktické konstrukce pro práci s poli.
JavaScript definuje další speciální typ objektu známý jako funkce. Funkce je objekt, se kterým je spojen spustitelný kód. Funkci lze zavolat, aby provedla konkrétní operaci a vrátila vypočítanou hodnotu. Stejně jako pole se funkce chovají jinak než jiné druhy objektů a JavaScript definuje speciální syntaxi pro práci s nimi. Jednou z nejdůležitějších věcí na funkcích v JavaScriptu je to, že se jedná o skutečné hodnoty a JavaScriptové programy s nimi mohou manipulovat jako s běžnými objekty.
Jsou volány funkce, které jsou napsány pro inicializaci nově vytvořených objektů (s operátorem new). návrháři. Každý konstruktér definuje třída objektu- sada objektů inicializovaných tímto konstruktorem. Třídy lze považovat za podtypy typu objektu.
Kromě tříd Pole A Funkce V základním jazyce JavaScript jsou definovány tři další užitečné třídy. Třída datum definuje objekty, které představují data. Třída RegExp definuje objekty, které reprezentují regulární výrazy (výkonný nástroj pro porovnávání vzorů). A třída Error definuje objekty, které představují chyby syntaxe a běhu, které se mohou vyskytnout v programech JavaScript. Je možné definovat vlastní třídy objektů deklarováním příslušných funkcí konstruktoru.
Čísla
Na rozdíl od mnoha programovacích jazyků JavaScript nerozlišuje mezi celočíselnými hodnotami a hodnotami s plovoucí desetinnou čárkou. Všechna čísla v JavaScriptu jsou reprezentována reálnými hodnotami (s plovoucí desetinnou čárkou). JavaScript používá k reprezentaci čísel standardně definovaný 64bitový formát IEEE 754. Tento formát je schopen reprezentovat čísla v rozsahu ±1,8 x 10308 až ±5 x 10-324.
V JavaScriptu se dekadická celá čísla zapisují jako posloupnost číslic. Kromě dekadických celočíselných literálů JavaScript rozpoznává hexadecimální hodnoty. Hexadecimální literály začínají posloupností znaků "0x" následovanou řetězcem hexadecimálních číslic. Hexadecimální číslice je jedno z čísel 0 až 9 nebo písmena A až F, které představují hodnoty 10 až 15:
Var a = 255; var b = 0xFF; // Číslo 255 v hexadecimálním zápisu
Literály reálných čísel musí mít desetinnou čárku – k definování takových literálů se používá tradiční syntaxe reálných čísel. Skutečná hodnota je reprezentována jako celá část čísla, za kterou následuje desetinná čárka a zlomková část čísla.
Literály reálného čísla mohou být také reprezentovány ve vědecké notaci: reálné číslo následované písmenem e (nebo E), následovaným volitelným znaménkem plus nebo mínus a exponentem celého čísla. Tato forma zápisu označuje reálné číslo vynásobené 10 mocninou určenou hodnotou exponentu:
Var a = 16,75; var b = 2e4; // 2 * 10^4 = 20 000
Aritmetické operace
Manipulace s čísly v JavaScriptu se provádí pomocí aritmetických operátorů. Mezi tyto operátory patří: operátor sčítání +, operátor odčítání -, operátor násobení *, operátor dělení / a operátor modulo % (vrací zbytek dělení).
Kromě těchto jednoduchých aritmetických operátorů podporuje JavaScript složitější matematické operace prostřednictvím funkcí a konstant dostupných jako vlastnosti objektu. Matematika:
Math.pow(2,53) // 2 na mocninu 53 Math.round(.6) // Zaokrouhlení na nejbližší celé číslo (výsledek 1,0) Math.ceil(,6) // Zaokrouhlení nahoru (výsledek 1,0) Matematika .floor( .6) // Zaokrouhlení dolů (výsledek 0) Math.abs(-5) // Modul čísla (výsledek 5) Math.max(x,y,z) // Vrátí největší argument Math.min( x,y,z ) // Vrátí nejmenší argument\ Math.random() // Pseudonáhodné číslo x, kde 0
Aritmetické operace v JavaScriptu nevyvolávají chybu v případě přetečení, podtečení nebo dělení nulou. Pokud je výsledek aritmetické operace větší než největší reprezentovatelná hodnota (přetečení), vrátí se speciální hodnota „nekonečno“, která se v JavaScriptu označuje jako Nekonečno. Podobně, pokud je absolutní hodnota negativního výsledku větší než největší reprezentovatelná hodnota, vrátí se hodnota „negativní nekonečno“, která je označena -Nekonečno.
Tyto speciální hodnoty pro nekonečno se chovají přesně tak, jak byste očekávali: sčítání, odečítání, násobení nebo dělení nekonečna jakoukoli hodnotou vede k nekonečnu (možná s opačným znaménkem).
Chybějící nastane, když je výsledek aritmetické operace blíže nule, než je minimální možná hodnota. V tomto případě je vrácené číslo 0. Pokud dojde ke ztrátě významných bitů v záporném výsledku, je vrácena speciální hodnota známá jako "záporná nula". Tato speciální hodnota je prakticky k nerozeznání od běžné nuly a programátoři JavaScriptu ji zřídka potřebují zvýrazňovat.
Dělení nulou se v JavaScriptu nepovažuje za chybu: jednoduše vrátí nekonečno nebo záporné nekonečno. Existuje však jedna výjimka: operace dělení nuly nulou nemá jasně definovaný význam, takže výsledek takové operace vrací speciální hodnotu „not-a-number“, která se označuje jako NaN. NaN je vráceno také při pokusu o dělení nekonečna nekonečnem, odmocnění záporného čísla nebo provedení aritmetické operace s nečíselnými operandy, které nelze převést na čísla.
JavaScript má předdefinované globální proměnné Infinity a NaN, které ukládají hodnoty kladného nekonečna a „ne čísla“. Ve standardu ECMAScript 3 jsou tyto proměnné pro čtení/zápis a lze je v programech měnit. Standard ECMAScript 5 toto přehlédnutí opravuje a vyžaduje, aby tyto proměnné byly pouze pro čtení.
datum a čas
Základní JavaScript poskytuje konstruktor Date() pro vytváření objektů, které představují datum a čas. Tyto objekty Date mají metody pro provádění jednoduchých výpočtů zahrnujících data. Objekt Date není základní datový typ jako čísla.
// Několik verzí přetíženého konstruktoru Date() new Date(); nové datum(milisekundy); new Date(datum_řetězec); nové datum (rok, měsíc, den, hodiny, minuty, sekundy, ms)
Konstruktor Date() bez argumentů vytvoří objekt Date s hodnotou rovnou aktuálnímu datu a času. Pokud je konstruktoru předán jeden číselný argument, použije se jako interní číselná reprezentace data v milisekundách, podobně jako hodnota vrácená metodou getTime(). Když je předán jeden řetězcový argument, je považován za řetězcovou reprezentaci data ve formátu akceptovaném metodou Date.parse().
Kromě toho lze konstruktoru předat dva až sedm číselných argumentů, které určují jednotlivá pole data a času. Všechny argumenty kromě prvních dvou - pole rok a měsíc - mohou chybět. Poznámka: tato pole data a času jsou nastavena na základě místního času, nikoli místního času UTC (Universal Coordinated Time). Alternativně lze použít statickou metodu Date.UTC(). Date() lze také volat jako funkci (bez operátoru new). Při tomto volání Date() ignoruje všechny předané argumenty a vrátí aktuální datum a čas.
| Argument | Označení |
|---|---|
| milisekundy | Počet milisekund mezi požadovaným datem a půlnocí 1. ledna 1970 (UTC). Například předání čísla 5000 jako argumentu vytvoří datum, které představuje pět sekund po půlnoci 1. ledna 1970. |
| datum_řetězec | Jediný argument, který určuje datum a (volitelně) čas jako řetězec. Řetězec musí být ve formátu, kterému Date.parse() rozumí. |
| rok | Rok ve čtyřech číslicích. Například 2001 pro 2001. Pro kompatibilitu s dřívějšími implementacemi JavaScriptu se k argumentu přidá 1900, pokud je hodnota argumentu mezi 0 a 99. |
| Měsíc | Měsíc, zadaný jako celé číslo od 0 (leden) do 11 (prosinec). |
| den | Den v měsíci zadaný jako celé číslo od 1 do 31. Všimněte si, že nejmenší z tohoto argumentu je 1 a zbývající argumenty jsou 0. Volitelný argument. |
| hodinky | Hodiny, zadané jako celé číslo od 0 (půlnoc) do 23 (23 hodin). Volitelný argument. |
| minut | Minuty v hodinách, zadané jako celé číslo od 0 do 59. Volitelný argument. |
| sekundy | Sekundy v minutách, zadané jako celé číslo od 0 do 59. Volitelný argument. |
| slečna | Milisekundy za sekundu, zadané jako celé číslo od 0 do 999. Volitelný argument. |
Objekt Date nemá žádné zapisovatelné nebo čitelné vlastnosti; místo toho se k hodnotám data a času přistupuje prostřednictvím metod. Většina metod objektu Date má dvě formy: jednu pro práci s místním časem, druhou pro práci s univerzálním časem (UTC nebo GMT). Pokud název metody obsahuje řetězec "UTC", pracuje s univerzálním časem.
Metody objektu Date lze volat pouze na objekty typu Date a vyvolá výjimku TypeError, pokud jsou volány na objekty jiného typu.
| Metoda | Popis |
|---|---|
| getDate(), getUTCDate(), setDate(), setUTCDate() | Vrátí/nastaví den v měsíci z objektu Date podle místního nebo univerzálního času. |
| getDay(), getUTCDay() | Vrátí den v týdnu z objektu Date podle místního nebo univerzálního času. |
| getFullYear(), getUTCFullYear(), setFullYear(), setUTCFullYear() | Vrátí/nastaví rok data v plném čtyřmístném formátu v místním nebo univerzálním čase. |
| getHours(), getUTCHours(), setHours(), setUTCHours() | Získá/nastaví pole hodiny v objektu Date v místním nebo univerzálním čase. |
| getMilliseconds(), getUTCMilliseconds(), setMilliseconds(), setUTCMilliseconds() | Získá/nastaví pole milisekund v objektu Date v místním nebo světovém čase. |
| getMinutes(), getUTCMinutes(), setMinutes(), setUTCMinutes() | Získá/nastaví pole minut v objektu Date v místním nebo univerzálním čase. |
| getMonth(), getUTCMonth(), setMonth(), setUTCMonth() | Získá/nastaví pole měsíc v objektu Date v místním nebo univerzálním čase. |
| getSeconds, getUTCSeconds(), setSeconds, setUTCSeconds() | Získá/nastaví pole sekund v objektu Date v místním nebo univerzálním čase. |
| getTime(), setTime() | Získá/nastaví vnitřní reprezentaci (milisekundy) objektu Date. Všimněte si, že tato hodnota není specifická pro časové pásmo, takže není potřeba samostatná metoda getUTCTime(). |
| getTimezoneOffset() | Vrátí rozdíl v minutách mezi místním a univerzálním zobrazením data v minutách. Všimněte si, že vrácená hodnota závisí na tom, zda je zadané datum letní čas. |
| getYear(), setYear() | Získá/nastaví pole roku v objektu Date. Zastaralé, místo toho se doporučuje používat metody getFullYear() a setFullYear().. |
| toDateString() | Vrátí řetězec představující datum z Date pro místní časové pásmo. |
| toGMTString() | Převede datum na řetězec pomocí časového pásma GMT. Metoda toUTCString() je zastaralá a místo ní se doporučuje. |
| toISOString() | Převede datum na řetězec pomocí standardu ISO-8601, který kombinuje formát data/času a UTC. |
| toJSON() | Serializuje objekt Date do formátu JSON pomocí metody toISOSTring(). |
| toLocaleDateString() | Vrátí řetězec představující datum z Date v místním časovém pásmu podle místních konvencí formátování data. |
| toLocaleString() | Převede datum na řetězec podle místního časového pásma a místních konvencí formátování data. |
| toLocaleTimeString() | Vrátí řetězec představující čas z Date v místním časovém pásmu na základě konvencí formátování místního času. |
| toString() | Převede datum na řetězec podle místního časového pásma. |
| toTimeString() | Vrátí řetězec představující čas z Date v místním časovém pásmu. |
| toUTCString() | Převede datum na řetězec pomocí univerzálního času. |
| hodnota() | Převede objekt Date do jeho interního milisekundového formátu. |
Kromě uvedených metod instance definuje objekt Date tři statické metody. Tyto metody jsou volány prostřednictvím konstruktoru Date() samotného, nikoli prostřednictvím jednotlivých objektů Date:
Date.now()Vrátí aktuální čas v milisekundách.
Date.parse()Zanalyzuje řetězcovou reprezentaci data a času a vrátí interní reprezentaci tohoto data v milisekundách.
Datum.UTC()Vrátí vyjádření zadaného data a času UTC v milisekundách.
Objekt Date je datový typ zabudovaný do jazyka JavaScript. Objekty Date se vytvářejí pomocí nové syntaxe Date() představené dříve.
Jakmile je objekt Date vytvořen, můžete použít jeho mnoho metod. Mnoho metod umožňuje získat a nastavit pole pro rok, měsíc, den, hodinu, minutu, sekundu a milisekundu podle místního času nebo času UTC (univerzálního času nebo GMT). Metoda toString() a její varianty převádějí data na lidsky čitelné řetězce.
getTime() a setTime() převádějí počet milisekund, které uplynuly od půlnoci (GMT) 1. ledna 1970, do az vnitřní reprezentace objektu Date. V tomto standardním milisekundovém formátu jsou datum a čas reprezentovány jako jedna jednotka, díky čemuž je datum velmi jednoduché aritmeticky. Standard ECMAScript vyžaduje, aby objekt Date mohl představovat jakékoli datum a čas s přesností na milisekundy v rozmezí 100 milionů dní před a po 1. 1. 1970. Tento rozsah je ±273 785 let, takže hodiny JavaScriptu budou správně fungovat až 275 755 let.
Příklady použití objektu Date
Existuje mnoho známých metod, které vám umožňují pracovat s vytvořeným objektem Date:
// Získá aktuální datum a čas d = new Date(); // Zobrazí datum document.write("Today: " + d.toLocaleDateString() + "."); // Zobrazí čas document.write("Time: "+ d.toLocaleTimeString()); // Den v týdnu var dayOfWeek = d.getDay(); // Dnes je volný den? var víkend = (den v týdnu == 0) || (den v týdnu == 6);
Níže je uveden jednoduchý příklad hodin používajících objekt Date. To používá metodu setTimeout() k aktualizaci hodin každou sekundu:
Funkce timer() ( // Najít prvek h1 v dokumentu h1 = document.getElementsByTagName("h1"); // Nastavení data var date = new Date(); var hours = date.getHours(); var minutes = date .getMinutes (); var sekund = date.getSeconds(); if (hodiny
Označení stránky je poměrně jednoduché a zahrnuje funkci timer() v obslužné rutině události onload() prvku body:
Struny
Řetězec je neměnná, uspořádaná sekvence 16bitových hodnot, z nichž každá obvykle představuje znak Unicode. Řetězce v JavaScriptu jsou datovým typem používaným k reprezentaci textu. Délka řetězce je počet 16bitových hodnot, které obsahuje. Číslování znaků v řetězcích (a prvků v polích) v JavaScriptu začíná od nuly: první 16bitová hodnota je na pozici 0, druhá na pozici 1 atd. Prázdný řetězec je řetězec, jehož délka je 0.
JavaScript nemá speciální typ, který by reprezentoval jeden prvek řetězce. Pro reprezentaci jedné 16bitové hodnoty se jednoduše použije řetězec o délce 1.
Chcete-li do programu JavaScript zahrnout řetězcový literál, jednoduše uzavřete znaky řetězce do párových jednoduchých nebo dvojitých uvozovek (" nebo "). Znaky dvojitých uvozovek mohou být obsaženy v řetězcích oddělených znaky jednoduchých uvozovek a znaky jednoduchých uvozovek mohou být obsaženy v řetězcích oddělených znaky dvojitých uvozovek. Níže jsou uvedeny některé příklady řetězcových literálů:
Var str = ""; // Prázdný řetězec str = "jednoduchý řetězec"; str = "řetězec s "uvozovkami" uvnitř"; str = "Tento řetězcový literál má dva řetězce";
V ECMAScript 3 musí být řetězcové literály zapsány na jeden řádek programu a nelze je rozdělit na dva řádky. V ECMAScript 5 však lze řetězcové literály rozdělit na více řádků tak, že každý řádek kromě posledního ukončíte znakem zpětného lomítka (\). Do řetězcového literálu nebudou zahrnuty žádné znaky zpětného lomítka ani následující znaky pro odřádkování. Chcete-li do řetězcového literálu zahrnout znak nového řádku, musíte použít posloupnost znaků \n (jak je uvedeno výše).
Znak zpětného lomítka (\) má v řetězcích JavaScriptu speciální účel. Spolu se znaky, které za ním následují, označuje znak, který nemůže být v řetězci reprezentován jinými způsoby. Například \n je escape sekvence, označující znak nového řádku.
Dalším příkladem je sekvence \", která představuje znak jednoduché uvozovky. Tato sekvence escape je potřeba k zahrnutí znaku jediné uvozovky do řetězcového literálu uzavřeného v jednoduchých uvozovkách. Nyní je jasné, proč tyto sekvence escape nazýváme – zde znak zpětného lomítka umožňuje ovládat interpretaci znaku jednoduché uvozovky. Místo označení konce řádku jej používáme jako apostrof:
Var str = "\"JavaScript\" je interpretovaný programovací jazyk";
Níže uvedená tabulka uvádí sekvence escape JavaScriptu a znaky, které představují. Dvě únikové sekvence jsou obecné; lze je použít k reprezentaci libovolného znaku zadáním kódu Latin-1 nebo Unicode znaku jako hexadecimálního čísla. Například sekvence \xA9 označuje symbol autorských práv, který má v kódování Latin-1 hexadecimální kód A9. Podobně sekvence escape začínající znaky \u označuje libovolný znak Unicode určený čtyřmi hexadecimálními číslicemi. Například \u03c0 představuje symbol π.
| Subsekvence | Zastoupený symbol |
|---|---|
| \0 | Znak NUL (\u0000) |
| \b | Zpětný pohyb (\u0008) |
| \t | Vodorovná karta (\u0009) |
| \n | Odřádkování (\u000A) |
| \proti | Svislá karta (\u000B) |
| \F | Překlad stránky (\u000C) |
| \r | Vrácení vozíku (\u000D) |
| \" | Dvojité uvozovky (\u0022) |
| \" | Jednoduchá uvozovka (\u0027) |
| \\ | Zpětné lomítko (\u005C) |
| \xZZ | Latin-1 znak určený dvěma hexadecimálními číslicemi ZZ |
| \uxZZZZ | Znak Unicode určený čtyřmi hexadecimálními číslicemi ZZZZ |
Pokud znaku "\" předchází jakýkoli jiný znak, než jsou uvedeny v této tabulce, zpětné lomítko se jednoduše ignoruje (ačkoli budoucí verze mohou samozřejmě definovat nové sekvence escape). Například \# je totéž jako #. A konečně, jak je uvedeno výše, standard ECMAScript 5 umožňuje přidat znak zpětného lomítka před konec řádku ve víceřádkových řetězcových literálech.
Práce se strunami
Jednou z integrovaných funkcí JavaScriptu je schopnost zřetězení řetězců. Pokud je operátor + aplikován na čísla, jsou přidána, a pokud je aplikována na řetězce, jsou kombinována, přičemž druhý řádek je přidán na konec prvního. Například:
Var str = "Dobrý den, " + "svět!"; // Toto vytvoří řetězec Hello, world! // Zřetězení řetězce s proměnnou var name = "Alexander"; str = "Vítejte, " + jméno + "!";
Řetězce v JavaScriptu jsou reprezentovány objektem Tětiva, který má jeden konstruktor, do kterého se předává řetězec. Když je funkce String() volána jako konstruktor (s operátorem new), vrací objekt String obsahující řetězec s nebo řetězcovou reprezentaci s. Konstruktor String() volaný bez operátoru new převede s na hodnotu elementárního řetězce a vrátí převedenou hodnotu:
Nový řetězec(y); // Funkce konstruktoru String(s); // Konverzní funkce
Objekt String má jedinou vlastnost - délka, která vrací počet znaků v řetězci.
V následující tabulce jsou uvedeny metody objektu String:
| Metoda | Popis | Příklad použití |
|---|---|---|
| charAt() | Extrahuje znak na zadané pozici z řetězce. Číslo prvního znaku v řádku je nula. | var str = "Ahoj světe!"; document.write(str.charAt(4)); // Výsledek "o" |
| charCodeAt() | Vrátí kód znaku umístěného na zadané pozici. (Kód Unicode n-tého znaku na řádku je 16bitové celé číslo mezi 0 a 65535.) | var str = "Ahoj světe!"; document.write(str.charCodeAt(4)); // Výsledek 111 - kód znaku "o" |
| spojit() | Zřetězí jednu nebo více hodnot pomocí řetězce. concat() převede všechny své argumenty na řetězce (v případě potřeby) a připojí je na konec řetězce. Vrátí výsledný zřetězený řetězec. | // Získejte jeden řetězec (new String()).concat("Jsme rádi", "vítáme", "vás na našem webu"); |
| indexOf(podřetězec, začátek) | Prohledá řetězec od začátku do konce, aby zjistil, zda obsahuje hledaný podřetězec. Hledání začíná na pozici "start" v řetězci nebo na začátku řetězce, pokud není zadán argument "start". Pokud je podřetězec nalezen, vrátí String.indexOf() pozici prvního znaku prvního výskytu podřetězce v řetězci. Pozice znaků v řádku jsou číslovány od nuly. Pokud podřetězec není v řetězci nalezen, vrátí String.indexOf() hodnotu -1. |
var str = "Ahoj světe!"; if (str.indexOf("svět", 0) != -1) document.write("Ve zdrojovém řetězci byl nalezen podřetězec \"svět\"."); |
| lastIndexOf() | Vyhledá znak nebo podřetězec v řetězci od konce. | var str = "Ahoj světe!"; document.write("Pozice posledního písmene "o" ve zdrojovém řetězci: " + + str.lastIndexOf("o")); // Výsledek 8 |
| localeCompare() | Porovnává řetězce s ohledem na pořadí znaků v národních abecedách. Vrátí číslo označující výsledek porovnání. Pokud je řetězec "menší než" cílový řetězec, localeCompare() vrátí záporné číslo. Pokud je řetězec "větší než" cílový řetězec, metoda vrátí kladné číslo. Pokud jsou řetězce identické nebo nerozeznatelné podle regionálních konvencí řazení, metoda vrátí 0. Když jsou operátory aplikovány na řetězce, porovnání se provádějí pouze podle kódů Unicode těchto znaků; Pořadí řazení aktuálního regionu se nebere v úvahu. Takto provedené řazení není vždy správné. Standard ECMAScript nespecifikuje, jak by se měla provádět srovnání specifická pro region; jednoduše uvádí, že funkce sleduje pořadí řazení definované operačním systémem. |
var str1 = "Řetězec1"; var str2 = "Řetězec2"; if (str1.localeCompare(str2) != 0) document.write("Řetězce nejsou identické"); |
| zápas() | Provádí vyhledávání vzoru pomocí regulárního výrazu. | var str = "1 plus 2 se rovná 3".match(/\d+/g); // Vrátí pole ("1", "2", "3") |
| nahradit() | Metoda replace() provádí operaci hledání a nahrazení řetězce. Vyhledá v řetězci jeden nebo více podřetězců, které odpovídají regulárnímu výrazu, a nahradí je. Pokud je v regulárním výrazu zadán globální atribut "g", nahradí funkce replace() všechny nalezené podřetězce. Jinak metoda nahradí pouze první nalezený podřetězec. Standard ECMAScript v3 specifikuje, že druhým argumentem metody replace() může být spíše funkce než řetězec. V tomto případě bude funkce volána pro každou nalezenou shodu a jako náhradní text se použije řetězec, který vrátí. |
var str = "javascript je interpretovaný programovací jazyk."; // Zajistěte správná velká a malá písmena ve slově "JavaScript" str = str.replace(/JavaScript/i, "JavaScript"); |
| Vyhledávání() | Metoda search() hledá podřetězec v řetězci, který odpovídá regulárnímu výrazu regulárního výrazu, a vrací pozici prvního znaku nalezeného podřetězce nebo -1, pokud není nalezena žádná shoda. Metoda neprovádí globální vyhledávání, ignoruje příznak "g". Také ignoruje vlastnost regexp.lastIndex a vždy vyhledává od začátku řetězce, takže vždy vrací pozici první nalezené shody v řetězci. |
var str = "JavaScript je interpretovaný programovací jazyk."; i = str.search("jazyk"); // Výsledek 30 (pozice slova "jazyk" ve zdrojovém řetězci) |
| plátek() | Metoda slice() vrací řetězec obsahující fragment nebo podřetězec řetězce, ale nemodifikuje řetězec. První argument je index v řádku, na kterém by měl fragment začínat. Pokud je tento argument záporný, označuje pozici měřenou od konce řetězce. To znamená, že -1 odpovídá poslednímu znaku, -2 druhému od konce atd. Druhý argument je znakový index zdrojového řetězce bezprostředně po konci extrahovaného fragmentu. Pokud není zadán, fragment obsahuje všechny znaky od začátku do konce řádku. Pokud je tento argument záporný, označuje pozici počítanou od konce řádku. |
var str = "abvgdezzik"; str1 = str.slice(0,4); // Návrat "abvg" str2 = str.slice(2,4); // Návrat "vg" str3 = str.slice(4); // Návrat "dezzik" str4 = str.slice(3,-1); // Návrat "kde" str5 = str.slice(3,-2); // Návrat "kde" str6 = str.slice(-4,-2); // Návrat "zhz" |
| rozdělit() | Rozdělí řetězec na pole řetězců v zadaném oddělovacím řetězci. Metoda split() vytvoří a vrátí pole podřetězců zadaného řetězce a velikost vráceného pole nepřekročí zadaný limit (předaný ve druhém argumentu). Tyto podřetězce se vytvářejí vyhledáním textu v řetězci, který odpovídá oddělovači (prvnímu argumentu) od začátku do konce, a rozdělením řetězce před a za nalezeným textem. Ohraničující text není zahrnut v žádném z vrácených řádků. |
// Metoda split() je nejužitečnější při práci // s vysoce strukturovanými řetězci var str = "1:2:3:4:5"; str.split(":"); // Návrat ["1","2","3","4","5"] str = "a||b||c"; str.split("||"); // Return ["a","b","c"] // Chcete-li rozdělit řetězec na pole znaků, // vezměte prázdný řetězec jako oddělovač str = "hello"; str.split(""); // Návrat ["h","e","l","l","o"] str.split("",3); // Návrat ["h","e","l"] |
| substr() | Metoda substr() extrahuje a vrátí podřetězec řetězce, ale nemodifikuje řetězec. Všimněte si, že metoda substr() specifikuje požadovaný podřetězec pomocí pozice a délky znaku. To poskytuje pohodlnou alternativu k metodám String.substring() a String.splice(), ve kterých je podřetězec specifikován dvěma pozicemi znaků. Je však třeba poznamenat, že metoda není standardizována v ECMAScriptu, a proto je považována za zastaralou. | var str = "abvgdezzik"; str = str.substr(2,5); // Výsledek "kde" |
| podřetězec() | Metoda String.substring() vrací podřetězec obsahující znaky mezi pozicemi od (první argument) do (druhý argument). Znak na pozici "od" je zahrnut v podřetězci, ale znak na pozici "do" není zahrnut. | var str = "abvgdezzik"; str = str.substring(2,7); // Výsledek "kde" |
| toLowerCase() | Vrátí kopii řetězce se všemi znaky převedenými na malá písmena. | var str = "JavaScript"; str = str.toLowerCase(); // Výsledek "javascript" |
| toString() | Vrátí hodnotu primitivního řetězce. Volání této metody je potřeba jen zřídka. Výjimka TypeError je vyvolána, pokud je metoda volána na objektu, který není objektem String. | |
| toUpperCase() | Vrátí kopii řetězce se všemi znaky převedenými na velká písmena. | var str = "JavaScript"; str = str.toUpperCase(); // Výsledek "JAVASCRIPT" |
| trim() | Vrátí kopii řetězce s odstraněnými všemi úvodními a koncovými mezerami. | |
| hodnota() | Vrací hodnotu primitivního řetězce (podobně jako toString(), používá se zřídka). |
Od počátků JavaScriptu definovala třída String několik metod, které vracejí řetězec upravený přidáním značek HTML. Tyto metody nebyly nikdy standardizovány v ECMAScript, ale umožňují dynamicky generovat HTML značky ve skriptech JavaScript na straně klienta i serveru. Pokud jste ochotni použít vlastní techniky, můžete vytvořit značku HTML pro hypertextový odkaz zeleným tučným písmem následovně:
Protože tyto metody nejsou standardizované, neexistují pro ně žádné samostatné referenční články.
Booleovské hodnoty
Logická hodnota říká, zda je něco pravdivé nebo nepravdivé. Datový typ Boolean má pouze dvě platné logické hodnoty. Tyto dvě hodnoty jsou reprezentovány literály true a false.
Booleovské hodnoty obvykle představují výsledek srovnávacích operací prováděných v programech JavaScript. Například:
Tento výraz testuje, zda je hodnota proměnné a rovna číslu 4. Pokud ano, výsledkem tohoto porovnání bude booleovská hodnota true. Pokud hodnota a není 4, bude výsledek srovnání nepravdivý.
Booleovské hodnoty se běžně používají v řídicích konstrukcích JavaScriptu. Například příkaz if/else v JavaScriptu provede jednu akci, pokud je logická hodnota pravdivá, a další akci, pokud je nepravda. Porovnání, které vytváří booleovskou hodnotu, je obvykle přímo kombinováno s instrukcí, ve které je použita. Výsledek vypadá takto:
If (a == 4) ( // ... ) else ( // ... )
Jakoukoli hodnotu v JavaScriptu lze převést na booleovskou hodnotu. Následující hodnoty mají za následek booleovskou hodnotu (a chovají se jako) false:
Undefined null 0 -0 NaN "" // prázdný řetězec
Všechny ostatní hodnoty, včetně všech objektů (a polí), mají při převodu za následek (a chovají se jako) true. Hodnota false a šest hodnot, které jsou na tuto hodnotu převedeny, se někdy nazývají false a všechny ostatní se nazývají true. V jakémkoli kontextu, kde interpret JavaScriptu očekává, že obdrží booleovskou hodnotu, jsou hodnoty false interpretovány jako nepravdivé a hodnoty true jsou interpretovány jako pravdivé.
Booleovské hodnoty mají metodu toString(), kterou lze použít k převodu těchto hodnot na řetězce „true“ nebo „false“, ale nemají žádné další užitečné metody.
Nulové a nedefinované hodnoty
Klíčové slovo null v JavaScriptu má speciální účel a obvykle se používá k označení absence hodnoty. Operátor typeof pro hodnotu null vrací řetězec "object", což znamená, že hodnota null je speciální "prázdný" objekt. V praxi je však null obvykle považován za jediný člen svého vlastního typu a lze jej použít k označení nepřítomnosti hodnoty, jako je číslo, řetězec nebo objekt. Většina ostatních programovacích jazyků má v JavaScriptu hodnoty podobné null: můžete je znát jako null nebo nil.
JavaScript má další hodnotu, která označuje absenci hodnoty. Nedefinovaná hodnota označující úplnou absenci jakékoli hodnoty. Je vrácena při přístupu k proměnné, které nikdy nebyla přiřazena hodnota, neexistující vlastnost objektu nebo prvek pole. Nedefinovaný je navíc vrácen funkcemi, které nemají návratovou hodnotu, a je přiřazen k parametrům funkce pro argumenty, které nebyly předány volání.
Identifikátor undefined je název předdefinované globální proměnné (ne klíčového slova jako null), která je inicializována hodnotou undefined. V ECMAScript 3 je undefined proměnná pro čtení/zápis, které lze přiřadit jakoukoli jinou hodnotu. Tento problém byl opraven v ECMAScript 5 a v implementacích JavaScriptu, které se řídí tímto standardem, je nedefinovaná proměnná pouze pro čtení. Operátor typeof na nedefinované hodnotě vrací řetězec "undefined", což znamená, že hodnota je jediným členem speciálního typu.
Navzdory těmto rozdílům značí null i undefined nepřítomnost hodnoty a často se používají zaměnitelně. Operátor rovnosti == je považuje za rovné. (K jejich rozlišení ve vašem programu můžete použít operátor identity ===.) Obě tyto hodnoty jsou nepravdivé – v booleovském kontextu jsou interpretovány jako nepravdivé. Null ani undefined nemají žádné vlastnosti ani metody. V praxi pokus o použití. nebo pro přístup k vlastnosti nebo metodě těchto hodnot vyvolá TypeError.
Nedefinovaná hodnota může být považována za známku neočekávané nebo chybné absence hodnoty a null za známku normální nebo zcela očekávané nepřítomnosti hodnoty.. Pokud váš program potřebuje přiřadit jednu z těchto hodnot proměnné nebo vlastnosti nebo předat jednu z těchto hodnot funkci, je téměř vždy vhodnější použít null.
Neměnné jednoduché hodnoty a odkazy na měnitelné objekty
Mezi jednoduchými hodnotami (undefined, null, booleans, čísla a řetězce) a objekty (včetně polí a funkcí) v JavaScriptu existují zásadní rozdíly. Jednoduché hodnoty jsou neměnné: jednoduchou hodnotu nelze změnit. To je zřejmé u čísel a booleanů – nemá smysl měnit hodnotu čísla.
U strun je to však méně zřejmé. Protože řetězce jsou pole znaků, bylo by přirozené očekávat, že bude možné změnit znaky na té či oné pozici v řetězci. JavaScript vám to ve skutečnosti neumožňuje a všechny metody řetězců, které vypadají, že vracejí upravený řetězec, ve skutečnosti vracejí novou hodnotu řetězce. Například:
Var str = "jednoduchý řetězec"; str.slice(8,14); console.log(str); // Zobrazí "jednoduchý řetězec" // Chcete-li explicitně změnit řetězec, musíte použít přiřazení str = str.slice(8,14); console.log(str); // Zobrazit "řetězec"
Kromě toho se hodnoty jednoduchých typů porovnávají podle hodnoty: dvě veličiny jsou považovány za stejné, pokud mají stejnou hodnotu. U čísel, booleanů, null a undefined se to zdá zřejmé: neexistuje žádný jiný způsob, jak je porovnat. U řetězců se však toto tvrzení nezdá tak zřejmé. Při porovnávání dvou hodnot řetězců je JavaScript považuje za stejné tehdy a pouze tehdy, jsou-li stejně dlouhé a obsahují stejné znaky na odpovídajících pozicích.
Objekty se liší od jednoduchých typů. Za prvé, jsou proměnlivé - jejich hodnoty lze změnit:
Var o = (x:1); // Počáteční hodnota objektu o.x = 2; // Změna změnou hodnoty vlastnosti o.y = 3; // Změna přidáním nové vlastnosti var a = ; // Pole jsou také proměnlivé objekty a = 0; // Změňte hodnotu prvního prvku pole a = 4; // Přidání nového prvku (index 3 odpovídá čtvrté pozici v poli)
Objekty nejsou porovnávány podle hodnoty: dva objekty nejsou považovány za rovnocenné, i když mají stejnou sadu vlastností se stejnými hodnotami. A dvě pole se nepovažují za rovná, i když mají stejnou sadu prvků ve stejném pořadí.
Aby se zdůraznil rozdíl od jednoduchých typů JavaScript, objekty se někdy nazývají referenční typy. Podle této terminologie jsou hodnoty objektů odkazy a lze říci, že objekty jsou porovnávány odkazem: hodnoty dvou objektů jsou považovány za stejné tehdy a pouze tehdy, pokud odkazují na stejný objekt v paměti.
Var a = ; // Proměnná a odkazuje na prázdné pole. var b = a; // Nyní b odkazuje na stejné pole. b = 1; // Upravte pole pomocí odkazu v proměnné b. console.log(a === b); // Vrátí "true" console.log("a = " + a); // Změna objektu b změní objekt a
Jak naznačuje výše uvedený příklad, přiřazení objektu (nebo pole) k proměnné ve skutečnosti přiřadí odkaz: nevytvoří novou kopii objektu. Pokud váš program potřebuje vytvořit novou kopii objektu nebo pole, budete muset explicitně zkopírovat vlastnosti objektu nebo prvky pole.
Jak počítačové programy pracují, manipulují s hodnotami, jako je číslo 7 nebo text "HelloWorld!" Každá hodnota, která může být reprezentována a zpracována v programovacím jazyce, patří ke specifickému datovému typu. Datový typ definuje typy hodnot, které se používají v programovacím jazyce.
V JavaScriptu lze datové typy rozdělit do dvou kategorií: jednoduché (také nazývané primitivní) typy a složené (také nazývané referenční nebo objektové).
- tětiva- textové řetězce (obvykle se jim říká jednoduše řetězce)
- číslo- čísla
- booleovský- logické (booleovské) hodnoty
K jednoduchým typům patří také dvě speciální hodnoty:
- nula
- nedefinováno
Mezi složené datové typy patří:
- funkce- funkce
- pole- pole
- objekt- předměty
Rozdíl mezi jednoduchými a složenými typy
Rozdíl mezi jednoduchými a složenými typy nastává při kopírování hodnot.
Když je proměnné (parametr funkce, vlastnost nebo prvek pole) přiřazena hodnota jednoduchého typu, například číslo, zapíše se do proměnné samotná hodnota (v tomto případě číslo). Když přiřadíte jednu proměnnou (s hodnotou jednoduchého typu) jiné proměnné, hodnota se zkopíruje. Výsledkem je, že každá proměnná má svou vlastní kopii hodnoty a změny v jedné z proměnných neovlivňují hodnotu té druhé:
Var num1 = 10; var num2 = num1; // Zkopírujte hodnotu alert("num1: " + num1 + // 10 "\nnum2: " + num2); // 10 num1 = 15; // Změňte hodnotu alert("num1: " + num1 + // 15 "\nnum2: " + num2); // 10
Když je proměnné (parametr funkce, vlastnost nebo prvek pole) přiřazena hodnota komplexního typu, jako je objekt, zapíše se do proměnné odkaz na hodnotu (v tomto případě odkaz na objekt). Když přiřadíte jednu proměnnou (jejíž hodnota obsahuje odkaz na složenou hodnotu) k jiné proměnné, odkaz na složenou hodnotu se zkopíruje. Výsledkem je, že obě proměnné odkazují na stejnou složenou hodnotu a jakékoli změny provedené v hodnotě jedné z proměnných ovlivní druhou proměnnou:
Var o1 = (x:10); var o2 = o1; // Zkopírujte odkaz na objekt alert("o1.x: " + o1.x + // 10 "\no2.x: " + o2.x); // 10 o2.x = 15; // Změna hodnoty alert("o1.x: " + o1.x + // 15 "\no2.x: " + o2.x); // 15
nulové a nedefinované
Typ null má pouze jednu hodnotu - null. Hodnota null je odkaz na prázdný objekt a má speciální účel – obvykle se používá k inicializaci proměnné, ke které bude objekt později přiřazen.
Nedefinovaný typ má pouze jednu hodnotu - nedefinováno. Hodnota undefined znamená, že pro začátek neexistuje žádná hodnota. Nedefinovanou hodnotu můžete získat následovně:
- Při přístupu k proměnné, která byla deklarována, ale nebyla inicializována.
- Při přístupu k neexistující vlastnosti objektu.
- Při přístupu k neexistujícímu prvku pole.
- Při přístupu k parametrům funkce, které nebyly inicializovány argumenty při volání funkce.
- Vráceno funkcemi, které nemají návratovou hodnotu.
- Vráceno operátorem typeof, pokud je operand neexistující proměnnou.
Identifikátor undefined je název předdefinované globální proměnné, která je inicializována hodnotou undefined. Nedefinovaná proměnná je pouze pro čtení.
Zabalit předměty
Kdykoli se program pokusí o přístup k vlastnosti nebo metodě hodnoty primitivního typu, interpret dočasně převede primitivní hodnotu na objekt příslušného typu. Volají se dočasné objekty, do kterých se převádějí hodnoty primitivního typu obalové předměty. Tyto objekty používá interpret pro přístup k požadované vlastnosti nebo metodě. Ihned po zavolání vlastnosti nebo metody je objekt wrapper zničen. Objekty Wrapper se vytvářejí pouze pro hodnoty typu number , string a boolean . Hodnoty null a undefined nemají obalové objekty: jakýkoli pokus o přístup k vlastnostem těchto hodnot vygeneruje chybu.
Pokud se pokusíte nastavit novou vlastnost pro objekt wrapper, nová vlastnost se neuloží, protože objekt wrapper bude zničen ihned poté, co dokončí svou práci:
Var str = "text"; str.len = 5; // Nastavení vlastnosti s hodnotou. Ihned poté je objekt zničen alert(str.len); // nedefinováno, protože předchozí objekt obalu již byl zničen
Objekty Wrapper lze jednoduše považovat za pohodlnou implementaci pro práci s hodnotami primitivního typu a vůbec o nich nepřemýšlet.
OS
