Syntaxe JavaScriptu - JavaScript syntax

Syntax z JavaScriptu je soubor pravidel, která definují správně strukturovaného programu JavaScript.

Následující příklady využívají funkci protokolu objektu konzoly přítomné ve většině prohlížečů pro standardní textový výstup .

Standardní knihovna JavaScriptu postrádá oficiální standardní funkci výstupu textu (s výjimkou document.write). Vzhledem k tomu, že JavaScript se používá hlavně pro skriptování na straně klienta v moderních webových prohlížečích a že téměř všechny webové prohlížeče poskytují funkci upozornění, upozornění lze také použít, ale není běžně používáno.

Původy

Brendan Eich shrnul původ syntaxe v prvním odstavci specifikace JavaScript 1.1 takto:

JavaScript si půjčuje většinu své syntaxe z Javy , ale také dědí od Awk a Perl , s určitým nepřímým vlivem od Self v jeho systému prototypů objektů.

Základy

Citlivost na malá a velká písmena

JavaScript rozlišuje velká a malá písmena . Je běžné, že na začátek názvu konstruktoru s kapitalizovaných dopisu, a název funkce nebo proměnnou s malým písmenem.

Příklad:

var a=5;
console.log(a); // 5
console.log(A); // throws a ReferenceError: A is not defined

Prázdné znaky a středníky

Na rozdíl od C může mezery ve zdroji JavaScriptu přímo ovlivnit sémantiku . Středníky končí příkazy v JavaScriptu. Kvůli automatickému vkládání středníků (ASI) budou některá prohlášení, která jsou dobře formulována při analýze nového řádku, považována za úplná, jako kdyby středník byl vložen těsně před nový řádek. Některé úřady doporučují dodávat středníky ukončující příkazy explicitně, protože to může snížit nechtěné efekty automatického vkládání středníků.

Existují dva problémy: pět tokenů může buď začít příkaz, nebo být rozšířením úplného příkazu; a pět omezených produkcí, kde na určitých pozicích nejsou povoleny konce řádků, což potenciálně vede k nesprávné analýze.

Pět problematických žetonů je otevřená závorka " ( ", otevřená závorka " [ ", lomítko " / ", plus " + " a mínus " - ". Z nich je otevřená závorka běžná ve vzorci výrazů s okamžitým vyvoláním funkce a někdy se objeví otevřená závorka, zatímco jiné jsou poměrně vzácné. Příklad uvedený ve specifikaci je:

a = b + c
(d + e).foo()

// Treated as:
//  a = b + c(d + e).foo();

s návrhem, aby předchozí prohlášení bylo ukončeno středníkem.

