MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Gramatika a typy

Tento překlad není kompletní. Prosím pomozte přeložit tento článek z angličtiny.

Tato kapitola probírá základní gramatiku, deklaraci proměnných, datové typy a literály JavaScriptu.

Základy

JavaScript si většinu své syntaxe vypůjčuje od Javy, je ale také ovlivněn jazyky Awk, Perl a Python.

JavaScript je case-sensitive (rozlišuje velikost písmen) a používá kódování znaků Unicode.

V JavaScriptu jsou instrukce označovány jako příkazy a oddělují se středníkem (;). Mezery, tabulátory a znaky zalomení se nazývají prázné znaky. Zdrojový text JavaScriptu je procházen zleva doprava a převádí se na sekvenci vstupních prvků, kterými jsou symboly, řídicí znaky, zakončení řádek, komentáře a prázdné znaky. ECMAScript také definuje určitá klíčová slova a literály a zahrnuje pravidla pro automatické vkládání středníků (ASI) na konec příkazů. Nicméně se i tak doporučuje vkládat středníky vždy za každý příkaz; předcházíte tak vedlejším efektům. Více informací získáne v podrobné referenční příručce o lexikální gramatice JavaScriptu. 

Komentáře

Syntaxe komentářů se shoduje s C++ a spoustou dalších jazyků:

// řádkový komentář
 
/* toto je delší,
   víceřádkový komentář
 */
 
/* Komentáře ale nemůžete /* vnořovat */ SyntaxError */

Deklarace

V JavaScriptu existují tři typy deklarací.

var
Deklaruje proměnnou, volitelně jí přiřazuje i hodnotu.
let
Deklaruje lokální proměnnou pro scope bloku kódu, volitelně jí přiřazuje i hodnotu.
const
Declaruje pojmenovanou konstantu, která je jen ke čtení.

Proměnné

Proměnné používáme jako symbolické názvy pro hodnoty v naší aplikaci. Názvy proměnných označované jako identifikátory podléhají jistým pravidlům.

Javascriptový identifikátor musí začínat písmenem, podrtžítkem (_) či dolarovým znakem ($); následujícími znaky pak mohou být i číslice (0-9). Protože je JavaScript case sensitive, zahrnuje množina písmem jak znaky of "A" do "Z" (velká písmena), tak i od "a" do "z" (malá písmena).

V identifikátorech můžeme použít znaky ze sady ISO 8859-1 nebo Unicode, jako jsou například å a ü. Stejně tak můžeme v identifikátorech používat i Unicode escape sekvence.

Příklady povolených názvů jsou Number_hits, temp99, a _name.

Deklarace proměnných

Proměnnou můžeme deklarovat třemi způsoby:

  • Klíčovým slovem var. Například var x = 42. Tato syntaxe může být použit pro deklaraci lokální i globální proměnné.
  • Jednoduše přiřazením hodnoty. Například x = 42. Takto deklarujeme výhradně globální proměnnou. V případě strict JavaScriptu generuje tento způsob upozornění. Tuto možno byste neměli používat.
  • Klíčovým slovem let. Například let y = 13. Tato syntaxe může být použita pro deklaraci lokální proměnné ve scope konkrétního bloku kódu. Podívejte se níže na Rámec působnosti proměnné (scope).

Vyhodnocování proměnných

Proměnná deklarovaná pomocí var či let příkazu má bez prvotní inicializace hodnotu undefined.

Pokud se pokusíme přistupovat k nedeklarované proměnné, skončí náš pokus vyhozením výjimky ReferenceError:

var a;
console.log("Hodnota a je " + a); // zapíše "Hodnota a je undefined"
console.log("Hodnota b je " + b); // způsobí výjimku ReferenceError

undefined můžeme použít k vyjádření toho, jestli má proměnná přiřazenu nějakou hodnotu. V následujícím kódu není proměnné input přiřazena hodnota, a příkaz if tak bude vyhodnocen jako true (pravdivý).

var input;
if(input === undefined){
  doThis();
} else {
  doThat();
}

Hodnota undefined se chová jako false, je-li použita v booleovském kontextu. Následující kód například funkci myFunction vykoná, protože prvek myArray je undefined:

var myArray = [];
if (!myArray[0]) myFunction(); 

