Grammatik und Typen

Dieses Kapitel behandelt die grundlegende Grammatik von JavaScript, Deklaration von Variablen, Datentypen und Objektinstanzen.

Grundlagen

JavaScript leiht sich den größten Teil seiner Syntax von Java, ist aber auch von Sprachen wie Awk, Perl und Python beeinflusst.,

JavaScript ist case-sensitive, unterscheidet also zwischen Groß- und Kleinschreibung, und benutzt den Unicode-Zeichensatz.

In JavaScript heißen Anweisungen "statements"  und werden durch ein Semikolon (;) voneinander getrennt. Leerzeichen, Tabulatoren und Zeilenumbrüche werden "Whitespace" genannt. Der Quelltext von JavaScript wird vom Interpreter von links nach rechts gelesen und in Sequenzen von Eingabe-Elementen wie JavaScript-Tokens, Steuerzeichen, Zeichenumbrüche, Kommentare und Objektinstanzen (Literale) umgewandelt. ECMAScript beschreibt für den Interpreter reservierte Schlüsselwörter sowie Objektinstanzen und hat eingebaute Regeln für die automatische Einfügung von Semikola (ASI) um Anweisungen zu beenden. Es wird jedoch empfohlen jede Anweisung mit einem Semikolon zu beenden; dies vermeidet ungewollte Nebeneffekte. Mehr Informationen dazu sind in der detaillierten Referenz über JavaScript's lexikalische Grammatik zu finden.

Kommentare

Die Syntax con Kommentaren ist die selbe wie in C++ und in vielen anderen Sprachen:

// Einzeiliger Kommentar
 
/* Das ist ein langer, 
   mehrzeiliger Kommentar
 */
 
/* Man kann keine Kommentare, /* Verschachteln */ SyntaxError */

Deklarationen

Es gibt drei mögliche Arten Variablen zu deklarieren:

var

Deklariert eine Variable unabhängig von ihrem Scope (Gültigkeitsbereich).

let

Deklariert eine im Scope (Gültigkeitsbereich) lokale Variable.

const

Deklariert eine unveränderbare Variable.

Variablen

Variablen werden benutzt, um Werte zu speichern. Dabei vergibt man einer Variable einen Namen, der identifier genannt wird, unter bestimmten Regeln.

Ein JavaScript Bezeichner muss mit einem Buchstaben, Unterstriche (_) oder einem Dollarzeichen ($) beginnen. Die nachfolgenden Zeichen können anschließend auch Zahlen sein. Da JavaScript case-sensitiv ist, wird zwischen Groß- und Kleinschreibung unterschieden und somit repräsentiert ein "A" einen anderen Buchstaben als "a".

Es kann der Großteil der ISO 8859-1 und Unicode Zeichen benutzt werden, wie z.B. ü oder auch å, aber auch Unicode escape sequences können genutz werden.

Beispiele für zulässige Bezeichner sind Number_hits, temp99 und _name.

Variablendeklaration

Die Deklaration einer Variable ist durch drei unterschiedliche Wege möglich:

• Mit dem Schlüsselwort var, wie var x = 42. Die Syntax kann benutz werden, um Variablen lokal und global zu deklarieren.
• Mit dem Zuweisen einer Variable, wie x = 42. Die Syntax definiert immer eine globale Variable. Auf diese Deklaration sollte jedoch nicht zurückgegriffen werden.
• Mit dem Schlüsselwort let , wie let x = 42. Die Syntax kann benutz werden, um Variablen nur für ihren Scope (Gültigkeitsbereich) zu deklarieren. Siehe Variablen Scope.

Variablen auswerten

Eine Variable die mit var ohne Initialisierung deklariert wurde hat den Wert undefined.

Der Zugriff auf eine nicht initialisierte Variable und der Zugriff auf eine let-Variable, bevor diese Initialisiert wurde,  erzeugt einen ReferenceError Fehler:

var a;
console.log("Der Wert von a ist " + a); // Der Wert von a ist undefined

console.log("Der Wert von b ist " + b); // ReferenceError: b is not defined

console.log("Der Wert von c ist " + c); // Der Wert von c ist undefined
var c;