Někteří navrhují namísto používání předních středníkem na řádky začínající ‚ ( ‘ nebo ‚ [ ‘, takže linie není náhodou spojen s předchozím. Toto je známé jako obranný středník , a je vhodné zejména, protože kód může se jinak nejednoznačné, když je přeuspořádáno. Například:

a = b + c
;(d + e).foo()

// Treated as:
//  a = b + c;
//  (d + e).foo();

Počáteční středníky se také někdy používají na začátku knihoven JavaScript, v případě, že jsou připojeny k jiné knihovně, která vynechává koncový středník, protože to může mít za následek nejednoznačnost počátečního příkazu.

Pět omezených produkcí je návrat , hod , přestávka , pokračování a následné zvýšení/snížení. V každém případě vložení středníků problém nevyřeší, ale zpřehlední syntaktickou syntaxi, což chybu snáze odhalí. return and throw take an optional value, while break and continue take an optional label. Ve všech případech se doporučuje ponechat hodnotu nebo štítek na stejném řádku jako příkaz. To se nejčastěji zobrazuje v příkazu return, kde je možné vrátit literál velkého objektu, který může být omylem umístěn počínaje novým řádkem. U dodatečného přírůstku/úbytku existuje potenciální nejednoznačnost s předběžným přírůstkem/úbytkem a opět se doporučuje ponechat je na stejném řádku.

return
a + b;

// Returns undefined. Treated as:
//   return;
//   a + b;
// Should be written as:
//   return a + b;

Komentáře

Syntaxe komentářů je stejná jako v C ++ , Swiftu a mnoha dalších jazycích.

// a short, one-line comment

/* this is a long, multi-line comment
  about my script. May it one day
  be great. */

/* Comments /* may not be nested */ Syntax error */

Proměnné

Proměnné ve standardním JavaScriptu nemají připojený žádný typ , takže libovolnou hodnotu (každá hodnota má typ) lze uložit do libovolné proměnné. Počínaje ES6 , 6. verzí jazyka, mohly být proměnné deklarovány varpro proměnné s rozsahem funkcí a letnebo constkteré jsou pro proměnné na úrovni bloku . Před ES6 mohly být proměnné deklarovány pouze varpříkazem. Hodnoty přiřazené proměnným deklarovaným pomocí constnelze změnit, ale jeho vlastnosti ano. Identifikátor proměnné musí začínat písmenem, podtržítkem ( _ ) nebo znakem dolaru ( $ ), zatímco následující znaky mohou být také číslice ( 0-9 ). JavaScript rozlišuje velká a malá písmena, takže velká písmena „A“ až „Z“ se liší od malých písmen „a“ až „z“.

Počínaje jazykem JavaScript 1.5 lze v identifikátorech použít písmena ISO 8859-1 nebo Unicode (nebo \ uXXXX Unicode escape sekvence). V určitých implementacích JavaScriptu lze zavináč (@) použít v identifikátoru, ale to je v rozporu se specifikacemi a není podporováno v novějších implementacích.

Rozsah a zvedání

Proměnné deklarované pomocí varjsou lexikálně vymezeny na úrovni funkce , zatímco ty s rozsahem na úrovni blokulet nebo constmají . Deklarace jsou zpracovány před spuštěním jakéhokoli kódu. Toto se označuje jako zdvihací a je ekvivalentní proměnným, které jsoudeklarovány vpředv horní části funkce nebo bloku.

S var, leta constprohlášení, kromě prohlášení je zvednuta; úkoly nejsou zvednuty. Tedy příkaz uprostřed funkce je ekvivalentní deklaračnímu příkazu v horní části funkce a příkazu přiřazení v tomto bodě uprostřed funkce. To znamená, že k hodnotám nelze přistupovat dříve, než jsou deklarovány; dopředná reference není možná. S hodnotou proměnná je , dokud se inicializuje. Proměnné deklarované s nebo k nim nelze přistupovat, dokud není inicializováno, takže odkazování na proměnnou způsobí chybu. var x = 1var xx = 1varundefinedletconst

Deklarace funkcí, které deklarují proměnnou a přiřazují jí funkci, jsou podobné příkazům proměnných, ale kromě zvednutí deklarace také zvedají přiřazení - jako by se celý příkaz objevil v horní části obsahující funkce - a tím dopředná reference je také možná: umístění příkazu funkce v rámci uzavírající funkce je irelevantní. Toto je odlišné od funkce výraz je přiřazen k proměnné v var, letnebo constprohlášení.

Takže např.

var func = function() { .. } // declaration is hoisted only
function func() { .. } // declaration and assignment are hoisted

Rozsah bloku lze vytvořit zabalením celého bloku do funkce a následným spuštěním-toto je známé jako vzorec výrazu funkce s okamžitým vyvoláním- nebo vyhlášením proměnné pomocí letklíčového slova.

Prohlášení a postoupení

Proměnné deklarované mimo obor jsou v globálu . Pokud je proměnná deklarována ve vyšším rozsahu, lze k ní přistupovat podřízenými obory.

Když se JavaScript pokusí vyřešit identifikátor, vypadá v místním rozsahu. Pokud tento identifikátor není nalezen, vypadá v dalším vnějším oboru atd. V řetězci oboru, dokud nedosáhne globálního rozsahu, kde jsou umístěny globální proměnné. Pokud to stále není nalezeno, JavaScript vyvolá ReferenceErrorvýjimku.

Při přiřazování identifikátoru JavaScript prochází přesně stejným procesem, aby získal tento identifikátor, kromě toho, že pokud není nalezen v globálním oboru , vytvoří „proměnnou“ v oboru, kde byl vytvořen. V důsledku toho bude nikdy deklarovaná proměnná globální, pokud bude přiřazena. Deklarace proměnné (s klíčovým slovem var) v globálním rozsahu (tj. Mimo jakékoli tělo funkce (nebo blok v případě let/const)), přiřazení nikdy deklarovaného identifikátoru nebo přidání vlastnosti ke globálnímu objektu (obvykle okno ) bude také vytvořit novou globální proměnnou.

Striktní režim JavaScriptu zakazuje přiřazení nedeklarované proměnné, která se vyhýbá znečištění globálního oboru názvů.

Příklady

Zde je několik příkladů deklarací proměnných a rozsahu:

var x1 = 0; // A global variable, because it is not in any function
let x2 = 0; // Also global, this time because it is not in any block

function f() {
  var z = 'foxes', r = 'birds'; // 2 local variables
  m = 'fish'; // global, because it wasn't declared anywhere before

  function child() {
    var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.
    z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.
  }

  twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here
  var twenty;

  child();
  return x1 + x2; // We can use x1 and x2 here, because they are global
}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

for (let i = 0; i < 10; i++) console.log(i);
console.log(i); // throws a ReferenceError: i is not defined

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

const pi; // throws a SyntaxError: Missing initializer in const declaration

Primitivní datové typy

Jazyk JavaScript poskytuje šest primitivních datových typů :

• Nedefinováno
• Číslo
• BigInt
• Tětiva
• Boolean
• Symbol

Některé primitivní datové typy také poskytují sadu pojmenovaných hodnot, které představují rozsahy hranic typů. Tyto pojmenované hodnoty jsou popsány v příslušných částech níže.

Nedefinováno

Hodnota „nedefinovaný“ je přiřazena všem neinicializované proměnné , a také se vrací při zjišťování vlastností objektů, které neexistují. V logickém kontextu je nedefinovaná hodnota považována za falešnou hodnotu.

Poznámka: undefined je považován za skutečný primitivní typ. Pokud není explicitně převedeno, může se nedefinovaná hodnota chovat neočekávaně ve srovnání s jinými typy, které jsou v logickém kontextu vyhodnoceny jako nepravdivé.

var test;                         // variable declared, but not defined, ...
                                  // ... set to value of undefined
var testObj = {};
console.log(test);                // test variable exists, but value not ...
                                  // ... defined, displays undefined
console.log(testObj.myProp);      // testObj exists, property does not, ...
                                  // ... displays undefined
console.log(undefined == null);   // unenforced type during check, displays true
console.log(undefined === null);  // enforce type during check, displays false

Poznámka: Pro nedefinovaný neexistuje žádný vestavěný doslovný jazyk. Tedy není spolehlivý způsob, jak zkontrolovat, zda je proměnná nedefinovaná, protože v některých verzích před ECMAScript 5, to je legální pro někoho psát . Robustnějším přístupem je porovnání použití . (x === undefined)var undefined = "I'm defined now";(typeof x === 'undefined')

Funkce, jako je tato, nebudou fungovat podle očekávání:

function isUndefined(x) { var u; return x === u; }             // like this...
function isUndefined(x) { return x === void 0; }               // ... or that second one
function isUndefined(x) { return (typeof x) === "undefined"; } // ... or that third one

Zde volání isUndefined(my_var)vyvolá ReferenceError, pokud my_var je neznámý identifikátor, zatímco ne. typeof my_var === 'undefined'

Číslo

Čísla jsou reprezentována binárně jako zdvojnásobení s plovoucí desetinnou čárkou IEEE-754 . Ačkoli tento formát poskytuje přesnost téměř 16 platných číslic , nemůže vždy přesně představovat reálná čísla, včetně zlomků.

To se stává problémem při porovnávání nebo formátování čísel. Například:

console.log(0.2 + 0.1 === 0.3); // displays false
console.log(0.94 - 0.01);       // displays 0.9299999999999999

V důsledku toho by rutina, jako je metoda toFixed (), měla být použita k zaokrouhlování čísel, kdykoli jsou formátována pro výstup .

Čísla mohou být uvedena v kterémkoli z těchto zápisů:

345;    // an "integer", although there is only one numeric type in JavaScript
34.5;   // a floating-point number
3.45e2; // another floating-point, equivalent to 345
0b1011; // a binary integer equal to 11
0o377;   // an octal integer equal to 255
0xFF;   // a hexadecimal integer equal to 255, digits represented by the ...
        // ... letters A-F may be upper or lowercase

V ES2021 je také zaveden numerický oddělovač _ (podtržítko):

// Note: Wikipedia syntax doesn't support numeric separators yet
1_000_000_000;    // Used with big numbers
1_000_000.5;      // Support with decimals
1_000e1_000;      // Support with exponents

// Support with binary, octals and hex
0b0000_0000_0101_1011;
0o0001_3520_0237_1327;
0xFFFF_FFFF_FFFF_FFFE;

// But you can't use them next to a non-digit number part, or at the start or end
_12; // Variable is not defined (the underscore makes it a variable identifier)
12_; // Syntax error (cannot be at the end of numbers)
12_.0; // Syntax error (doesn't make sense to put a separator next to the decimal point)
12._0; // Syntax error
12e_6; // Syntax error (next to "e", a non-digit. Doesn't make sense to put a separator at the start)
1000____0000; // Syntax error (next to "_", a non-digit. Only 1 separator at a time is allowed

Rozsah +∞ , −∞ a NaN (není číslo) typu čísla lze získat dvěma výrazy programu:

Infinity; // positive infinity (negative obtained with -Infinity for instance)
NaN;      // The Not-A-Number value, also returned as a failure in ...
          // ... string-to-number conversions

Infinity a NaN jsou čísla:

typeof Infinity;   // returns "number"
typeof NaN;        // returns "number"

Tyto tři speciální hodnoty odpovídají a chovají se tak, jak je popisuje IEEE-754 .

K provedení explicitní číselné převody lze použít konstruktor Number (používá se jako funkce) nebo unární + nebo -:

var myString = "123.456";
var myNumber1 = Number(myString);
var myNumber2 = +myString;

Když se používá jako konstruktor, vytvoří se objekt numerického obalu (i když je málo použitelný):

myNumericWrapper = new Number(123.456);

NaN se však sama sobě nerovná:

const nan = NaN;
console.log(NaN == NaN);        // false
console.log(NaN === NaN);       // false
console.log(NaN !== NaN);       // true
console.log(nan !== nan);       // true

// You can use the isNaN methods to check for NaN
console.log(isNaN("converted to NaN"));     // true
console.log(isNaN(NaN));                    // true
console.log(Number.isNaN("not converted")); // false
console.log(Number.isNaN(NaN));             // true

BigInt

BigInts lze použít pro libovolně velká celá čísla . Zvláště celá čísla větší než 2 ⁵³ - 1, což je největší číslo, které JavaScript může spolehlivě reprezentovat s primitivem Number a reprezentovaným konstantou Number.MAX_SAFE_INTEGER.

Při dělení BigInts jsou výsledky zkráceny .

Tětiva

Řetězec v JavaScriptu je posloupnost znaků. V JavaScriptu lze řetězce vytvářet přímo (jako literály) umístěním řady znaků mezi uvozovky s dvojitým (") nebo jednoduchým (') textem. Takové řetězce musí být zapsány na jeden řádek, ale mohou obsahovat znaky nového řádku s únikem (například \ n). Standard JavaScriptu umožňuje znaku backquote (`, aka hrobový přízvuk nebo backtick) citovat víceřádkové doslovné řetězce, ale to je od roku 2016 podporováno pouze v určitých prohlížečích: Firefox a Chrome, ale ne Internet Explorer 11.

var greeting = "Hello, World!";
var anotherGreeting = 'Greetings, people of Earth.';

K jednotlivým znakům v řetězci lze přistupovat pomocí metody charAt (poskytuje String.prototype ). Toto je upřednostňovaný způsob při přístupu k jednotlivým znakům v řetězci, protože funguje také v nemoderních prohlížečích:

var h = greeting.charAt(0);

V moderních prohlížečích lze přistupovat k jednotlivým znakům v řetězci (jako řetězce pouze s jedním znakem) pomocí stejného zápisu jako pole:

var h = greeting[0];

Řetězce JavaScriptu jsou však neměnné :

greeting[0] = "H"; // Fails.

Použití operátoru rovnosti ("==") na dva řetězce vrátí hodnotu true, pokud mají řetězce stejný obsah, což znamená: stejné délky a obsahující stejnou posloupnost znaků (pro abecedy je velký případ). Tím pádem:

var x = "World";
var compare1 = ("Hello, " +x == "Hello, World"); // Here compare1 contains true.
var compare2 = ("Hello, " +x == "hello, World"); // Here compare2 contains  ...
                                                 // ... false since the ...
                                                 // ... first characters ...
                                                 // ... of both operands ...
                                                 // ... are not of the same case.

Citáty stejného typu nelze vnořovat, pokud nejsou uvozeny .

var x = '"Hello, World!" he said.'; // Just fine.
var x = ""Hello, World!" he said."; //  Not good.
var x = "\"Hello, World!\" he said."; // Works by escaping " with \"

Konstruktor String vytvoří objekt řetězce (objekt obalující řetězec):

var greeting = new String("Hello, World!");

Tyto objekty mají metodu valueOf, která vrací primitivní řetězec zabalený v nich:

var s = new String("Hello !");
typeof s; // Is 'object'.
typeof s.valueOf(); // Is 'string'.

Rovnost mezi dvěma objekty String se nechová jako u řetězcových primitiv:

var s1 = new String("Hello !");
var s2 = new String("Hello !");
s1 == s2; // Is false, because they are two distinct objects.
s1.valueOf() == s2.valueOf(); // Is true.

Boolean

JavaScript poskytuje booleovský datový typ s true a false literály. Typeof Operátor vrátí řetězec „boolean“ pro tyto primitivní typy . Při použití v logickém kontextu vyhodnotí 0 , -0 , null , NaN , undefined a prázdný řetězec ( "" ) jako nepravdivé kvůli automatickému nátlaku typu . Všechny ostatní hodnoty ( doplněk předchozího seznamu) jsou vyhodnoceny jako pravdivé , včetně řetězců „0“ , „false“ a jakéhokoli objektu.

Převod typu

Automatickému nátlaku na typ pomocí operátorů porovnání rovnosti ( ==a !=) se lze vyhnout použitím operátorů porovnávání typu ( ===a !==).

Je -li požadována konverze typů, JavaScript převádí logické , číselné , řetězcové nebo objektové operandy následujícím způsobem:

Číslo a řetězec

Řetězec je převeden na číselnou hodnotu. JavaScript se pokouší převést řetězcový číselný literál na hodnotu typu Number. Nejprve je z řetězcového číselného literálu odvozena matematická hodnota. Dále je tato hodnota zaokrouhlena na nejbližší hodnotu typu čísla.

Boolean

Pokud je jeden z operandů logický, booleovský operand je převeden na 1, pokud je pravdivý , nebo na 0, pokud je nepravdivý .

Objekt

Pokud je objekt porovnáván s číslem nebo řetězcem, JavaScript se pokusí vrátit výchozí hodnotu pro objekt. Objekt je převeden na primitivní hodnotu String nebo Number pomocí metod .valueOf () nebo .toString () objektu. Pokud se to nezdaří, vygeneruje se chyba za běhu.

Douglas Crockford obhajuje termíny „ pravdivé “ a „ falešné “, aby popsal, jak se hodnoty různých typů chovají při hodnocení v logickém kontextu, zejména pokud jde o okrajové případy. Binární logické operátory vrátily logickou hodnotu v dřívějších verzích JavaScriptu, ale nyní místo toho vracejí jeden z operandů. Levý operand je vrácen, pokud jej lze vyhodnotit jako: false , v případě spojky : ( a && b), nebo true , v případě disjunkce : ( a || b); jinak se vrátí pravý operand. Automatický nátlak typu porovnávacími operátory se může lišit pro případy smíšených booleovských a číselně kompatibilních operandů (včetně řetězců, které lze vyhodnotit jako číslo, nebo objektů, které lze vyhodnotit jako takový řetězec), protože booleovský operand bude porovnáván jako číselnou hodnotu. To může být neočekávané. Výraz lze explicitně přenést na logický primitiv zdvojením operátoru logické negace : ( !! ), pomocí funkce Boolean () nebo pomocí podmíněného operátoru : ( c ? t : f).

// Automatic type coercion
console.log(true  ==   2 ); // false... true  → 1 !== 2 ←  2
console.log(false ==   2 ); // false... false → 0 !== 2 ←  2
console.log(true  ==   1 ); // true.... true  → 1 === 1 ←  1
console.log(false ==   0 ); // true.... false → 0 === 0 ←  0
console.log(true  ==  "2"); // false... true  → 1 !== 2 ← "2"
console.log(false ==  "2"); // false... false → 0 !== 2 ← "2"
console.log(true  ==  "1"); // true.... true  → 1 === 1 ← "1"
console.log(false ==  "0"); // true.... false → 0 === 0 ← "0"
console.log(false ==  "" ); // true.... false → 0 === 0 ← ""
console.log(false ==  NaN); // false... false → 0 !== NaN

console.log(NaN == NaN); // false...... NaN is not equivalent to anything, including NaN.

// Type checked comparison (no conversion of types and values)
console.log(true === 1); // false...... data types do not match

// Explicit type coercion
console.log(true === !!2);   // true.... data types and values match
console.log(true === !!0);   // false... data types match, but values differ
console.log( 1  ? true : false); // true.... only ±0 and NaN are "falsy" numbers
console.log("0" ? true : false); // true.... only the empty string is "falsy"
console.log(Boolean({}));    // true.... all objects are "truthy"

Nový operátor lze použít k vytvoření obálky objektů pro booleovský primitiv. Nicméně, typeof operátor nevrací boolean pro objekt obalu, vrátí objekt . Protože všechny objekty jsou vyhodnoceny jako pravdivé , je třeba k načtení zabalené hodnoty použít metodu, jako je .valueOf () nebo .toString () . Pro explicitní nátlak na booleovský typ Mozilla doporučuje, aby byla před logickým objektem použita funkce Boolean () (bez nového ).

var b = new Boolean(false);   // Object  false {}
var t = Boolean(b);           // Boolean true
var f = Boolean(b.valueOf()); // Boolean false
var n = new Boolean(b);       // Not recommended
n = new Boolean(b.valueOf()); // Preferred

if (0 || -0 || "" || null || undefined || b.valueOf() || !new Boolean() || !t) {
  console.log("Never this");
} else if ([] && {} && b && typeof b === "object" && b.toString() === "false") {
  console.log("Always this");
}

Symbol

Novinka v ECMAScript6. Symbol je jedinečný a neměnný identifikátor.

Příklad:

var x = Symbol(1);
var y = Symbol(1);
x === y; // => false

var symbolObject = {};
var normalObject = {};

// since x and y are unique,
// they can be used as unique keys in an object
symbolObject[x] = 1;
symbolObject[y] = 2;

symbolObject[x]; // => 1
symbolObject[y]; // => 2

// as compared to normal numeric keys
normalObject[1] = 1;
normalObject[1] = 2; // overrides the value of 1

normalObject[1]; // => 2

// changing the value of x does not change the key stored in the object
x = Symbol(3);
symbolObject[x]; // => undefined

// changing x back just creates another unique Symbol
x = Symbol(1);
symbolObject[x]; // => undefined

Existují také dobře známé symboly .

Jedním z nich je Symbol.iterator; pokud něco implementuje Symbol.iterator, je to iterovatelné:

let x = [1, 2, 3, 4]; // x is an Array
x[Symbol.iterator] === Array.prototype[Symbol.iterator]; // and Arrays are iterable

const xIterator = x[Symbol.iterator](); // The [Symbol.iterator] function should provide an iterator for x
xIterator.next(); // { value: 1, done: false }
xIterator.next(); // { value: 2, done: false }
xIterator.next(); // { value: 3, done: false }
xIterator.next(); // { value: 4, done: false }
xIterator.next(); // { value: undefined, done: true }
xIterator.next(); // { value: undefined, done: true }

// for..of loops automatically iterate values
for (const value of x) {
   console.log(value); // 1 2 3 4
}

// Sets are also iterable:
[Symbol.iterator] in Set.prototype; // true

for (const value of new Set(['apple', 'orange'])) {
   console.log(value); // "apple" "orange"
}

Nativní objekty

Jazyk JavaScript poskytuje několik nativních objektů . Nativní objekty JavaScriptu jsou považovány za součást specifikace JavaScript. Bez ohledu na prostředí JavaScript by tato sada objektů měla být vždy k dispozici.

Pole

Array je objekt JavaScript prototyp od Array konstruktoru speciálně navržen tak, aby hodnoty dat ukládání indexovaných celé číslo klíče. Pole, na rozdíl od základního typu Object, jsou prototypována s metodami a vlastnostmi, které pomáhají programátorovi v rutinních úlohách (například spojovat , krájet a tlačit ).

Stejně jako v rodině C pole používají schéma indexování založené na nule: Hodnota, která je vložena do prázdného pole pomocí metody push, zabírá 0. index v poli.

var myArray = [];            // Point the variable myArray to a newly ...
                             // ... created, empty Array
myArray.push("hello World"); // Fill the next empty index, in this case 0
console.log(myArray[0]);           // Equivalent to console.log("hello World");

Pole mají vlastnost length, která je vždy zaručeně větší než největší celočíselný index použitý v poli. Automaticky se aktualizuje, pokud vytvoříte vlastnost s ještě větším indexem. Zápis menšího čísla do vlastnosti length odstraní větší indexy.

K prvkům Array s lze přistupovat pomocí normálního zápisu vlastností objektu:

myArray[1];  // the 2nd item in myArray
myArray["1"];

Výše uvedené dva jsou ekvivalentní. Není možné použít poznámku „tečka“ nebo řetězce s alternativními reprezentacemi čísla:

myArray.1;     // syntax error
myArray["01"]; // not the same as myArray[1]

Deklarace pole může použít buď literál Array, nebo konstruktor Array :

let myArray;

// Array literals
myArray = [1, 2]; // length of 2
myArray = [1, 2,]; // same array - You can also have an extra comma at the end

// It's also possible to not fill in parts of the array
myArray = [0, 1, /* hole */, /* hole */, 4, 5]; // length of 6
myArray = [0, 1, /* hole */, /* hole */, 4, 5,]; // same array
myArray = [0, 1, /* hole */, /* hole */, 4, 5, /* hole */,]; // length of 7

// With the constructor
myArray = new Array(0, 1, 2, 3, 4, 5); // length of 6
myArray = new Array(365);              // an empty array with length 365

Pole jsou implementována tak, aby paměť používaly pouze definované prvky; jsou to „ řídká pole “. Nastavení a používá pouze prostor pro tyto dva prvky, stejně jako jakýkoli jiný objekt. Délka matice bude stále označena jako 58. Maximální délka pole je 4294967295, což odpovídá 32-bitové binární číslo (11111111111111111111111111111111) ₂ . myArray[10] = 'someThing'myArray[57] = 'somethingOther'

Pomocí literálu deklarace objektu lze vytvářet objekty, které se chovají podobně jako asociativní pole v jiných jazycích:

dog = {color: "brown", size: "large"};
dog["color"]; // results in "brown"
dog.color;    // also results in "brown"

Pomocí literálů deklarace objektu a pole lze rychle vytvořit pole asociativní, vícerozměrná nebo obojí. (Technicky JavaScript nepodporuje vícerozměrná pole, ale je možné je napodobit pomocí polí polí.)

cats = [{color: "brown", size: "large"},
    {color: "black", size: "small"}];
cats[0]["size"];      // results in "large"

dogs = {rover: {color: "brown", size: "large"},
    spot: {color: "black", size: "small"}};
dogs["spot"]["size"]; // results in "small"
dogs.rover.color;     // results in "brown"

datum

Objekt Date ukládá počet podepsaných milisekund s nulou představující 1970-01-01 00:00:00 UT a rozsah ± 10 ⁸ dní. Existuje několik způsobů poskytování argumentů konstruktoru Datum . Měsíce jsou založeny na nule.

new Date();                       // create a new Date instance representing the current time/date.
new Date(2010, 2, 1);             // create a new Date instance representing 2010-Mar-01 00:00:00
new Date(2010, 2, 1, 14, 25, 30); // create a new Date instance representing 2010-Mar-01 14:25:30
new Date("2010-3-1 14:25:30");    // create a new Date instance from a String.

K dispozici jsou metody k extrahování polí a také užitečný proString :

var d = new Date(2010, 2, 1, 14, 25, 30); // 2010-Mar-01 14:25:30;

// Displays '2010-3-1 14:25:30':
console.log(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate() + ' '
    + d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());

// Built-in toString returns something like 'Mon Mar 01 2010 14:25:30 GMT-0500 (EST)':
console.log(d);

Chyba

Vlastní chybové zprávy lze vytvořit pomocí třídy Error :

throw new Error("Something went wrong.");

Ty lze zachytit pomocí bloků try ... catch ... konečne, jak je popsáno v části o zpracování výjimek .

Matematika

Objekt Math obsahuje různé matematické konstanty (například π ) a funkce (například kosinus). (Všimněte si, že Math objekt nemá žádný konstruktor, na rozdíl od Array nebo Date . Všechny jeho metody jsou "statické", tj. Metody "třídy".) Všechny goniometrické funkce používají úhly vyjádřené v radiánech , nikoli ve stupních nebo gradech .

Regulární výraz

/expression/.test(string);     // returns Boolean
"string".search(/expression/); // returns position Number
"string".replace(/expression/, replacement);

// Here are some examples
if (/Tom/.test("My name is Tom")) console.log("Hello Tom!");
console.log("My name is Tom".search(/Tom/));          // == 11 (letters before Tom)
console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"

Třídy postav

// \d  - digit
// \D  - non digit
// \s  - space
// \S  - non space
// \w  - word char
// \W  - non word
// [ ] - one of
// [^] - one not of
//  -  - range

if (/\d/.test('0'))                   console.log('Digit');
if (/[0-9]/.test('6'))                console.log('Digit');
if (/[13579]/.test('1'))              console.log('Odd number');
if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK');
if (/\w\w\w/.test('Tom'))             console.log('Hello Tom');
if (/[a-zA-Z]/.test('B'))             console.log('Letter');

Shoda znaků

// A...Z a...z 0...9  - alphanumeric
// \u0000...\uFFFF    - Unicode hexadecimal
// \x00...\xFF        - ASCII hexadecimal
// \t                 - tab
// \n                 - new line
// \r                 - CR
// .                  - any character
// |                  - OR

if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim');
if (/A|B/.test("A"))  console.log ('A or B');

Opakovače

// ?   - 0 or 1 match
// *   - 0 or more
// +   - 1 or more
// {n}   - exactly n
// {n,}  - n or more
// {0,n} - n or less
// {n,m} - range n to m

if (/ab?c/.test("ac"))       console.log("OK"); // match: "ac", "abc"
if (/ab*c/.test("ac"))       console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc.
if (/ab+c/.test("abc"))      console.log("OK"); // match: "abc", "abbc", "abbbc" etc.
if (/ab{3}c/.test("abbbc"))  console.log("OK"); // match: "abbbc"
if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc", "abbbbc", "abbbbbc" etc.
if (/ab{1,3}c/.test("abc"))  console.log("OK"); // match: "abc", "abbc", "abbbc"

Kotvy

// ^  - string starts with
// $  - string ends with

if (/^My/.test("My name is Tom"))   console.log ("Hi!");
if (/Tom$/.test("My name is Tom"))  console.log ("Hi Tom!");

Podvýraz

// ( )  - groups characters

if (/water(mark)?/.test("watermark")) console.log("Here is water!"); // match: "water", "watermark",
if (/(Tom)|(John)/.test("John"))      console.log("Hi Tom or John!");

Vlajky

// /g  - global
// /i  - ignore upper/lower case
// /m  - allow matches to span multiple lines

console.log("hi tom!".replace(/Tom/i, "John"));  // == "hi John!"
console.log("ratatam".replace(/ta/, "tu"));      // == "ratutam"
console.log("ratatam".replace(/ta/g, "tu"));     // == "ratutum"

Pokročilé metody

my_array = my_string.split(my_delimiter);
// example
my_array = "dog,cat,cow".split(",");      // my_array==["dog","cat","cow"];

my_array = my_string.match(my_expression);
// example
my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g); // my_array==["11:30","12:15","16:45"];

Zachycení skupin

var myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/;
var results = myRe.exec("The date and time are 2009-09-08 09:37:08.");
if (results) {
  console.log("Matched: " + results[0]); // Entire match
  var my_date = results[1]; // First group == "2009-09-08"
  var my_time = results[2]; // Second group == "09:37:08"
  console.log("It is " + my_time + " on " + my_date);
} else console.log("Did not find a valid date!");

Funkce

Každá funkce v JavaScriptu je instancí konstruktoru funkce :

// x, y is the argument. 'return x + y' is the function body, which is the last in the argument list.
var add = new Function('x', 'y', 'return x + y');
add(1, 2); // => 3

Výše přidanou funkci lze také definovat pomocí výrazu funkce:

var add = function(x, y) {
  return x + y;
};
add(1, 2); // => 3

V ES6 byla přidána syntaxe šipkové funkce, což umožňuje, aby funkce, které vracejí hodnotu, byly stručnější. Na rozdíl od výrazu function () {} také uchovávají toto z globálního objektu místo toho, aby jej děděly z místa, kde bylo voláno / na co bylo voláno .

var add = (x, y) => {return x + y;};
// values can also be implicitly returned (i.e. no return statement is needed)
var addImplicit = (x, y) => x + y;

add(1, 2); // => 3
addImplicit(1, 2) // => 3

Pro funkce, které je třeba zvednout, existuje samostatný výraz:

function add(x, y) {
  return x + y;
}
add(1, 2); // => 3

Zvedání vám umožňuje použít funkci, než je „deklarována“:

add(1, 2); // => 3, not a ReferenceError
function add(x, y) {
  return x + y;
}

Instance funkce má vlastnosti a metody.

function subtract(x, y) {
  return x - y;
}

console.log(subtract.length); // => 2, arity of the function (number of arguments)
console.log(subtract.toString());

/*
"function subtract(x, y) {
  return x - y;
}"
*/

Operátoři

Operátor '+' je přetížený : používá se pro zřetězení řetězců a aritmetické sčítání. To může způsobit problémy při nechtěném míchání řetězců a čísel. Jako unární operátor dokáže převést číselný řetězec na číslo.

// Concatenate 2 strings
console.log('He' + 'llo'); // displays Hello

// Add two numbers
console.log(2 + 6);  // displays 8

// Adding a number and a string results in concatenation (from left to right)
console.log(2 + '2');    // displays 22
console.log('$' + 3 + 4);  // displays $34, but $7 may have been expected
console.log('$' + (3 + 4)); // displays $7
console.log(3 + 4 + '7'); // displays 77, numbers stay numbers until a string is added

// Convert a string to a number using the unary plus
console.log(+'2' === 2); // displays true
console.log(+'Hello'); // displays NaN

Podobně je přetížen operátor '*': může převést řetězec na číslo.

console.log(2 + '6'*1);  // displays 8
console.log(3*'7'); // 21
console.log('3'*'7'); // 21
console.log('hello'*'world'); // displays NaN

Aritmetický

JavaScript podporuje následující binární aritmetické operátory :

JavaScript podporuje následující unární aritmetické operátory :

var x = 1;
console.log(++x); // x becomes 2; displays 2
console.log(x++); // displays 2; x becomes 3
console.log(x);  // x is 3; displays 3
console.log(x--); //  displays 3; x becomes 2
console.log(x);  //  displays 2; x is 2
console.log(--x); //  x becomes 1; displays 1

Operátor modulo zobrazí zbytek po dělení modulem. Pokud se jedná o záporná čísla, vrácená hodnota závisí na operandu.

var x = 17;
console.log(x%5); // displays 2
console.log(x%6); // displays 5
console.log(-x%5); // displays -2
console.log(-x%-5); // displays -2
console.log(x%-5); // displays 2

Chcete-li vždy vrátit nezáporné číslo, znovu přidejte modul a znovu použijte operátor modulo:

var x = 17;
console.log((-x%5+5)%5); // displays 3

Úkol

Zadání z primitivní typy

var x = 9;
x += 1; 
console.log(x); // displays: 10
x *= 30;
console.log(x); // displays: 300
x /= 6;
console.log(x); // displays: 50
x -= 3;
console.log(x); // displays: 47
x %= 7;
console.log(x); // displays: 5

Přiřazení typů objektů

/**
 * To learn JavaScript objects...
 */
var object_1 = {a: 1};		// assign reference of newly created object to object_1
var object_2 = {a: 0};
var object_3 = object_2;	// object_3 references the same object as object_2 does
	 
object_3.a = 2;
message();	        	// displays 1 2 2
	 
object_2 = object_1;		// object_2 now references the same object as object_1
	        	        // object_3 still references what object_2 referenced before
message();		        // displays 1 1 2
	 
object_2.a = 7;  	        // modifies object_1
message();		        // displays 7 7 2

object_3.a = 5;                 // object_3 doesn't change object_2
message();	                // displays 7 7 5

object_3 = object_2;	
object_3.a=4;                  // object_3 changes object_1 and object_2
message();                     // displays 4 4 4

/**
 * Prints the console.log message
 */
function message() {
	console.log(object_1.a + " " + object_2.a + " " + object_3.a);
}

Destrukturalizační úkol

V JavaScriptu od verze 1.7 umožňuje destrukční přiřazení přiřazení částí datových struktur několika proměnným najednou. Levá strana přiřazení je vzor, ​​který se podobá libovolně vnořenému literálu objektu/pole obsahujícímu na jeho listech hodnoty l-l, které mají přijímat podstruktury přiřazené hodnoty.

var a, b, c, d, e;
[a, b, c] = [3, 4, 5];
console.log(a + ',' + b + ',' + c); // displays: 3,4,5
e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};
var arr = [];
({baz: [arr[0], arr[3]], foo: a, bar: b}) = e;
console.log(a + ',' + b + ',' + arr);	// displays: 5,6,Baz,,,Content
[a, b] = [b, a];		// swap contents of a and b
console.log(a + ',' + b);		// displays: 6,5

[a, b, c] = [3, 4, 5]; // permutations
[a, b, c] = [b, c, a];
console.log(a + ',' + b + ',' + c); // displays: 4,5,3

Provozovatel šíření/odpočinek

Standard ECMAScript 2015 zavádí operátor " ... " pro související pojmy "syntaxe roztažení" a "parametry odpočinku"

Šířená syntaxe poskytuje další způsob destrukce polí. Udává, že prvky ve specifikovaném poli by měly být použity jako parametry ve volání funkce nebo položky v literálu pole.

Jinými slovy, „ ... “ transformuje „ [... foo] “ na „ [foo [0], foo [1], foo [2]] “ a „ this.bar (... foo); "do" this.bar (foo [0], foo [1], foo [2]); ".

var a = [1, 2, 3, 4];

// It can be used multiple times in the same expression
var b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];