Je-li hodnota undefined použita v číselném kontextu, převede se na NaN.

var a;
a + 2;  // vyhodnotí se jako NaN

Při vyhodnocování proměnné s hodnotou null se null chová jako 0 v číselném kontextu a jako false v booleovském kontextu. Například:

var n = null;
console.log(n * 32); // Zapíše 0 do konzole

Rámec působnosti proměnné (scope)

Deklarujeme-li proměnnou vně jakékoliv funkce, pak ji nazýváme globální proměnnou, protože je dostupná i ve zbylých částech kodu dokumentu. Pokud deklarujeme proměnnou uvnitř funkce, označujeme ji jako lokální proměnnou, protože je dostupná pouze v jejím rámci.

JavaScript neměl před ECMAScript 2015 scope pro příkaz bloku; přesněji řečeno, proměnná deklarovaná v rámci bloku je lokální vzhledem k funkci (nebo globálnímu scope), v níž je blok umístěn. Následující kód například vypíše 5, protože scope proměnné x je funkce (nebo globální kontext), v jejímž rámci je x deklarováno, nikoliv blok, což je v tomto případě příkaz if.

if (true) {
  var x = 5;
}
console.log(x);  // 5

Toto chování se změní, použijeme-li deklaraci pomocí let zavedeného v ECMAScriptu 2015.

if (true) {
  let y = 5;
}
console.log(y);  // ReferenceError: y není definováno

Hoisting proměnných

Další neobvyklou záležitost týkající se proměnných v JavaScriptu představuje skutečnost, že můžeme odkazovat na proměnnou, která je deklarována až později, aniž bychom způsobili výjimku. Tento koncept je znám jako hoisting (vyzdvihnutí); proměnné v JavaScriptu jsou obrazně „vyzdvihnuty“ nebo „vytaženy“ na začátek funkce či příkazu. Proměnné, které jsou vyzdvihnuty, ale vrátí hodnotu undefined. Takže i když proměnnou deklarujete a inicializujete po tom, co ji použijete, nebo se na ni odkážete, vrátí stejně hodnotu undefined.

/**
 * Příklad 1
 */
console.log(x === undefined); // vypíše "true"
var x = 3;

/**
 * Příklad 2
 */
// vrátí hodnotu undefined
var myvar = "moje hodnota";
 
(function() {
  console.log(myvar); // undefined
  var myvar = "lokální hodnota";
})();

Předcházející příklad bude interpretován stejně jako tento:

/**
 * Příklad 1
 */
var x;
console.log(x === undefined); // vypíše "true"
x = 3;
 
/**
 * Example 2
 */
var myvar = "moje hodnota";
 
(function() {
  var myvar;
  console.log(myvar); // undefined
  myvar = "lokální hodnota";
})();

Kvůli hoistingu by měly být veškeré příkazy var použité uvnitř funkce umístěny nejblíž jejímu začátku. Tento osvědčený postup zlepšuje srozumitelnost kódu.

V ECMAScriptu 2015, let (const) „nevyzdvihne“ proměnnou na začátek bloku. Nicméně odkazování se na tuto proměnnou v předchozím bloku skončí chybou ReferenceError. Tato proměnná je od začátku bloku až po deklaraci v „dočasně mrtvé zóně“.

console.log(x); // ReferenceError
let x = 3;

Hoisting funkcí

Pro funkce platí, že je „vyzdvihována“ jen jejich deklarace, nikoliv samotný výraz function.

/* Deklarace funkce */

foo(); // "bar"

function foo() {
  console.log("bar");
}


/* Výraz function */

baz(); // TypeError: baz není funkce

var baz = function() {
  console.log("bar2");
};

Globální proměnné

Globální proměnné jsou ve skutečnosti vlastnostmi globálního objektu. V případě webových stránek je jím window, můžeme tedy ke globálním proměnným přistupovat pomocí syntaxe window.promenna a stejně tak i do nich zapisovat.

Následkem toho můžeme přistupovat ke globálním proměnným deklarovaným v jednom okně (rámu) z jiného okna (rámu) uvedením názvu tohoto okna (rámu). Pokud je například v dokumentu deklarována proměnná phoneNumber, můžeme na ni odkazovat z iframe rámu pomocí parent.phoneNumber.