console.log("Der Wert von x ist " + x); // ReferenceError: x is not defined
let x;

undefined kann benutzt werden, um zu überprüfen ob eine Variable einen Wert hat. Im Folgenden Codebeispiel ist die Variable input keinem Wert zugewiesen worden und das if-Statement wird somit mit true evaluieren.

var input;             
if(input === undefined){  
  macheDas();             
} else {                  
  macheDasAndere();  
}

undefined verhält sich wie ein false, wenn es in einem boolschen Kontext verwendet wird. Zum Beispiel wird im Folgendem Codebeispiel die Funktion myFunction ausgeführt, weil das myArray Element undefined ist:

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

undefined wird zu NaN (Not a Number) konvertiert, wenn es in einem numerischen Kontext verwendet wird:

var a;
a + 2;  //NaN

Wenn eine null Variable ausgewertet wird, verhält sie sich im numerischen Kontext als 0 und in boolschen Kontext als false:

var n = null;                  
console.log(n * 32);  // wird 0 in die Konsole eintragen

Variablen Scope

Wird eine Variable außerhalb eines Code-Blocks deklariert wird sie eine globale Variable genannt, da sie jetzt in jedem Bereich verfügbar ist. Wenn eine Variable jedoch innerhalb eines Code-Blocks deklariert wird, so ist sie nur innerhalb dieses Blocks verfügbar und wird aus dem Grund lokale Variable genannt.

JavaScript hatte vor ECMAScript 2015 keine Block-Anweisungens Scope; Daher wurde eine deklarierte Variable in einem Block immer zu der Funktion (oder dem globalen Scope) gezählt, in dem sich der Block befindet. Zum Beispiel wird der folgende Quelltext 5 ausgeben, weil der Scope von x die Funktion (oder der globale Kontext) indem x deklariert wird ist und nicht der Block in welchem in diesem Fall eine if Anweisung ist.

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

Das Verhalten ändert sich, wenn man die in ECMAScript 2015 eingeführte let Deklaration benutzt.

if (true) {
  let y = 5;
}
console.log(y);  // ReferenceError: y is not defined

Variablen hochziehen (hoisting)

Eine andere besonderheit mit Variablen in JavaScript ist, dass man eine Variable referenzieren kann, bevor sie deklariert wurde, ohne das es zu einem Fehler kommt. Diese Konzept ist bekannt als hoisting (hochziehen); Variablen in JavaScript sind hochgezogen und leben vom Anfang der Funktion oder des Statements. Immer wenn Variablen hochgezogen werden, werden sie den Wert undefined zurückgeben. So wird immer undefined zurückgegeben, wenn man die Variablen benutzt, bevor sie deklariert und initialisiert wurde.

/**
 * Beispiel 1
 */
console.log(x === undefined); // true
var x = 3;

/**
 * Beispiel 2
 * wird den Wert undefined zurückgeben 
 */
var myvar = "my value";
 
(function() {
  console.log(myvar); // undefined
  var myvar = "local value";
})();

Das obere Beispiel wird genauso interpretiert, wie das folgende Beispiel:

/**
 * Beispiel 1
 */
var x;
console.log(x === undefined); // true
x = 3;
 
/**
 * Beispiel 2
 */
var myvar = "my value";
 
(function() {
  var myvar;
  console.log(myvar); // undefined
  myvar = "local value";
})();

Wegen des Hochziehens sollten alle var Anweisungen so weit am Anfang der Funktion wie nur möglich platziert werden. Dieses Vorgehen verbessert die Qualität des Quelltextes.

In ECMAScript 2015 wird let (bzw. const) nicht an den Anfang eines Blocks hochgezogen. Immer wenn die Variable in dem Block referenziert wird bevor die Deklaration durchgeführt wurde, wird ein ReferenceError erzeugt. Die Variable ist in einer "temporären toten Zone", die vom Start des Blocks bis zur Deklaration der Variablen besteht.

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

Funktionen hochziehen (hoisting)

Bei Funktionen (nur Funktionsdeklarationen) werden die Deklarationen ebenfalls nach oben gezogen. Bei Funktionsausdrücken gilt dieses jedoch nicht.

/* Funktionsdeklaration */