// It can be combined with non-spread items.
var c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];

// For comparison, doing this without the spread operator 
// creates a nested array.
var d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]

// It works the same with function calls
function foo(arg1, arg2, arg3) {
    console.log(arg1 + ':' + arg2 + ':' + arg3);
}

// You can use it even if it passes more parameters than the function will use
foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

// You can mix it with non-spread parameters
foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

// For comparison, doing this without the spread operator
// assigns the array to arg1, and nothing to the other parameters.
foo(a); // "1,2,3,4:undefined:undefined"

Když ... se používá v deklaraci funkce , označuje parametr rest . Zbývající parametr musí být konečným pojmenovaným parametrem v seznamu parametrů funkce. Bude mu přiřazeno pole obsahující všechny argumenty předané funkci přesahující ostatní pojmenované parametry. Jinými slovy, získá „zbytek“ argumentů předaných funkci (odtud název).

function foo(a, b, ...c) {
    console.log(c.length);
}

foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]
foo('a', 'b'); // "0" → c = []

Zbytkové parametry jsou podobné objektu argumentů Javascriptu , což je objekt podobný poli, který obsahuje všechny parametry (pojmenované i nepojmenované) v aktuálním volání funkce. Na rozdíl od argumentů jsou však ostatní parametry true Array objekty, takže na ně lze přímo použít metody jako .slice () a .sort () .