Konstanty

Klíčovým slovem const můžeme vytvářet pojmenované konstanty, které lze pouze číst. Syntaxe identifikátoru konstanty je stejná jako u identifikátoru proměnné: musí začínat písmenem, podtržítkem nebo znakem dolaru a může obsahovat alfranumerické znaky nebo podtržítko.

const PI = 3.14;

Konstanta nemůže měnit hodnotu přiřazením nebo opakovanou deklarací během vykonávání skriptu. Hodnota jí musí být přiřazena již při inicializaci.

Pro konstanty platí stejná pravidla týkající se scope jako u proměnných bloku deklarovaných pomocí let. Pokud je klíčové slovo const vynecháno, zachází se s identifikátorem jako s běžnou proměnnou.

Konstanta nemůže nést stejné jméno jako funkce nebo proměnné ve stejné scope. Například:

// TOTO ZPŮSOBÍ CHYBU
function f() {};
const f = 5;

// TOTO TAKÉ ZPŮSOBÍ CHYBU
function f() {
  const g = 5;
  var g;

  // příkazy
}

Vlastnosti objektů přiřazených konstantě takto chráněny ale nejsou, proto lze následující kód bez problémů vykonat.

const MY_OBJECT = {"key": "value"};
MY_OBJECT.key = "otherValue";

Datové struktury a typy

Datové typy

Poslední verze ECMAScript standardu definuje sedm datových typů:

  • Šest datovýh typů je označováno jako primitivní:
    • Boolean. true (pravda) a false (nepravda).
    • null. Speciální klíčové slovo označující nulovou hodnotu. Protože JavaScript rozlišujemalá a velká písmena, null nepředstavuje to samé co Null, NULL nebo jakákoliv jiná varianta.
    • undefined. Vlastnost nejvyšší úrovně, jejíž hodnota není definována.
    • Number. 42 nebo 3.14159.
    • String. "Nazdar"
    • Symbol (nové v ECMAScript 6). Datový typ, jehož instance jsou unikátní a neměnné.
  • a Object

Ačkoliv je množství těchto datových typů poměrně malé, umožňuje nám v aplikaci vytvářet užitečné funkce. Dalšími základními prvky tohoto jazyka jsou Objekty a funkce. Objekty si můžeme představit jako pojmenované kontejnery pro různé hodnoty a funkce jako procedury, které umí naše aplikace vykonávat.

Konverze datových typů

JavaScript je jazyk s dynamickým typováním. To znamená, že při deklaraci proměnné nemusíme specifikovat její datový typ a že datové typy jsou podle potřeby měněny automaticky při výkonu skriptu. Proměnnou proto můžeme definovat například takto:

var answer = 42;

Později můžeme té samé proměnné přiřadit řetězcovou hodnotu, například:

answer = "Thanks for all the fish...";

Protože je JavaScript dynamicky typovaný, nezpůsobí toto přiřazení chybu.

Ve výrazech zahrnujících současně číselné i řetězcové hodnoty převede JavaScript číselné hodnoty na řetězce. Podívejme se na tyto příklady:

x = "The answer is " + 42 // "The answer is 42"
y = 42 + " is the answer" // "42 is the answer"

Ve výrazech zahrnujících jiné operátory JavaScript převod čísla na řetězec neprovádí. Například:

"37" - 7 // 30
"37" + 7 // "377"

Převod řetězců na čísla

Pro případ, kdy jsou v paměti čísla uložena jako řetězce, existují následující metody pro převod.

parseInt vrátí pouze celé číslo, takže pro desetinná čísla se jeho použití nehodí. Navíc se doporučuje pro parseInt vždy uvádět i radix parametr. Ten specifikuje číselný základ soustavy, která má být pro převod použita.

Alternativou pro získání čísla z řetězce je použití operátoru + (unární plus):

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   
// Poznámka: závorky jsou přidány pro slepší čitelnost,
// nejsou vyžadovány.

Literály

Literály v JavaScriptu používáme pro reprezentaci hodnoty. Jde o neměnné hodnoty, které přímo (literally) uvádíme ve skriptu. Tato podkapitola popisuje následující typy literálů:

Literály pole