foo(); // "bar"

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


/* Funktionsausdruck */

baz(); // TypeError: baz ist keine Funktion

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

Globale Variablen

Globale Variablen sind faktisch Eigenschaften des globalen Objekts. In Webseiten ist das globale Objekt das window Objekt, so dass globale Variablen gesetzt und erreicht werden können, indem die Syntax window.variable eingesetzt wird.

Folglich kann man globale Variablen, die in einem window oder frame deklariert wurden, aus einem anderen window oder Frame erreichen, indem der window oder framename angegeben wird. Zum Beispiel kann eine Variable phoneNumber, die in einem Dokument deklariert wurde, von einem iframe mit parent.phoneNumber erreicht werden.

Konstanten

Man kann eine nur lesende, benamte Konstante mit dem Schlüsselwort const erstellen. Die Syntax für einen Konstantenbezeichner ist die selbe, wie für Variablenbezeichner: Er muss mit einem Buchstaben, Unterstrich oder Dollarzeichen beginnen und kann alphabetische Zeichen, nummerische Zeichen und Unterstiche enthalten.

const PI = 3.14;

Der Wert einer Konstanten kann nicht durch Zuweisungen oder Neudeklarationen werden, während das Skript läuft. Konstanten müssen deswegen initialisiert werden.

Die Sichtbarkeitsregeln (Scope) bei Konstanten sind die gleichen, wie für let Blockscope Variablen. Wenn das Schösselwort const weggelassen wird, wird vorausgesetzt, dass der der Bezeichner eine  Variable repräsentiert.

Man kann keine Konstante mit dem gleichen Namen einer Funktion oder Variablen im gleiche Gültigkeitsbereich deklarieren. Zum Beispiel:

// DAS WIRD ZU EINEM ERROR FÜHREN
function f() {};
const f = 5;

// DAS WIRD EBENFALLS ZU EINEM ERROR FÜHREN 
function f() {
  const g = 5;
  var g;

  //statements
}

Immer, wenn Objektattribute nicht geschützt sind, werden die folgende Anweisungen ohne Probleme ausgeführt.

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

Datenstrukturen und -typen

Datentypen

Der neuste ECMAScript Standard definiert sieben Datentypen:

• Sechs Datentypen sind primitive Datentypen:
  • Boolean. true und false.
  • null. Eine spezielles Schlüsselwort, was einen null-Wert kennzeichnet. Weil JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist null nicht das selbe wie Null, NULL oder einen andere Variante.
  • undefined. Ein Eigenschaft, wessen Wert undefined ist.
  • Number. 42 oder 3.14159.
  • String. "Zeichenkette"
  • Symbol (neu in ECMAScript 2015). Ein Datentyp, bei dem Instanzen einzigartig und unveränderlich sind.
• und Object

Obwohl die Anzahl Datentypen relativ klein ist, eröffnen sie die Möglich nützliche Funktionen für Applikationen zu erstellen. Objects und functions sind die anderen fundamentalen Elemente der Sprache. Man sich Objekte als benamte Container für Werte und Funktionen als Verfahren, die die Applikation ausführen kann, vorstellen.

Datentypkonvertierungen

JavaScript ist eine dynamisch typisierte Sprache. Das bedeutet, dass man den Datentypen einer Variable bei der Deklaration nicht mit angibt. Der Datentyp wird während der Ausführung automatisch konvertiert, wenn es notwendig ist. So kann folgendermaßen eine Variable definiert werden:

var answer = 42;

Und Später kann der gleichen Variablen eine Zeichenkette zugewiesen werden:

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

Weil JavaScript dynamisch typisiert ist, erzeugt diese Zuweisung keinen Fehler im Programm.

In Ausdrücken, in denen Zahlen und Zeichenketten mit dem + Operator gebraucht werden, konvertiert JavaScript die Zahlen in Zeichenketten. Sie dazu das folgende Beispiel:

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

In Ausdrücken mit anderen Operatoren, konvertiert JavaScript zahlen nicht in Zeichenketten. Zum Beispiel:

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

Konvertieren von Zeichenketten zu Zahlen

In Fällen, in denen eine Zahl durch einen String repräsentiert wird, gibt es folgende Methoden, um die Zeichenkette in eine Zahl umzuwandeln.