... Operátor může být použit pouze s Array objektů. (Existuje však návrh na jeho rozšíření na Object s v budoucím standardu ECMAScript.)

Srovnání

Proměnné odkazující na objekty jsou stejné nebo identické pouze tehdy, pokud odkazují na stejný objekt:

var obj1 = {a: 1};
var obj2 = {a: 1};
var obj3 = obj1;
console.log(obj1 == obj2);  //false
console.log(obj3 == obj1);  //true
console.log(obj3 === obj1); //true

Viz také řetězec .

Logický

JavaScript poskytuje čtyři logické operátory:

• unární negace ( NOT =! a )
• binární disjunkce ( OR = a || b ) a spojka ( AND = a && b )
• ternární podmíněné ( c? t: f )

V kontextu logické operace je jakýkoli výraz vyhodnocen jako true kromě následujících :

• Řetězce: "" , '' ,
• Čísla: 0 , -0 , NaN ,
• Speciální: null , undefined ,
• Boolean: nepravda .

Boolovskou funkci lze použít k explicitnímu převodu na primitivum typu Boolean :

// Only empty strings return false
console.log(Boolean("")      === false);
console.log(Boolean("false") === true);
console.log(Boolean("0")     === true);

// Only zero and NaN return false
console.log(Boolean(NaN) === false);
console.log(Boolean(0)   === false);
console.log(Boolean(-0)  === false); // equivalent to -1*0
console.log(Boolean(-2)  === true);