Literál pole představuje výčet nula a více výrazů, kde každý z nich reprezentuje prvek pole. Celý výčet je uzavřen v hranatých závorkách ([]). Když vytváříme pole pomocí literálu, iniciují se jeho prvky se specifikovanými hodnotami a jeho délka je nastavena na jejich počet.

Následující příklad vytvoří pole coffees se třemi prvky a délkou tři:

var coffees = ["French Roast", "Colombian", "Kona"];

Poznámka: Literál pole je typ objektového inicializátoru. Víz kapitolu Použití objektových inicializátorů.

Je-li pole vytvořeno pomocí literálu ve skriptu na nejvyšší úrovni, JavaScript jej interpretuje při každém vyhodnocení výrazu, v němž je pole obsaženo. Kromě toho, literál použitý uvnitř funkce se opakovaně vytváří při každém jejím volání.

Literály pole jsou také Array objekty. Viz ArrayIndexované kolekce pro více podrobností o Array objektech.

Nadbytečné čárky v literálech pole

V literálu pole není nutné specifikovat všechny prvky. Pokud umístíme dvě čárky za sebou, vytvoří se pole s hodnotami undefined pro nespecifikované prvky. Následující příklad vytvoří pole fish:

var fish = ["Lion", , "Angel"];

Toto pole obsahuje dva prvky s hodnotami a jeden prázdný prvek (fish[0] je „Lion“, fish[1] je undefinedfish[2] je „Angel“).

Pokud uvedeme čárku na konci výčtu prvků, bude ignorována. V následujícím příkladu je dílka pole tři. Prvek myList[3] neexistuje. Všechny ostatní čárky ve výčtu poukazují na nový prvek.

Poznámka: Čárky na konci výčtu prvků pole mohou ve starších prohlížečích vyvolat chybu, proto se doporučuje je odstraňovat.

var myList = ['home', , 'school', ];

V následujícím příkladu je délka pole čtyři a prvky myList[0] a myList[2] chybí.

var myList = [ , 'home', , 'school'];

V následujícím příkladu je délka pole čtyři a prvky myList[1]myList[3] chybí. Poslední čárka je ignorována.

var myList = ['home', , 'school', , ];

Pochopení toho, jak se nadbytečné čárky chovají, je důležité pro porozumění JavaScriptu jako jazyku. Nicméně při psaní vlastního kódu bychom měli chybějící prvky explicitně deklarovat jako undefined, abychom zachovali jeho čitelnost a udržovatelnost.

Boolean literály

Datový typ Boolean type má dvě hodnoty: true (pravda) a false (nepravda).

Nezaměňujte primitivní boolean hodnoty truefalse s hodnotami true a false používanými v souvislosti s objektem Boolean. Objekt Boolean je obálkou nad primitivním datovým typem Boolean. Více informací v kapitole Boolean.

Celočíselné literály

Celá čísla mohou být vyjádřena v desítkové (základ 10), šestnáctkové/hexadecimální (základ 16), osmičkové (základ 8) nebo binární/dvojkové (základ 2) soustavě.

  • Celé číslo v desítkové soustavě je vyjádřeno posloupností číslic bez úvodní nuly.
  • Úvodní nula nebo úvodní posloupnost 0o (nebo 0O) v celočíselném literálu indikuje použití osmičkové soustavy. Celá čísla v osmičkové soustavě mohou obsahovat pouze číslice 0-7.
  • Úvodní posloupnost 0x (nebo 0X) indikuje šestnáctkovou soustavu. Celá čísla v šestnáctkové soustavě mohou obsahovat číslice 0–9 a písmena a–f (A–F).
  • Úvodní posloupnost 0b (nebo 0B) indikuje dvojkovou soustavu. Celá čísla v binární soustavě mohou obsahovat pouze číslice 0 a 1.

Několik příkladů celočíselných literálů:

0, 117 and -345 (desítková, základ 10)
015, 0001 and -0o77 (osmičková, základ 8) 
0x1123, 0x00111 and -0xF1A7 (šestnáctková, "hex" or základ 16)
0b11, 0b0011 and -0b11 (dvojková, základ 2)

Více informací v kapitole Číselné literály v Příručce lexikální gramatiky.

Literály čísla s pohyblivou řadovou tečkou