• parseInt()
• parseFloat()

parseInt gibt nur ganze Zahlen zurück, weshalb der Einsatz für Dezimalzahlen nicht geeignet ist. Zu einem guten Programmiertstiel gehört, dass man immer die Basis bei parseInt mit angibt. Dieser Parameter der Methode gibt an, aus welchem Zahlensystem die Zahl stammt.

Eine alternative Methode, um einen String in eine Zahl zu konvertieren ist der + (unär Plus) Operator:

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   
// Hinweis: die hinzugefügten Klammern sind nur für die Lesbarkeit.

Literale

Man benutzt Literale, um in JavaScript Werte zu repräsentieren. Diese sind feste Werte, keine Variablen, die man in einem Skript einsetzt. Dies Kapitel beschreibt die folgeden Literaltypen:

• Array Literale
• Boolean Literale
• Gleitkomma Literale
• Ganze Zahlen
• Objekt Literale
• RegExp Literale
• String Literale

Array Literal

Ein Array Literal ist eine Liste von null oder mehr Ausdrücken. Jeder Ausdruck repräsentiert ein Element des Arrays. Diese Elemente sind von eckigen Klammern ([]) umschlossen. Wenn ein Array mit einem Array Literal erstellt wird, wird das Array mit allen definierten Elementen initialisiert und die länge des Arrays wird auf die Menge der Elemente gesetzt.

Das folgende Beispiel erstellt das coffees Array mit drei Elementen und der Länge drei:

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

Wenn ein Array durch ein Literal im Toplevel Skript erstellt wird, interpretiert JavaScript dieses Array immer, wenn ein Ausdruck dieses Literal enthält. Im Gegensatz dazu wird ein Literal in einer Funktion immer neu erstellt, wenn die Funktion aufgerufen wird.

Array Literale sind ebenfalls Array Objekte. Für mehr Details siehe Array und Indexed collections.

Extra Kommas in Array Literalen

Man muss nicht alle Elemente in einem Array Literal spezifizieren. Wenn man zwei Kommas in einer Reihe verwendet, wird das Array mit einem undefined Element erstellt. Das folgende Beispiel erstellt das fish Array:

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

Dieses Array hat zwei Elemente mit Werten und ein leeres Element (fish[0] ist "Lion", fish[1] ist undefined und fish[2] ist "Angel").

Wenn man ein trennendes Komma am ende der Elementliste hinzufügt, wird dieses ignoriert. Im folgenden Beispiel ist die Länge des Arrays drei. Es gibt kein myList[3]. Alle weiteren Kommas in der Liste führen zu einem neuen Element.

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

Im folgenden Beispiel hat das Array vier Elemente und myList[0] und myList[2] sind nicht spezifiziert.

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

Im folgenden Beispiel hat das Array vier Elemente und myList[1] und myList[3] sind nicht spezifiziert. Nur das letzte Komma wird ignoriert.

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

Das Verständnis für das Verhalten von extra Kommas ist wichtig, um JavaScript als Sprache zu verstehen, wenn man sein eigenen Quelltext schreibt. Das explizite Deklarieren von fehlenden Elementen mit undefined steigert die Lesbarkeit und Wartbarkeit des Quelltextes.

Boolean Literale

Der Boolean Typ hat zwei Literale: true und false.

Man sollte die primitiven Werte true und false jedoch nicht mit den Werten true und false des Boolean Objektes verwechseln. Das Boolean Objekt ist eine Hülle um den primitiven Boolean Datentypen. Siehe im Artikel Boolean für weitere Informationen.

Ganze Zahlen

Ganze Zahlen können als Dezimal- (Basis 10), Hexadezimal- (Basis 16), Oktal- (Basis 8) und Binärzahl (Basis 2) ausgedrückt werden.