// All objects return true
console.log(Boolean(this) === true);
console.log(Boolean({})   === true);
console.log(Boolean([])   === true);

// These types return false
console.log(Boolean(null)      === false);
console.log(Boolean(undefined) === false); // equivalent to Boolean()

Operátor NOT vyhodnotí svůj operand jako logickou hodnotu a vrátí negaci. Použití operátoru dvakrát za sebou jako dvojitého záporu výslovně převede výraz na primitivum typu Boolean:

console.log( !0 === Boolean(!0));
console.log(Boolean(!0) === !!1);
console.log(!!1 === Boolean(1));
console.log(!!0 === Boolean(0));
console.log(Boolean(0) === !1);
console.log(!1 === Boolean(!1));
console.log(!"" === Boolean(!""));
console.log(Boolean(!"") === !!"s");
console.log(!!"s" === Boolean("s"));
console.log(!!"" === Boolean(""));
console.log(Boolean("") === !"s");	
console.log(!"s" === Boolean(!"s"));

Ternární operátor lze také použít pro explicitní převod:

console.log([] == false); console.log([] ? true : false); // “truthy”, but the comparison uses [].toString()
console.log([0] == false); console.log([0]? true : false); // [0].toString() == "0"
console.log("0" == false); console.log("0"? true : false); // "0" → 0 ... (0 == 0) ... 0 ← false
console.log([1] == true); console.log([1]? true : false); // [1].toString() == "1"
console.log("1" == true); console.log("1"? true : false); // "1" → 1 ... (1 == 1) ... 1 ← true
console.log([2] != true); console.log([2]? true : false); // [2].toString() == "2"
console.log("2" != true); console.log("2"? true : false); // "2" → 2 ... (2 != 1) ... 1 ← true