Literál čísla s pohyblivou řadovou tečkou může mít následující části:

  • celé číslo případně se znaménkem (uvozené znakem „+“ nebo „-“),
  • desetinný oddělovač („.“),
  • desetinná část (další celé číslo),
  • exponent.

Exponentová část je reprezentována znakem „e“ nebo „E“ následovaným celým číslem, které může být doplněno znaménkem (uvozeno „+“ nebo „-“). Literál čísla s pohyblivou řadovou tečkou musí obsahovat aspoň jednu číslici a buď desetinný oddělovač, nebo „e“ (či„E“).

Stručněji, syntaxe je následující:

[(+|-)][číslice][.číslice][(E|e)[(+|-)]číslice]

Například:

3.1415926
-.123456789
-3.1E+12
.1e-23

Objektové literály

Objektový literál je výčet nula a více dvojic pojmenovaných vlastností a jim přiřazených hodnot objektu; uzavřený ve složených závorkách ({}). Objektový literál by neměl být používán na začátku příkazu, protože pak by otevírající složená závorka ({ ) byla reprezentována jako začátek bloku.

Následující ukázka kódu je příkladem objektového literálu. První prvek objektu car definuje vlastnost myCar a přiřazuje jí hodnotu "Saturn"; druhému prvku, vlastnosti getCar je bezprostředně přiřazen výsledek volání funkce (carTypes("Honda")); třetí prvek, vlastnost special, využívá existující proměnné (sales).

var sales = "Toyota";

function carTypes(name) {
  if (name === "Honda") {
    return name;
  } else {
    return "Sorry, we don't sell " + name + ".";
  }
}

var car = { myCar: "Saturn", getCar: carTypes("Honda"), special: sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota 

Pro pojmenování vlastnosti navíc můžeme použít číselný nebo řetězcový literál a objekty do sebe můžeme vnořovat. To ilustruje následující příklad.

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

Názvem pro vlastnost objektu může být jakýkoliv řetězec, včetně prázdného. V případě, že název vlastnosti není platným javascriptovým identifikátorem a není ani číslem, musí být uzavřen v uvozovkách. K vlastnostem, jejichž název není platným identifikátorem, rovněž nelze přistupovat tečkovou notací (.), k jejich hodnotě ale můžeme číst a měnit pomocí stejné notace, jakou používají pole ("[]").

var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // SyntaxError: Unexpected string
console.log(unusualPropertyNames[""]);  // An empty string
console.log(unusualPropertyNames.!);    // SyntaxError: Unexpected token !
console.log(unusualPropertyNames["!"]); // Bang!

ECMAScript 2015 rozšiřuje objektové literály o možnost nastavení prototypu již ve fázi konstrukce, čímž je zkratkou pro foo: foo přiřazení, definici metod, uskutečnění volání super a výpočet názvů vlastností pomocí výrazů. Dohromady tyto možnosti vzájemně přibližují objektové literály a definice tříd, a umožňují tak objektově založenému návrhu těžit z těch samých užitečných možností..

var obj = {
    // __proto__
    __proto__: theProtoObj,
    // Zkratka pro "handler: handler"
    handler,
    // metody
    toString() {
     // volání super
     return "d " + super.toString();
    },
    // (Dynamicky) vypočtené názvy vlastností
    [ 'prop_' + (() => 42)() ]: 42
};

Všimněte si, že:

var foo = {a: "alpha", 2: "two"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // two
//console.log(foo.2);  // Error: missing ) after argument list
//console.log(foo[a]); // Error: a is not defined
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two

Literály regulárního výrazu

Regex literál je regulární výraz uzavřený mezi lomítka. Například:

var re = /ab+c/;

Řetězcové literály

Řetězcový literál představuje nula a více znaků uzavřených mezi dvojité (") nebo jednoduché (') uvozovky. Řetězec musí být ukončen stejným typem uvozovek, to znamená, že buď musí být obě uvozovky jednoduché nebo obě dvojité. Například:

"foo"
'bar'
"1234"
"jedna radka \n druha radka"
"John's cat"

Nad řetězcovým literálem můžeme volat libovolné metody objektu String — JavaScript automaticky převede literál na dočasný String objekt, zavolá požadovanou metodu a pak dočasný objekt zruší. U řetězcového literálu lze také používat vlastnost String.length:

console.log("John's cat".length) 
// Vytiskne počet znaků v řetězci včetně bílých znaků. 
// V tomto případě 10.

ECMAScript 2015 přináší také šablonové literály. Šablonové řetězce poskytují syntactic sugar pro sestavování řetězců. Jde o konstrukci podobnou interpolaci v Perlu, Pythonu a dalších jazycích. Volitelně může být přidán tag, který umožňuje přizpůsobení konstrukce řetězce, předcházení injection útokům nebo konstrukci datových struktur vyšší úrovně z částí řetězce.

// Vytvoření základního řetězcového literálu
`In JavaScript '\n' is a line-feed.`

// Víceřádkový řetězec
`In JavaScript this is
 not legal.`

// interpolace řetězce
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=${a}&b=${b}
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);

Řetězcové literály bychom měli používat, dokud přímo nepotřebujeme použít String objekt. Více informací o String objektu v kapitole String.

Použití speciálních znaků v řetězcích

Mimo běžné znaky lze v řetězcích uvádět i speciální znaky, což znázorňuje následující příklad:

"one line \n another line"

Tabulka níže obsahuje výčet speciálních znaků, které lze používat v řetězcích v rámci JavaScriptu.

Tabulka: Speciální znaky v JavaScriptu
Znak Význam
\0 Null Byte
\b Posun kurzoru o znak vzad
\f Posun kurzoru na další tiskovou stránku
\n Odřádkování
\r Posun kurzoru na začátek řádku
\t Posun kurzoru na další zarážku tabulátoru
\v Vertikální tabulátor
\' Apostrof/jednoduchá uvozovka
\" Dvojitá uvozovka
\\ Zpetné lomítko
\XXX Znak s kódovánímThe Latin-1 specifikovaný až třemi číslicemi osmičkové soustavy XXX v rozsahu 0 až 377. Například \251 je osmičkovou sekvencí pro symbol copyrightu.
\xXX Znak s kódováním Latin-1 specifikovaný dvěma šestnáctkovými číslicemi XX v rozsahu 00 až FF. Například \xA9 je šestnáctkovou sekvencí pro symbol copyrightu.
\uXXXX Unicode znak specifikovaný čtyřmi šestnáctkovými číslicemi XXXX. Například \u00A9 je Unicode sekvencí pro symbol copyrightu. Viz Unicode escape sekvence.
\u{XXXXX} Unicode code point escapes. Například \u{2F804} je stejné jako dvě jednoduché Unicode escape sekvence \uD87E\uDC04.

Escapování znaků

Pro znaky, které nejsou uvedený v tabulce, se uvozující zpětné lomítko ignoruje. Takové použití ale není schvalované a měli bychom se mu vyhýbat.

Do řetězce může být vložen symbol uvozovky, je-li uvozen zpětným lomítkem. Říkáme tomu escapování uvozovek. Například:

var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);

Výsledkem by bylo:

He read "The Cremation of Sam McGee" by R.W. Service.

Abychom mohli v řetězci uvést zpětné lomítko, musíme je rovněž escapovat. Například, chceme-li přiřadit do proměnné cestu k souboru c:\temp to a string, uděláme to následovně:

var home = "c:\\temp";

Také zalomení řádek mohou být escapována, pokud před nimi uvedeme zpětné lomítko. Zalomení i lomítko jsou pak odstraněny z hodnoty řetězce.

var str = "this string \
is broken \
across multiple\
lines."
console.log(str);   // this string is broken across multiplelines.

Přestože JavaScript nedisponuje „heredoc“ syntaxí, lze se jí přiblížit vkládáním escape znaku pro nový řádek před escapovaný konec každého fyzického řádku:

var poem = 
"Roses are red,\n\
Violets are blue.\n\
I'm schizophrenic,\n\
And so am I."

Více informací

Tato kapitola se zaměřuje na základy syntaxe deklarace a typů. Chcete-li se anučit víc o jazykových konstrukcích JavaScriptu, podívejte se také na následující kapitolyobsažené v tomto průvodci:

V další kapitole se podíváme na řídicí struktury a zpracování chyb.

Štítky a přispěvatelé do dokumentace

 Přispěvatelé této stránky: kajda90
 Poslední aktualizace od: kajda90,