• Eine Dezimalzahlenliteral besteht aus einer Sequenz von Ziffern ohne eine führende 0.
• Eine führende 0 oder 0o (oder 0O) bei einem Zahlenliteral deutet eine Oktalzahl an. Oktalzahlen können nur die Ziffern 0 bis 7 enthalten.
• Ein führendes 0x (oder 0X) deutet eine Hexadezimalzahl an. Hexadezimalzahlen können als Ziffern die Werte 0 bis 9 und die Buchstaben a bis f bzw. A bis F enthalten.
• Ein führendes 0b (oder 0B) deutet eine Binärzahl an. Binärzahlen können als Ziffern nur 0 und 1 enthalten.

Im folgenden Beispiel sind einige Beispiele für Zahlenliterale:

0, 117 and -345 (dezimal, Basis 10)
015, 0001 and -0o77 (oktal, Base 8) 
0x1123, 0x00111 and -0xF1A7 (hexadezimal, "hex", Base 16)
0b11, 0b0011 and -0b11 (binär, Base 2)

Für weitere Informationen siehe Numerische Literale in der Lexikalischen Grammatik Referenz.

Gleitkomma Literale

Ein Gleitkomma Literal kann die folgenden Abschnitte beinhalten:

• Eine dezimale ganze Zahl, welche mit einem Vorzeichen ("+" oder "-") versehen sein kann.
• Ein Dezimalpunkt (".").
• Ein Nachkommazahl (weitere Dezimalzahl).
• Ein Exponent.

Der Exponent besteht aus einem "e" oder "E" gefolgt von einer ganzen Zahl, welche mit einem Vorzeichen ("+" oder "-") versehen sein kann. Eine Gleitkommazahl muss mindestens aus einer Ziffer und entweder einem Dezimalpunkt oder einem "e" (oder "E") bestehen.

Kurz und knapp sieht die Syntax folgendermaßen aus:

[(+|-)][ziffern][.ziffern][(E|e)[(+|-)]ziffern]

Zum Beispiel:

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

Objekt Literale