Výrazy, které používají funkce jako post -incrementation ( i ++ ), mají očekávaný vedlejší účinek . JavaScript poskytuje zkratové vyhodnocení výrazů; pravý operand je spuštěn pouze v případě, že levý operand nestačí k určení hodnoty výrazu.

console.log(a || b);  // When a is true, there is no reason to evaluate b.
console.log(a && b);  // When a is false, there is no reason to evaluate b.
console.log(c ? t : f); // When c is true, there is no reason to evaluate f.

V raných verzích JavaScriptu a JScriptu binární logické operátory vrátily booleovskou hodnotu (jako většina programovacích jazyků odvozených od C). Všechny současné implementace však místo toho vracejí jeden ze svých operandů:

console.log(a || b); // if a is true, return a, otherwise return b
console.log(a && b); // if a is false, return a, otherwise return b

Programátorům, kteří jsou obeznámeni s chováním v jazyce C, může tato funkce připadat překvapivá, ale umožňuje výstižnější vyjádření vzorů, jako je nulové spojování :

var s = t || "(default)"; // assigns t, or the default value, if t is null, empty, etc.

Logické přiřazení

bitový

JavaScript podporuje následující binární bitové operátory :

Příklady:

x=11 & 6;
console.log(x); // 2

JavaScript podporuje následující unární bitový operátor :

Bitové přiřazení

JavaScript podporuje následující operátory binárního přiřazení:

Příklady:

x=7;
console.log(x); // 7
x<<=3;
console.log(x); // 7->14->28->56

Tětiva

Příklady:

str = "ab" + "cd";  // "abcd"
str += "e";      // "abcde"

str2 = "2" + 2;     // "22", not "4" or 4.

??

const a = b ?? 3;

const a = b || 3;

Řídicí struktury

Složené prohlášení

Dvojice složených závorek {} a uzavřená posloupnost příkazů tvoří složený příkaz, který lze použít všude tam, kde lze použít příkaz.

Pokud ... jinak

if (expr) {
  //statements;
} else if (expr2) {
  //statements;
} else {
  //statements;
}

Podmíněný (ternární) operátor

Podmíněný operátor vytvoří výraz, který se vyhodnotí jako jeden ze dvou výrazů v závislosti na podmínce. To je podobné příkazu if, který vybere jeden ze dvou příkazů, které se mají provést v závislosti na podmínce. Tj., Podmíněný operátor je pro výrazy what if je pro příkazy.

 result = condition ? expression : alternative;

je stejné jako:

 if (condition) {
  result = expression;
 } else {
  result = alternative;
 }

Na rozdíl od příkazu if nemůže podmíněný operátor vynechat svou „větev else“.

Přepnout prohlášení

Syntaxe příkazu k přepnutí JavaScriptu je následující:

 switch (expr) {
  case SOMEVALUE:
   // statements;
   break;
  case ANOTHERVALUE:
   // statements;
   break;
  default:
   // statements;
   break;
 }

• přestávka; je volitelný; je to však obvykle potřeba, protože jinak bude provádění kódu pokračovat do těla dalšího bloku případů.
• Jako preventivní opatření přidejte na konec posledního případu prohlášení o přestávce, v případě, že budou později přidány další případy.
• Řetězcové doslovné hodnoty lze také použít pro hodnoty případu.
• Místo hodnot lze použít výrazy.
• Výchozí případ (volitelný) se provede, když výraz neodpovídá žádným jiným zadaným případům.
• Rovnátka jsou nutná.

Pro smyčku

Syntaxe smyčky JavaScript pro je následující:

 for (initial; condition; loop statement) {
  /*
   statements will be executed every time
   the for{} loop cycles, while the
   condition is satisfied
  */
 }

nebo

 for (initial; condition; loop statement(iteration)) // one statement

Pro ... ve smyčce

Syntaxe JavaScriptu for ... in loopje následující:

for (var property_name in some_object) {
  // statements using some_object[property_name];
}