Ein Objekt Literal ist eine Liste von null oder mehr Paaren von Eigenschaftsnamen und -werten, umschlossen von geschweiften Klammern ({}). Man sollte kein Objekt Literal am Anfang eines Statements benutzen. Dieses wird zu einem Fehler führen oder nicht wie erwartet funktionieren, weil der {-Zeichen als Anfang eines Blocks interpretiert wird.

Im Folgenden  ist ein Beispiel für ei Objekt Literal. Das erste Element des car Objektes definiert eine Eigenschaft, myCar, und beschreibt diese mit einem neuen String, "Saturn". Dam zweiten Element, der getCar Eigenschaft, wird der Rückgabewert der aufgerufenen Funktion (carTypes("Honda")) zugewiesen. Das dritte Element, die special Eigenschaft, benutzt eine existierende Variable (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 

Für die Namen der Eigenschaften kann auch ein String oder ein Zahlen Literal verwendet werden. Für den Wert kann auch ein verschachteltes Objekt Literal genutzt werden. Das folgende Beispiel nutzt diese Optionen.

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

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

Die Namen von Objekteigenschaften können ein String sein, was auch den leeren String beinhaltet. Wenn die Eigenschaftsnamen keine gültigen JavaScript Bezeichner sind, müssen in Anführungszeichen geschrieben werden. Eigenschaftsnamen die keine gültigen Bezeichner sind, können nicht mit der Punktschreibweise (.) erreicht werden. Diese können mit der Array ähnlichen Notation erreicht werden ("[]").

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!

In ES2015 wurde das Objekt Literal dahingehend erweitert, dass der Prototyp bei der Erstellung gesetzt werden. Desweiteren sind neue Funktionalitäten hinzugekommen, die eine Kurzschreibweise für foo: foo Zuweisungen, die Definitionen für Methoden, das Aufrufen von super Methoden und die Berechnung der Eigenschaftsnamen mit Ausdrücken ermöglichen. Alle diese Funktionen bringen Klassendefinition und Objekt Literale näher zusammen und somit sind objektbasierte Desigs manchmal vorteilhafter und bequemer.

var obj = {
    // __proto__
    __proto__: theProtoObj,
    // Shorthand for ‘handler: handler’
    handler,
    // Methods
    toString() {
     // Super calls
     return "d " + super.toString();
    },
    // Computed (dynamic) property names
    [ 'prop_' + (() => 42)() ]: 42
};

Bitte beachten:

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

RegExp Literale

Ein RegExp Literal ist ein Muster (Pattern) umschlossen von Schrägstrichen (slashes). Das folgende ist ein Beispiel für ein RegExp Literal:

var re = /ab+c/;

String Literale

Ein String Literal besteht aus null oder mehr Zeichen, die von doppelten (") oder einfachen (') Anführungszeichen umschlossen sind. Ein String muss immer von gleichen Anführungszeichen umschlossen sein. Entweger immer von einfachen oder von doppelten Anführungszeichen. Im folgenden Beispiel sind ein paar String Literale gezeigt:

"foo"
'bar'
"1234"
"eine Zeile \n weitere Zeile"
"John's cat"

Man kann alle Methoden des String Objektes auf einem String Literal aufrufen, denn JavaScript konvertiert das Literal automatisch in ein temporäres String Objekt, führt die Methode aus und verwirft danach das temporäre Objekt. Man kann auch die String.length Eigenschaft mit einem String Literal benutzen:

console.log("John's cat".length) 
// Wird die Anzahl der Zeichen (auch Leerzeichen) ausgeben. 
// In diesem Fall 10.

In ES2015, wurden zudem Template Literale eingeführt. Template Strings bieten syntaktischen Zucker für das erstellen von Strings an. Dieses ist vergleichbar mit den String Interpolation Funktion in Perl Python und anderen Sprachen. Optional können Marken eingefügt werden, um einen String benutzerdefiniert zu erstellen. Diese vermeiden Injection-Attacken und ermöglichen es Datenstrukturen in Strings unterzubringen.

// Standardliteral für die String erstellung
`In JavaScript '\n' is a line-feed.`

// Mehrzellige Strings
`In JavaScript this is
 not legal.`

// String Interpolation
var name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

// Erstellung einer HTTP Anfrage.
POST`https://foo.org/bar?a=${a}&b=${b}
     Content-Type: application/json
     X-Credentials: ${credentials}
     { "foo": ${foo},
       "bar": ${bar}}`(myOnReadyStateChangeHandler);

Man sollte String Literale benutzen, sofern man nicht explizit ein Objekt benötigt. Für weitere Informationen siehe im String Artikel nach.

Einsatz von Sonderzeichen in Strings

Neben den normalen Zeichen ist es auch möglich Sonderzeichen in einem String zu verwenden. Ein Beispiel ist im folgenden zu sehen:

"eine Zeile \n nächste Zeile"

Die folgende Tabelle Zeigt die Sonderzeichen, die in JavaScript Strings verwendet werden können:

Escaping Zeichen

Für nicht in der Tabelle gezeigte Zeichen wird ein vorangegangenes Backslash ignoriert. Dieser Einsatz von Backslash ist Veraltet und sollte vermieden werden.

Man kann Anführungszeichen in einen String hinzufügen, indem ein Führendes Backslash eingesetzt wird. Das wird auch escaping der Anführungszeichen genannt. Ein Beispiel:

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

Das Ergebniss ist:

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

Um ein Backslash in einem String zu verwenden, muss dieses mit einem Backslash escapet werden. Zum Beispiel muss der Pfad c:\temp wie folgt geschrieben werden:

var home = "c:\\temp";

Man kann zudem Zeilenumbrüche mit einem vorangegangenen Backslash escapen. Das Backslash und der Zeilenumbruch werden aus dem String entfernt.

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

JavaScript hat keinen "heredoc" Syntax. Dafür muss am Ende jeder Zeile einem Zeilenumbruch (\n) gefolgt von einem Backslash geschreiben werden:

var poem = 
"Roses are red,\n\
Violets are blue.\n\
Sugar is sweet,\n\
and so is foo."

Mehr Informationen

Dieses Kapitel beschränkt sich auf die Basissyntax für Deklarationen und Typen. Um mehr über die Sprachkonstrukte von JavaScript zu lernen siehe in die folgenden Kapitel dieses Guides:

• Kontrollfluss und Fehlerbehandlung
• Schleifen und Iterationen
• Funktionen
• Ausdrücke und Operatoren

Im nächsten Kapitel wird ein Blick auf Kontrollflüsse und Fehlerbehandlungen geworfen.