• Iteruje přes všechny vyčíslitelné vlastnosti objektu.
• Iteruje přes všechny použité indexy pole, včetně všech uživatelem definovaných vlastností objektu pole, pokud existují. Při iteraci přes pole tedy může být lepší použít tradiční smyčku for s číselným indexem.
• Mezi různými webovými prohlížeči existují rozdíly, pokud jde o to, které vlastnosti se projeví pomocí příkazu for ... in loop. Teoreticky je to řízeno vlastností vnitřního stavu definovanou standardem ECMAscript s názvem „DontEnum“, ale v praxi každý prohlížeč během introspekce vrací mírně odlišnou sadu vlastností. Je užitečné otestovat danou vlastnost pomocí }. Přidání metody k prototypu pole pomocí } tedy může způsobit smyčky smyčky nad názvem metody.if (some_object.hasOwnProperty(property_name)) { ...Array.prototype.newMethod = function() {...for ... in

Zatímco smyčka

Syntaxe smyčky JavaScript while je následující:

while (condition) {
  statement1;
  statement2;
  statement3;
  ...
}

Do ... while loop

Syntaxe JavaScriptu do ... while loopje následující:

do {
  statement1;
  statement2;
  statement3;
  ...
} while (condition);

S

Příkaz with přidá všechny vlastnosti a metody daného objektu do rozsahu následujícího bloku a nechá je odkazovat, jako by to byly lokální proměnné.

with (document) {
  var a = getElementById('a');
  var b = getElementById('b');
  var c = getElementById('c');
};

• Všimněte si absence dokumentu. před každým vyvoláním getElementById () .

Sémantika je podobná příkazu with of Pascal .

Protože dostupnost příkazů with brání výkonu programu a předpokládá se, že snižuje srozumitelnost kódu (protože jakákoli daná proměnná může být ve skutečnosti vlastností z uzavření s ), toto prohlášení není povoleno v přísném režimu .

Štítky

JavaScript ve většině implementací podporuje vnořené popisky. Smyčky nebo bloky mohou být označeny pro příkaz break a smyčky pro pokračování . Ačkoli goto je vyhrazené slovo, goto není implementováno v JavaScriptu.

loop1: for (var a = 0; a < 10; a++) {
  if (a == 4) {
    break loop1; // Stops after the 4th attempt
  }
  console.log('a = ' + a);
  loop2: for (var b = 0; b < 10; ++b) {
    if (b == 3) {
     continue loop2; // Number 3 is skipped
    }
    if (b == 6) {
     continue loop1; // Continues the first loop, 'finished' is not shown
    }
    console.log('b = ' + b);
  }
  console.log('finished');
}
block1: {
  console.log('Hello'); // Displays 'Hello'
  break block1;
  console.log('World'); // Will never get here
}
goto block1; // Parse error.

Funkce

Funkce je blok s (případně prázdný) seznamu parametrů, která se obvykle podává jméno. Funkce může používat lokální proměnné. Pokud funkci ukončíte bez příkazu return, vrátí se hodnota undefined .

function gcd(segmentA, segmentB) {
  var diff = segmentA - segmentB;
  if (diff == 0) 
    return segmentA;
  return diff > 0 ? gcd(segmentB, diff) : gcd(segmentA, -diff);
}
console.log(gcd(60, 40)); // 20

var mygcd = gcd; // mygcd is a reference to the same function as gcd. Note no argument ()s.
console.log(mygcd(60, 40)); // 20

Funkce jsou objekty první třídy a mohou být přiřazeny jiným proměnným.

Počet argumentů zadaných při volání funkce nemusí nutně odpovídat počtu argumentů v definici funkce; pojmenovaný argument v definici, který nemá odpovídající argument ve volání, bude mít hodnotu undefined (kterou lze implicitně přetypovat na false). V rámci funkce lze k argumentům přistupovat také prostřednictvím objektu argumentů ; to poskytuje přístup ke všem argumentům pomocí indexů (např. ), včetně těch, které přesahují počet pojmenovaných argumentů. (I když seznam argumenty má .length vlastnost, že je není instancí Array , nemá metod, jako je .slice () , .sort () , atd.) arguments[0], arguments[1], ... arguments[n]

function add7(x, y) {
  if (!y) {
    y = 7;
  }
  console.log(x + y + arguments.length);
};
add7(3); // 11
add7(3, 4); // 9

Primitivní hodnoty (číslo, logická hodnota, řetězec) se předávají podle hodnoty. U objektů je to odkaz na objekt, který je předán.

var obj1 = {a : 1};
var obj2 = {b : 2};
function foo(p) {
  p = obj2; // Ignores actual parameter
  p.b = arguments[1];
}
foo(obj1, 3); // Does not affect obj1 at all. 3 is additional parameter
console.log(obj1.a + " " + obj2.b); // writes 1 3

Funkce lze deklarovat uvnitř jiných funkcí a přistupovat k lokálním proměnným vnější funkce. Kromě toho implementují úplné uzavření tím, že si pamatují lokální proměnné vnější funkce i poté, co vnější funkce skončila.

var v = "Top";
var bar, baz;
function foo() {
  var v = "fud";
  bar = function() { console.log(v) };
  baz = function(x) { v = x; };
}
foo();
baz("Fugly");
bar(); // Fugly (not fud) even though foo() has exited.
console.log(v); // Top

Asynchronní/čekejte

async function createNewDoc() {
  let response = await db.post({}); // post a new doc
  return await db.get(response.id); // find by id
}

async function main() {
  try {
    let doc = await createNewDoc();
    console.log(doc);
  } catch (err) {
    console.log(err);
  }
}
main();

Objekty

Pro pohodlí jsou typy obvykle rozděleny na primitiva a objekty . Objekty jsou entity, které mají identitu (jsou si rovny pouze sami sobě) a které mapují názvy vlastností na hodnoty („sloty“ v terminologii programování založené na prototypech ). Objekty lze považovat za asociativní pole nebo hashe a často se implementují pomocí těchto datových struktur. Objekty však mají další funkce, například prototypový řetězec, který běžná asociativní pole nemají.

JavaScript má několik druhů integrovaných objektů, jmenovitě Array , Boolean , Date , Function , Math , Number , Object , RegExp a String . Dalšími objekty jsou „hostitelské objekty“, které nejsou definovány jazykem, ale běhovým prostředím. Například v prohlížeči patří typické hostitelské objekty do modelu DOM (okno, formulář, odkazy atd.).

Vytváření objektů

Objekty lze vytvářet pomocí konstruktoru nebo literálu objektu. Konstruktor může použít buď vestavěnou funkci Object, nebo vlastní funkci. Je zvykem, že funkce konstruktoru mají název, který začíná velkým písmenem:

// Constructor
var anObject = new Object();

// Object literal
var objectA = {};
var objectA2 = {};  // A != A2, {}s create new objects as copies.
var objectB = {index1: 'value 1', index2: 'value 2'};

// Custom constructor (see below)

Objektové literály a literály pole umožňují snadno vytvářet flexibilní datové struktury:

var myStructure = {
  name: {
    first: "Mel",
    last: "Smith"
  },
  age: 33,
  hobbies: ["chess", "jogging"]
};

Toto je základ pro JSON , což je jednoduchá notace, která pro výměnu dat používá syntaxi podobnou JavaScriptu.

Metody

Metoda je prostě Funkce, která byla přiřazena k názvu vlastnosti objektu. Na rozdíl od mnoha objektově orientovaných jazyků neexistuje v objektovém JavaScriptu rozdíl mezi definicí funkce a definicí metody. K rozlišování dochází spíše při volání funkce; funkci lze nazvat jako metodu.

Při volání jako metoda, standardní lokální proměnná to je prostě automaticky nastaven na instanci objektu na levé části „ “. (Tam jsou také volat a aplikovat metody, které lze nastavit tento explicitně některé balíčky, jako jQuery dělat neobvyklé věci se to .)

V níže uvedeném příkladu se jako konstruktor používá Foo. Na konstruktoru není nic zvláštního - je to jen obyčejná funkce, která inicializuje objekt. Při použití s novým klíčovým slovem, jak je normou, je toto nastaveno na nově vytvořený prázdný objekt.

Všimněte si, že v následujícím příkladu Foo jednoduše přiřazuje hodnoty slotům, z nichž některé jsou funkce. Může tedy různým instancím přiřadit různé funkce. V tomto příkladu není prototypování.

function px() { return this.prefix + "X"; }

function Foo(yz) {
  this.prefix = "a-";
  if (yz > 0) {
    this.pyz = function() { return this.prefix + "Y"; };
  } else {
    this.pyz = function() { return this.prefix + "Z"; };
  }
  this.m1 = px;
  return this;
}

var foo1 = new Foo(1);
var foo2 = new Foo(0);
foo2.prefix = "b-";

console.log("foo1/2 " + foo1.pyz() + foo2.pyz());
// foo1/2 a-Y b-Z

foo1.m3 = px; // Assigns the function itself, not its evaluated result, i.e. not px()
var baz = {"prefix": "c-"};
baz.m4 = px; // No need for a constructor to make an object.

console.log("m1/m3/m4 " + foo1.m1() + foo1.m3() + baz.m4());
// m1/m3/m4 a-X a-X c-X

foo1.m2(); // Throws an exception, because foo1.m2 doesn't exist.

Konstruktéři

Funkce konstruktoru jednoduše přiřazují hodnoty slotům nově vytvořeného objektu. Hodnoty mohou být data nebo jiné funkce.

Příklad: Manipulace s objektem:

function MyObject(attributeA, attributeB) {
  this.attributeA = attributeA;
  this.attributeB = attributeB;
}

MyObject.staticC = "blue"; // On MyObject Function, not object
console.log(MyObject.staticC); // blue

object = new MyObject('red', 1000);

console.log(object.attributeA); // red
console.log(object["attributeB"]); // 1000

console.log(object.staticC); // undefined
object.attributeC = new Date(); // add a new property

delete object.attributeB; // remove a property of object
console.log(object.attributeB); // undefined

delete object; // remove the whole Object (rarely used)
console.log(object.attributeA); // throws an exception

Na samotný konstruktor se odkazuje ve slotu konstruktoru prototypu objektu . Tak,

function Foo() {}
// Use of 'new' sets prototype slots (for example, 
// x = new Foo() would set x's prototype to Foo.prototype,
// and Foo.prototype has a constructor slot pointing back to Foo).
x = new Foo();
// The above is almost equivalent to
y = {};
y.constructor = Foo;
y.constructor();
// Except
x.constructor == y.constructor // true
x instanceof Foo // true
y instanceof Foo // false
// y's prototype is Object.prototype, not
// Foo.prototype, since it was initialised with
// {} instead of new Foo.
// Even though Foo is set to y's constructor slot,
// this is ignored by instanceof - only y's prototype's
// constructor slot is considered.

Funkce jsou samotné objekty, které lze použít k vytvoření efektu podobného „statickým vlastnostem“ (pomocí terminologie C ++/Java), jak je uvedeno níže. (Objekt funkce má také speciální vlastnost prototypu , jak je popsáno v části "Dědičnost" níže.)

Odstranění objektu se používá jen zřídka, protože skriptovací stroj smetí objekty, na které se již neodkazuje.

Dědictví

JavaScript podporuje hierarchie dědičnosti prostřednictvím prototypování způsobem Self .

V následujícím příkladu odvozená třída dědí ze třídy Base . Když je d vytvořeno jako odvozené , zkopíruje se odkaz na základní instanci Base do d.base .

Derive neobsahuje hodnotu pro aBaseFunction , takže je načtena z aBaseFunction při přístupu k aBaseFunction . To je zřejmé změnou hodnoty base.aBaseFunction , která se odráží v hodnotě d.aBaseFunction .

Některé implementace umožňují přístup k prototypu nebo jeho nastavení explicitně pomocí slotu __proto__, jak je uvedeno níže.

function Base() {
  this.anOverride = function() { console.log("Base::anOverride()"); };

  this.aBaseFunction = function() { console.log("Base::aBaseFunction()"); };
}

function Derived() {
  this.anOverride = function() { console.log("Derived::anOverride()"); };
}

base = new Base();
Derived.prototype = base; // Must be before new Derived()
Derived.prototype.constructor = Derived; // Required to make `instanceof` work

d = new Derived();    // Copies Derived.prototype to d instance's hidden prototype slot.
d instanceof Derived; // true
d instanceof Base;    // true

base.aBaseFunction = function() { console.log("Base::aNEWBaseFunction()"); }

d.anOverride();    // Derived::anOverride()
d.aBaseFunction(); // Base::aNEWBaseFunction()
console.log(d.aBaseFunction == Derived.prototype.aBaseFunction); // true

console.log(d.__proto__ == base); // true in Mozilla-based implementations and false in many others.

Následující text jasně ukazuje, jak se při vytváření instance kopírují odkazy na prototypy , ale že změny prototypu mohou ovlivnit všechny instance, které na něj odkazují.

function m1() { return "One"; }
function m2() { return "Two"; }
function m3() { return "Three"; }

function Base() {}

Base.prototype.m = m2;
bar = new Base();
console.log("bar.m " + bar.m()); // bar.m Two

function Top() { this.m = m3; }
t = new Top();

foo = new Base();
Base.prototype = t;
// No effect on foo, the *reference* to t is copied.
console.log("foo.m " + foo.m()); // foo.m Two

baz = new Base();
console.log("baz.m " + baz.m()); // baz.m Three

t.m = m1; // Does affect baz, and any other derived classes.
console.log("baz.m1 " + baz.m()); // baz.m1 One

V praxi se používá mnoho variací těchto témat a může to být silné i matoucí.

Zpracování výjimek

JavaScript obsahuje příkaz pro zpracování try ... catch ... finally výjimek pro zpracování chyb za běhu.

Příkaz try ... catch ... finallyzachycuje výjimky vyplývající z chyby nebo příkazu throw. Jeho syntaxe je následující:

try {
  // Statements in which exceptions might be thrown
} catch(errorValue) {
  // Statements that execute in the event of an exception
} finally {
  // Statements that execute afterward either way
}

Zpočátku se provádějí příkazy v bloku try. Pokud je vyvolána výjimka, tok řízení skriptu se okamžitě přenese do příkazů v bloku catch, přičemž výjimka je k dispozici jako argument chyby. Jinak se přeskočí blok catch. Blok catch může vrhnout (errorValue) , pokud nechce zpracovat konkrétní chybu.

V každém případě jsou příkazy v bloku finally vždy provedeny. To lze použít k uvolnění zdrojů, ačkoli paměť se automaticky shromažďuje odpadky.

Může být vynechán úlovek nebo klauzule konečně. Je vyžadován argument catch.

Implementace Mozilly umožňuje více příkazů catch jako rozšíření standardu ECMAScript. Řídí se podobnou syntaxí, jaká se používá v Javě :

try { statement; }
catch (e if e == "InvalidNameException")  { statement; }
catch (e if e == "InvalidIdException")    { statement; }
catch (e if e == "InvalidEmailException") { statement; }
catch (e)                                 { statement; }

V prohlížeči je událost onerror běžněji používána k zachycování výjimek.

onerror = function (errorValue, url, lineNr) {...; return true;};

Nativní funkce a metody

(Nesouvisí s webovými prohlížeči.)

eval (výraz)

Vyhodnocuje první parametr jako výraz, který může zahrnovat příkazy přiřazení. Na proměnné lokální pro funkce lze odkazovat pomocí výrazu. Nicméně, evalpředstavuje zásadní bezpečnostní riziko, protože umožňuje špatný herec spuštění libovolného kódu, takže jeho použití se nedoporučuje.

(function foo() {
  var x = 7;
  console.log("val " + eval("x + 2"));
})(); // shows val 9.

Viz také

• Porovnání editorů zdrojových kódů založených na JavaScriptu
• JavaScript

Reference

Další čtení

• Danny Goodman: JavaScript Bible , Wiley, John & Sons, ISBN  0-7645-3342-8 .
• David Flanagan, Paula Ferguson: JavaScript: The Definitive Guide , O'Reilly & Associates, ISBN  0-596-10199-6 .
• Thomas A. Powell, Fritz Schneider: JavaScript: The Complete Reference , McGraw-Hill Companies, ISBN  0-07-219127-9 .
• Axel Rauschmayer: Speaking JavaScript: An In-Depth Guide for Programmers , 460 stran, O'Reilly Media, 25. února 2014, ISBN  978-1449365035 . ( bezplatné online vydání )
• Emily Vander Veer: JavaScript For Dummies, 4. vydání , Wiley, ISBN  0-7645-7659-3 .

externí odkazy

• Opětovné představení JavaScriptu - Mozilla Developer Center
• Smyčky JavaScript
• Standardní odkazy na ECMAScript: ECMA-262
• Interaktivní lekce JavaScriptu - založené na příkladech
• JavaScript na webu About.com: lekce a vysvětlení
• Školení JavaScriptu
• Mozilla Developer Center Základní reference pro JavaScript verze 1.5 , 1.4 , 1.3 a 1.2
• Jazyková dokumentace Mozilla JavaScript