Werte, Variablen und Literale

  • Adressname der Version: JavaScript/javascript_guide/Werte,_Variablen_und_Literale
  • Titel der Version: Werte, Variablen und Literale
  • ID der Version: 13069
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar 81 words added, 106 words removed

Inhalt der Version

Dieses Kapitel informiert über die Werte mit denen JavaScript arbeitet und beschreibt die grundlegenden Elemente von Ausdrücken: Variablen, Konstanten und Literale.

Werte

JavaScript kennt die folgenden verschiedenen Typen von Werten:

  • Numbers (numerische Werte), wie 42 or 3.14159
  • Boolean (boolesche Werte),  true oder false
  • Strings (Zeichenketten), wie z.B. "Hallo!"
  • null, ein spezielles Schlüsselwort, das einen null-Wert beschreibt; null ist auch ein primitiver Wert. Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist null nicht dasselbe wie Null, NULL oder jede andere Variante.
  • undefined, eine Top-Level-Eigenschaft, deren Wert undefiniert ist; undefined ist auch ein primitiver Wert.

Dieser relativ kleine Satz von unterschiedlichen Typen für Werte, auch Datentypen genannt, ermöglicht die Erstellung nützlicher Funktionen in Applikationen. Es gibt keine echte Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen, beide sind vom Typ Number. Bei Operationen mit Kalenderdaten, Zeitpunkten und Datumsformaten kann mit dem Date-Objekt gearbeitet werden.

Objekte und Funktionen sind weitere Kernelemente der Sprache. Objekte kann man sich wie benannte Container für Werte vorstellen und Funktionen wie Prozeduren, die in der Applikation ausgeführt werden können.

Konvertierung von Datentypen

Javascript ist eine dynamisch typisierte Programmiersprache. Das bedeutet, dass der Typ einer Variablen nicht festgelegt werden muss, bevor ihr ein Wert zugewiesen wird. Eine Variable muss also nicht erst durch die Spezifikation eines Datentyps deklariert werden, wie meist bei anderen Programmiersprachen. Außerdem werden Datentypen automatisch so konvertiert, wie sie bei der Ausführung des Skripts benötigt werden.

Eine Variable kann z.B. so definiert werden:

var antwort = 42;

Später kann man derselben Variablen z.B. einen String zuweisen:

antwort = "Danke für den Fisch...";

Da Javascript dynamisch typisiert ist, erzeugt diese Zuweisung keine Fehlermeldung.

Wenn man in Ausdrücken numerische Werte (Numbers) und Zeichenketten (Strings) mit dem Operator + (Pluszeichen) verbindet, werden die numerischen Werte von Javascript automatisch in Strings umgewandelt:

x = "Die Antwort ist " + 42  // ergibt: "Die Antwort ist 42"
y = 42 + " ist die Antwort"  // ergibt: "42 ist die Antwort"

Werden bei Ausdrücken jedoch andere Operatoren verwendet, konvertiert Javascript den Wert nicht automatisch zu einem String:

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

Konvertieren von Strings zu Numbers

Falls sich ein numerischer Wert in Form eines Strings im Speicher befindet, kann er mit passenden Methoden konvertiert werden.

parseInt() and parseFloat()

Siehe: parseInt() und parseFloat().

Die Methode parseInt gibt ausschließlich ganze Zahlen zurück, daher ist ihr Nutzen auf Dezimalzahlen beschränkt. Bei parseInt sollte man immer den radix-Parameter mit angeben.

Plus-Operator

Eine alternative Methode, um einen numerischen Wert aus einem String zu erhalten, ist die Verwendung des Operators + (Pluszeichen). 

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   // Anführungszeichen dienen der Übersichtlichkeit, nicht unbedingt nötig.

Variablen

Variablen werden als symbolische Namen für Werte eingesetzt. Die Namen der Variablen werden Bezeichner (oder engl. Identifier) genannt und folgen gewissen Regeln.

Ein JavaScript-Bezeichner muss mit einem Buchstaben, Unterstrich (_) oder Dollar-Zeichen ($) beginnen. Die darauf folgenden Zeichen dürfen auch Ziffern sein (0-9). Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, sind mit Buchstaben sowohl "A" bis "Z" (Großbuchstaben)  als auch "a" bist "z" (Kleinbuchstaben) gemeint.

Ab JavaScript 1.5 sind bei Bezeichnern auch Buchstaben aus den Zeichensätzen ISO 8859-1 oder Unicode wie å oder ü erlaubt. Außerdem dürfen auch die \uXXXX {{ web.link("#Unicode_escape_sequences", "Unicode-Escape-Sequenzen") }} bei Identifiern verwendet werden.

Ein paar Beispiele von zulässigen Bezeichnern: Number_hits, temp99, and _name.

Deklarieren von Variablen

Variablen kann man auf zwei verschiedene Arten deklarieren:

  • Mit dem Schlüsselwort var, welches dem Bezeichner vorangestellt wird: var x = 42. Auf diese Weise können sowohl lokale als auch globale Variablen deklariert werden.
  • Indem einfach der Wert der Variablen zugewiesen wird: x = 42. Dies erzeugt immer eine globale Variable und eine strikte JavaScript-Warnung. Deshalb wird von dieser Vorgehensweise abgeraten.

Auswerten von Variablen

Eine Variable, die mit dem var-Schlüsselwort deklariert wurde, ohne dass ihr ein Wert zugewiesen wurde, besitzt den Wert undefined.

Der Versuch, auf eine undeklarierte Variable zuzugreifen, scheitert mit dem Ergebnis einer ReferenceError-Ausnahmebehandlung:

var a;
console.log("Der Wert von a ist " + a); // gibt aus: "Der Wert von a ist undefined"
console.log("Der Wert von b ist " + b); // erzeugt ReferenceError-Ausnahmebehandlung

Ersteres Verhalten kann man sich zunutze machen, um zu überprüfen, ob eine Variable einen Wert enthält. Im folgenden Code-Beispiel wurde der Variablen myVar kein Wert zugewiesen und die Prüfung mit einer if-Anweisung ergibt deshalb true.

var myVar;
if(myVar === undefined){
  alert("myVar ist kein Wert zugewiesen.");
} else {
  alert("myVar ist ein Wert zugewiesen.");
}

Folgende Erläuterungen hängen mit den Erklärungen der Variablen zusammen, als potentielle Werte bei Zuweisungen. The following is related to "Variables" section as potential values in assignment.

Der Wert undefined evaluiert zu false, wenn er in einem booleschen Kontext verwendet wird. Zum Beispiel wird bei folgendem Code die Funktion myFunction ausgeführt, weil das Element myArray nicht definiert ist:

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

In numerischem Kontext wird undefined hingegen zu NaN konvertiert:

var a;
a + 2 = NaN

Eine Variable, die mit null deklariert ist, evaluiert in numerischem Kontext zu 0 und in booleschem Kontext zu false:

var n = null;
console.log(n * 32); // prints 0

Sichtbarkeitsbereich (Scope) von Variablen

Eine Variable, die außerhalb einer Funktion deklariert wird, ist eine globale Variable. Globale Variablen sind im ganzen Programm sichtbar und der Zugriff kann über den Code im Dokument von beliebiger Stelle aus erfolgen. Hingegen sind Variablen, die innerhalb von Funktionen definiert werden, lokale Variablen, die nur innerhalb der Funktion angesprochen werden können.

JavaScript grenzt die Sicherheitbarkeit von Block-Anweisungen nicht ab. Variablen innerhalb von Block-Anweisungen sind lokal zu dem Code, in dem sich der Block befindet. Zum Beispiel wird der folgende Code 5 in der Konsole ausgeben, weil die Sichtbarkeit von x die Funktion (oder der globale Kontext) ist, in der x deklariert wurde und nicht der Block der if-Anweisung.

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

Eine weitere Besonderheit bei Variablen in JavaScript ist, dass man sich auf eine Variable beziehen kann, die erst später deklariert wurde, ohne einen Ausnahmefehler zu erhalten. Dieses Konzept ist als "hoisting" (engl. Hochziehen) bekannt. Variablen in JavaScript werden gewissermaßen zum Anfang der Funktion hochgezogen oder angehoben. Jedoch liefern uninitialisierte Variablen den Wert undefined.

// Beispiel 1

console.log(x === undefined); // loggt "true"
var x = 3;


// Beispiel 2

// gibt undefined zurück
var myVar = "mein Wert";

(function() {
  console.log(myVar); // undefined
  var myVar = "lokaler Wert";
})();

Das Beispiel 2 oben wird vom JavaScript-Interpreter so gedeutet:

var myVar = "mein Wert";

(function() {
  var myVar;  // hoisting
  console.log(myVar); // undefined
  myVar = "lokaler Wert";
})();

Aufgrund des "hoisting" sollten alle var-Anweisungen in einer Funktion so nahe wie möglich an den Anfang platziert werden. Diese Vorgehensweise verbessert die Übersichtlichkeit des Codes.

Globale Variablen

need links to pages discussing scope chains and the global object

Globale Variablen sind tatsächlich Eigenschaften des globalen Objekts. Bei Websiten ist das globale Objekt window, sodass man globale Variablen über die Syntax window.variable ansprechen kann.

Globale Variablen, die in einem Fenster oder Frame deklariert wurden, lassen sich von einem anderen Fenster aus ansprechen, indem man den Namen des Fensters oder Frames spezifiziert. Wenn z.B. eine Variable Telefonnummer in einem FRAMESET deklariert wurde, lässt sich diese von den Frames aus ansprechen.

Konstanten

Mit dem Schlüsselwort const erzeugt man Konstanten. Die Syntax für Bezeichner von Konstanten ist dieselbe wie bei Variablen.

const prefix = '212';

A constant cannot change value through assignment or be re-declared while the script is running.

The scope rules for constants are the same as those for variables, except that the const keyword is always required, even for global constants. If the keyword is omitted, the identifier is assumed to represent a variable.

You cannot declare a constant with the same name as a function or variable in the same scope. For example:

// THIS WILL CAUSE AN ERROR
function f() {};
const f = 5;

// THIS WILL CAUSE AN ERROR ALSO
function f() {
  const g = 5;
  var g;

  //statements
}

Literals

You use literals to represent values in JavaScript. These are fixed values, not variables, that you literally provide in your script. This section describes the following types of literals:

  • {{ web.link("#Array_literals", "Array literals") }}
  • {{ web.link("#Boolean_literals", "Boolean literals") }}
  • {{ web.link("#Floating-point_literals", "Floating-point literals") }}
  • {{ web.link("#Integers", "Integers") }}
  • {{ web.link("#Object_literals", "Object literals") }}
  • {{ web.link("#String_literals", "String literals") }}

Array literals

An array literal is a list of zero or more expressions, each of which represents an array element, enclosed in square brackets ([]). When you create an array using an array literal, it is initialized with the specified values as its elements, and its length is set to the number of arguments specified.

The following example creates the coffees array with three elements and a length of three:

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

Note An array literal is a type of object initializer. See Using Object Initializers.

If an array is created using a literal in a top-level script, JavaScript interprets the array each time it evaluates the expression containing the array literal. In addition, a literal used in a function is created each time the function is called.

Array literals are also Array objects. See Array Object for details on Array objects.

Extra commas in array literals

You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with undefined for the unspecified elements. The following example creates the fish array:

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

This array has two elements with values and one empty element (fish[0] is "Lion", fish[1] is undefined, and fish[2] is "Angel").

If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no myList[3]. All other commas in the list indicate a new element. (Note trailing commas can create errors in older browser versions and it is a best practice to remove them)

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

In the following example, the length of the array is four, and myList[0] and myList[2] are missing.

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

In the following example, the length of the array is four, and myList[1] and myList[3] are missing. Only the last comma is ignored.

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

Understanding the behavior of extra commas is important to understanding JavaScript as a language, however when writing your own code: explicitly declaring the missing elements as undefined will increase your code's clarity and maintainability.

Boolean literals

The Boolean type has two literal values: true and false.

Do not confuse the primitive Boolean values true and false with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. See Boolean Object for more information.

Integers

Integers can be expressed in decimal (base 10), hexadecimal (base 16), and octal (base 8).

  • Decimal integer literal consists of a sequence of digits without a leading 0 (zero).
  • Leading 0 (zero) on an integer literal indicates it is in octal.  Octal integers can include only the digits 0-7.
  • Leading 0x (or 0X) indicates hexadecimal. Hexadecimal integers can include digits (0-9) and the letters a-f and A-F.

Octal integer literals are deprecated and have been removed from the ECMA-262, Edition 3 standard (in strict mode). JavaScript 1.5 still supports them for backward compatibility.

Some examples of integer literals are:

0, 117 and -345 (decimal, base 10)
015, 0001 and -077 (octal, base 8) 
0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)

Floating-point literals

A floating-point literal can have the following parts:

  • A decimal integer which can be signed (preceded by "+" or "-"),
  • A decimal point ("."),
  • A fraction (another decimal number),
  • An exponent.

The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E").

Some examples of floating-point literals are 3.1415, -3.1E12, .1e12, and 2E-12.

More succinctly, the syntax is:

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

For example:

3.14
2345.789
.3333333333333333333

Object literals

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.

The following is an example of an object literal. The first element of the car object defines a property, myCar; the second element, the getCar property, invokes a function (CarTypes("Honda")); the third element, the special property, uses an existing variable (Sales).

var Sales = "Toyota";

function CarTypes(name) {
  return (name == "Honda") ?
    name :
    "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 

Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.

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

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

Please note:

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

String literals

A string literal is zero or more characters enclosed in double (") or single (') quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:

  • "foo"
  • 'bar'
  • "1234"
  • "one line \n another line"
  • "John's cat"

You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the String.length property with a string literal:

"John's cat".length

You should use string literals unless you specifically need to use a String object. See String Object for details on String objects.

Using special characters in strings

In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.

"one line \n another line"

The following table lists the special characters that you can use in JavaScript strings.

Table 2.1 JavaScript special characters
Character Meaning
\b Backspace
\f Form feed
\n New line
\r Carriage return
\t Tab
\v Vertical tab
\' Apostrophe or single quote
\" Double quote
\\ Backslash character (\).
\XXX The character with the Latin-1 encoding specified by up to three octal digits XXX between 0 and 377. For example, \251 is the octal sequence for the copyright symbol.
\xXX The character with the Latin-1 encoding specified by the two hexadecimal digits XX between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol.
\uXXXX The Unicode character specified by the four hexadecimal digits XXXX. For example, \u00A9 is the Unicode sequence for the copyright symbol. See {{ web.link("#Unicode_escape_sequences", "Unicode escape sequences") }}.

Escaping characters

For characters not listed in Table 2.1, a preceding backslash is ignored, but this usage is deprecated and should be avoided.

You can insert a quotation mark inside a string by preceding it with a backslash. This is known as escaping the quotation mark. For example:

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

The result of this would be:

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

To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path c:\temp to a string, use the following:

var home = "c:\\temp";

You can also escape line breaks by preceding them with backslash.  The backslash and line break are both removed from the value of the string.

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

Although JavaScript does not have "heredoc" syntax, you can get close by adding a linebreak escape and an escaped linebreak at the end of each line:

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

Unicode

Unicode is a universal character-coding standard for the interchange and display of principal written languages. It covers the languages of the Americas, Europe, Middle East, Africa, India, Asia, and Pacifica, as well as historic scripts and technical symbols. Unicode allows for the exchange, processing, and display of multilingual texts, as well as the use of common technical and mathematical symbols. It hopes to resolve internationalization problems of multilingual computing, such as different national character standards. Not all modern or archaic scripts, however, are currently supported.

The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.

Unicode is not supported in versions of JavaScript prior to 1.3.

Unicode compatibility with ASCII and ISO

Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646.

Several encoding standards (including UTF-8, UTF-16 and ISO UCS-2) are used to physically represent Unicode as actual bits.

The UTF-8 encoding of Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses a 7-bit character set, UTF-8 uses between one and four octets for each character ("octet" meaning a byte, or 8 bits.) This allows for several million characters. An alternative encoding standard, UTF-16, uses two octets to represent Unicode characters. An escape sequence allows UTF-16 to represent the whole Unicode range by using four octets. The ISO UCS-2 (Universal Character Set) uses two octets.

JavaScript and Navigator support for UTF-8/Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since the UTF-8 encoding of Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments, string literals, identifiers, and regular expressions of JavaScript.

Unicode escape sequences

You can use the Unicode escape sequence in string literals, regular expressions, and identifiers. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.

The following code returns the copyright symbol and the string "Netscape Communications".

var x = "\u00A9 Netscape Communications";

The following table lists frequently used special characters and their Unicode value.

Table 2.2 Unicode values for special characters
Category Unicode value Name Format name
White space values \u0009 Tab <TAB>
\u000B Vertical Tab <VT>
\u000C Form Feed <FF>
\u0020 Space <SP>
Line terminator values \u000A Line Feed <LF>
\u000D Carriage Return <CR>
Additional Unicode escape sequence values \u0008 Backspace <BS>
\u0009 Horizontal Tab <HT>
\u0022 Double Quote "
\u0027 Single Quote '
\u005C Backslash \

The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (e.g., \u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.

Unicode characters in JavaScript files

Earlier versions of Gecko assumed the Latin-1 character encoding for JavaScript files loaded from XUL. Starting with Gecko 1.8, the character encoding is inferred from the XUL file's encoding. Please see International characters in XUL JavaScript for more information.

Displaying characters with Unicode

You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Mozilla Firefox or Netscape needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide partial support for Unicode.

To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Sometimes, the only way to input Unicode characters is by using Unicode escape sequences.

For more information on Unicode, see the Unicode Home Page and The Unicode Standard, Version 2.0, published by Addison-Wesley, 1996.

autoPreviousNext("JSGChapters");
wiki.languages({
  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/JavaScript_概要",
  "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript",
  "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript",
  "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu",
  "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8"
});

Quelltext der Version

<p>Dieses Kapitel informiert über die Werte mit denen JavaScript arbeitet und beschreibt die grundlegenden Elemente von Ausdrücken: Variablen, Konstanten und Literale.</p>
<h2>Werte</h2>
<p>JavaScript kennt die folgenden verschiedenen Typen von Werten:</p>
<ul> <li><a href="/en/JavaScript/Reference/Global_Objects/Number" title="en/JavaScript/Reference/Global Objects/Number">Numbers</a> (numerische Werte), wie 42 or 3.14159</li> <li><a href="/en/JavaScript/Reference/Global_Objects/Boolean" title="en/JavaScript/Reference/Global Objects/Boolean">Boolean (boolesche Werte</a>),  <code>true</code> oder <code>false</code></li> <li><a href="/en/JavaScript/Reference/Global_Objects/String" title="en/JavaScript/Reference/Global Objects/String">Strings</a> (Zeichenketten), wie z.B. "Hallo!"</li> <li><code>null</code>, ein spezielles Schlüsselwort, das einen null-Wert beschreibt; <code>null</code> ist auch ein primitiver Wert. Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, ist <code>null</code> nicht dasselbe wie <code>Null</code>, <code>NULL</code> oder jede andere Variante.</li> <li><code><a href="/en/JavaScript/Reference/Global_Objects/undefined" title="en/JavaScript/Reference/Global Objects/undefined">undefined</a></code>, eine Top-Level-Eigenschaft, deren Wert undefiniert ist; <code>undefined</code> ist auch ein primitiver Wert.</li>
</ul>
<p>Dieser relativ kleine Satz von unterschiedlichen Typen für Werte, auch <em>Datentypen</em> genannt, ermöglicht die Erstellung nützlicher Funktionen in Applikationen. Es gibt keine echte Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen, beide sind vom Typ <em>Number</em>. Bei Operationen mit Kalenderdaten, Zeitpunkten und Datumsformaten kann mit dem <code><a href="/en/JavaScript/Reference/Global_Objects/Date" title="en/JavaScript/Reference/Global Objects/Date">Date</a></code>-Objekt gearbeitet werden.</p>
<p><a href="/en/JavaScript/Reference/Global_Objects/Object" title="en/JavaScript/Reference/Global Objects/Object">Objekte</a> und <a href="/en/JavaScript/Reference/Global_Objects/Function" title="en/JavaScript/Reference/Global Objects/Function">Funktionen </a>sind weitere Kernelemente der Sprache. Objekte kann man sich wie benannte Container für Werte vorstellen und Funktionen wie Prozeduren, die in der Applikation ausgeführt werden können.</p>
<h3>Konvertierung von Datentypen</h3>
<p>Javascript ist eine dynamisch typisierte Programmiersprache. Das bedeutet, dass der Typ einer Variablen nicht festgelegt werden muss, bevor ihr ein Wert zugewiesen wird. Eine Variable muss also nicht erst durch die Spezifikation eines Datentyps deklariert werden, wie meist bei anderen Programmiersprachen. Außerdem werden Datentypen automatisch so konvertiert, wie sie bei der Ausführung des Skripts benötigt werden.</p>
<p>Eine Variable kann z.B. so definiert werden:</p>
<pre class="brush: js"><code>var antwort = 42;</code>
</pre>
<p>Später kann man derselben Variablen z.B. einen String zuweisen:</p>
<pre class="brush: js">antwort = "Danke für den Fisch...";
</pre>
<p>Da Javascript dynamisch typisiert ist, erzeugt diese Zuweisung keine Fehlermeldung.</p>
<p>Wenn man in Ausdrücken numerische Werte (Numbers) und Zeichenketten (Strings) mit dem Operator <code>+</code> (Pluszeichen) verbindet, werden die numerischen Werte von Javascript automatisch in Strings umgewandelt:</p>
<pre class="brush: js">x = "Die Antwort ist " + 42  // ergibt: "Die Antwort ist 42"
y = 42 + " ist die Antwort"  // ergibt: "42 ist die Antwort"
</pre>
<p>Werden bei Ausdrücken jedoch andere Operatoren verwendet, konvertiert Javascript den Wert nicht automatisch zu einem String:</p>
<pre class="brush: js">"37" - 7 // returns 30
"37" + 7 // returns "377"
</pre>
<h3>Konvertieren von Strings zu Numbers</h3>
<p>Falls sich ein numerischer Wert in Form eines Strings im Speicher befindet, kann er mit passenden Methoden konvertiert werden.</p>
<h4><code>parseInt()</code> and <code>parseFloat()</code></h4>
<p>Siehe: <code><a href="/en/JavaScript/Reference/Global_Objects/parseInt" title="en/JavaScript/Reference/Global Objects/parseInt">parseInt()</a></code> und <code><a href="/en/JavaScript/Reference/Global_Objects/parseFloat" title="en/JavaScript/Reference/Global Objects/parseFloat">parseFloat()</a></code>.</p>
<p>Die Methode <code>parseInt</code> gibt ausschließlich ganze Zahlen zurück, daher ist ihr Nutzen auf Dezimalzahlen beschränkt. Bei <code>parseInt</code> sollte man immer den radix-Parameter mit angeben.</p>
<h4>Plus-Operator</h4>
<p>Eine alternative Methode, um einen numerischen Wert aus einem String zu erhalten, ist die Verwendung des Operators + (Pluszeichen). </p>
<pre class="brush: js">"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   // Anführungszeichen dienen der Übersichtlichkeit, nicht unbedingt nötig.
</pre>
<h2><a name="Variablen">Variablen</a></h2><a name="Variablen">
<p>Variablen werden als symbolische Namen für Werte eingesetzt. Die Namen der Variablen werden <em>Bezeichner (</em>oder engl. <em>Identifier)</em> genannt und folgen gewissen Regeln.</p>
<p>Ein JavaScript-Bezeichner muss mit einem Buchstaben, Unterstrich (_) oder Dollar-Zeichen ($) beginnen. Die darauf folgenden Zeichen dürfen auch Ziffern sein (0-9). Da JavaScript zwischen Groß- und Kleinschreibung unterscheidet, sind mit Buchstaben sowohl "A" bis "Z" (Großbuchstaben)  als auch "a" bist "z" (Kleinbuchstaben) gemeint.</p>
<p>Ab JavaScript 1.5 sind bei Bezeichnern auch Buchstaben aus den Zeichensätzen ISO 8859-1 oder Unicode wie å oder ü erlaubt. Außerdem dürfen auch die \uXXXX {{ web.link("#Unicode_escape_sequences", "Unicode-Escape-Sequenzen") }} bei Identifiern verwendet werden.</p>
<p>Ein paar Beispiele von zulässigen Bezeichnern: <code>Number_hits</code>, <code>temp99</code>, and <code>_name</code>.</p>
<h3>Deklarieren von Variablen</h3>
<p>Variablen kann man auf zwei verschiedene Arten deklarieren:</p>
</a><ul><a name="Variablen"> </a><li><a name="Variablen">Mit dem Schlüsselwort </a><a href="/en/JavaScript/Reference/Statements/var" title="en/JavaScript/Reference/Statements/var">var</a>, welches dem Bezeichner vorangestellt wird: <code>var x = 42</code>. Auf diese Weise können sowohl<a href="#Variable_Scope"> lokale als auch globale</a> Variablen deklariert werden.</li> <li>Indem einfach der Wert der Variablen zugewiesen wird: <code>x = 42</code>. Dies erzeugt immer eine <a href="#Global_Variables">globale Variable</a> und eine strikte JavaScript-Warnung. Deshalb wird von dieser Vorgehensweise abgeraten.</li>
</ul>
<h3>Auswerten von Variablen</h3>
<p>Eine Variable, die mit dem <code>var</code>-Schlüsselwort deklariert wurde, ohne dass ihr ein Wert zugewiesen wurde, besitzt den Wert <code><a href="/en/JavaScript/Reference/Global_Objects/undefined" title="en/JavaScript/Reference/Global Objects/undefined">undefined</a></code>.</p>
<p>Der Versuch, auf eine undeklarierte Variable zuzugreifen, scheitert mit dem Ergebnis einer <code>ReferenceError</code>-Ausnahmebehandlung:</p>
<pre class="brush: js">var a;
console.log("Der Wert von a ist " + a); // gibt aus: "Der Wert von a ist undefined"
console.log("Der Wert von b ist " + b); // erzeugt ReferenceError-Ausnahmebehandlung
</pre>
<p>Ersteres Verhalten kann man sich zunutze machen, um zu überprüfen, ob eine Variable einen Wert enthält. Im folgenden Code-Beispiel wurde der Variablen <code>myVar</code> kein Wert zugewiesen und die Prüfung mit einer <code>if</code>-Anweisung ergibt deshalb <code>true</code>.</p>
<pre class="brush: js">var myVar;
if(myVar === undefined){
  alert("myVar ist kein Wert zugewiesen.");
} else {
  alert("myVar ist ein Wert zugewiesen.");
}
</pre>
<p><span class="comment">Folgende Erläuterungen hängen mit den Erklärungen der Variablen zusammen, als potentielle Werte bei Zuweisungen. The following is related to "Variables" section as potential values in assignment.</span></p>
<p>Der Wert <code>undefined</code> evaluiert zu <code>false</code>, wenn er in einem booleschen Kontext verwendet wird. Zum Beispiel wird bei folgendem Code die Funktion <code>myFunction</code> ausgeführt, weil das Element <code>myArray</code> nicht definiert ist:</p>
<pre class="eval deki-transform">var myArray = new Array();
if (!myArray[0]) myFunction(); 
</pre>
<p>In numerischem Kontext wird <code>undefined</code> hingegen zu <code>NaN</code> konvertiert:</p>
<pre class="deki-transform">var a;
a + 2 = NaN</pre>
<p>Eine Variable, die mit <code>null</code> deklariert ist, evaluiert in numerischem Kontext zu 0 und in booleschem Kontext zu <code>false</code>:</p>
<pre class="eval deki-transform">var n = null;
console.log(n * 32); // prints 0
</pre>
<h3>Sichtbarkeitsbereich (Scope) von Variablen</h3>
<p>Eine Variable, die außerhalb einer Funktion deklariert wird, ist eine globale Variable. Globale Variablen sind im ganzen Programm sichtbar und der Zugriff kann über den Code im Dokument von beliebiger Stelle aus erfolgen. Hingegen sind Variablen, die innerhalb von Funktionen definiert werden, lokale Variablen, die nur innerhalb der Funktion angesprochen werden können.</p>
<p>JavaScript grenzt die Sicherheitbarkeit von <a href="/en/JavaScript/Guide/Statements#Block_Statement" title="en/JavaScript/Guide/Statements#Block Statement">Block-Anweisungen</a> nicht ab. Variablen innerhalb von Block-Anweisungen sind lokal zu dem Code, in dem sich der Block befindet. Zum Beispiel wird der folgende Code <code>5</code> in der Konsole ausgeben, weil die Sichtbarkeit von x die Funktion (oder der globale Kontext) ist, in der x deklariert wurde und nicht der Block der <code>if</code>-Anweisung.</p>
<pre class="eval deki-transform">if (true) {
  var x = 5;
}
console.log(x);
</pre>
<p>Eine weitere Besonderheit bei Variablen in JavaScript ist, dass man sich auf eine Variable beziehen kann, die erst später deklariert wurde, ohne einen Ausnahmefehler zu erhalten. Dieses Konzept ist als "hoisting" (engl. Hochziehen) bekannt. Variablen in JavaScript werden gewissermaßen zum Anfang der Funktion <em>hochgezogen</em> oder angehoben. Jedoch liefern uninitialisierte Variablen den Wert <code>undefined</code>.</p>
<pre class="brush: js"><code>// Beispiel 1

console.log(x === undefined); // loggt "true"
var x = 3;


// Beispiel 2

// gibt undefined zurück
var myVar = "mein Wert";

(function() {
  console.log(myVar); // undefined
  var myVar = "lokaler Wert";
})();</code>
</pre>
<p>Das Beispiel 2 oben wird vom JavaScript-Interpreter so gedeutet:</p>
<pre class="brush: js"><code>var myVar = "mein Wert";

(function() {
  var myVar;  // hoisting
  console.log(myVar); // undefined
  myVar = "lokaler Wert";
})();</code>
</pre>
<p>Aufgrund des "hoisting" sollten alle <code>var</code>-Anweisungen in einer Funktion so nahe wie möglich an den Anfang platziert werden. Diese Vorgehensweise verbessert die Übersichtlichkeit des Codes.</p>
<h3>Globale Variablen</h3>
<p><span style="color:#d3d3d3;"><span class="comment">need links to pages discussing scope chains and the global object</span></span></p>
<p>Globale Variablen sind tatsächlich Eigenschaften des <em>globalen Objekts</em>. Bei Websiten ist das globale Objekt <code><a href="/en/DOM/window" title="en/DOM/window">window</a></code>, sodass man globale Variablen über die Syntax <code>window.<em>variable</em></code> ansprechen kann.</p>
<p>Globale Variablen, die in einem Fenster oder Frame deklariert wurden, lassen sich von einem anderen Fenster aus ansprechen, indem man den Namen des Fensters oder Frames spezifiziert. Wenn z.B. eine Variable <code>Telefonnummer</code> in einem <code>FRAMESET</code> deklariert wurde, lässt sich diese von den Frames aus ansprechen.</p>
<h2>Konstanten</h2>
<p>Mit dem Schlüsselwort <code><a href="/en/JavaScript/Reference/Statements/const" title="en/Core_JavaScript_1.5_Reference/Statements/const">const</a></code> erzeugt man Konstanten. Die Syntax für Bezeichner von Konstanten ist dieselbe wie bei Variablen.</p>
<pre class="eval deki-transform">const prefix = '212';
</pre>
<p>A constant cannot change value through assignment or be re-declared while the script is running.</p>
<p>The scope rules for constants are the same as those for variables, except that the <code>const</code> keyword is always required, even for global constants. If the keyword is omitted, the identifier is assumed to represent a variable.</p>
<p>You cannot declare a constant with the same name as a function or variable in the same scope. For example:</p>
<pre class="eval deki-transform">// THIS WILL CAUSE AN ERROR
function f() {};
const f = 5;

// THIS WILL CAUSE AN ERROR ALSO
function f() {
  const g = 5;
  var g;

  //statements
}
</pre>
<h2>Literals</h2>
<p>You use literals to represent values in JavaScript. These are fixed values, not variables, that you <em>literally</em> provide in your script. This section describes the following types of literals:</p>
<ul> <li>{{ web.link("#Array_literals", "Array literals") }}</li> <li>{{ web.link("#Boolean_literals", "Boolean literals") }}</li> <li>{{ web.link("#Floating-point_literals", "Floating-point literals") }}</li> <li>{{ web.link("#Integers", "Integers") }}</li> <li>{{ web.link("#Object_literals", "Object literals") }}</li> <li>{{ web.link("#String_literals", "String literals") }}</li>
</ul>
<h3>Array literals</h3>
<p>An array literal is a list of zero or more expressions, each of which represents an array element, enclosed in square brackets ([]). When you create an array using an array literal, it is initialized with the specified values as its elements, and its length is set to the number of arguments specified.</p>
<p>The following example creates the <code>coffees</code> array with three elements and a length of three:</p>
<pre class="eval deki-transform">var coffees = ["French Roast", "Colombian", "Kona"];
</pre>
<p><strong>Note</strong> An array literal is a type of object initializer. See <a href="/en/JavaScript/Guide/Working_with_Objects#Using_Object_Initializers" title="en/JavaScript/Guide/Working with Objects#Using Object Initializers">Using Object Initializers</a>.</p>
<p>If an array is created using a literal in a top-level script, JavaScript interprets the array each time it evaluates the expression containing the array literal. In addition, a literal used in a function is created each time the function is called.</p>
<p>Array literals are also <code>Array</code> objects. See <a href="/en/JavaScript/Guide/Predefined_Core_Objects#Array_Object" title="en/JavaScript/Guide/Predefined Core Objects#Array Object">Array Object</a> for details on <code>Array</code> objects.</p>
<h4>Extra commas in array literals</h4>
<p>You do not have to specify all elements in an array literal. If you put two commas in a row, the array is created with <code>undefined</code> for the unspecified elements. The following example creates the <code>fish</code> array:</p>
<pre class="eval deki-transform">var fish = ["Lion", , "Angel"];
</pre>
<p>This array has two elements with values and one empty element (<code>fish[0]</code> is "Lion", <code>fish[1]</code> is <code>undefined</code>, and <code>fish[2]</code> is "Angel").</p>
<p>If you include a trailing comma at the end of the list of elements, the comma is ignored. In the following example, the length of the array is three. There is no <code>myList[3]</code>. All other commas in the list indicate a new element. (<strong>Note</strong> trailing commas can create errors in older browser versions and it is a best practice to remove them)</p>
<pre class="eval deki-transform">var myList = ['home', , 'school', ];
</pre>
<p>In the following example, the length of the array is four, and <code>myList[0]</code> and <code>myList[2]</code> are missing.</p>
<pre class="eval deki-transform">var myList = [ , 'home', , 'school'];
</pre>
<p>In the following example, the length of the array is four, and <code>myList[1]</code> and <code>myList[3]</code> are missing. Only the last comma is ignored.</p>
<pre class="eval deki-transform">var myList = ['home', , 'school', , ];
</pre>
<p>Understanding the behavior of extra commas is important to understanding JavaScript as a language, however when writing your own code: explicitly declaring the missing elements as <code>undefined</code> will increase your code's clarity and maintainability.</p>
<h3>Boolean literals</h3>
<p>The Boolean type has two literal values: <code>true</code> and <code>false</code>.</p>
<p>Do not confuse the primitive Boolean values <code>true</code> and <code>false</code> with the true and false values of the Boolean object. The Boolean object is a wrapper around the primitive Boolean data type. See <a href="/en/JavaScript/Guide/Predefined_Core_Objects#Boolean_Object" title="en/JavaScript/Guide/Predefined Core Objects#Boolean Object">Boolean Object</a> for more information.</p>
<h3>Integers</h3>
<p>Integers can be expressed in decimal (base 10), hexadecimal (base 16), and octal (base 8).</p>
<ul> <li>Decimal integer literal consists of a sequence of digits without a leading 0 (zero).</li> <li>Leading 0 (zero) on an integer literal indicates it is in octal.  Octal integers can include only the digits 0-7.</li> <li>Leading 0x (or 0X) indicates hexadecimal. Hexadecimal integers can include digits (0-9) and the letters a-f and A-F.</li>
</ul>
<p>Octal integer literals are deprecated and have been removed from the ECMA-262, Edition 3 standard (in <em>strict mode</em>). JavaScript 1.5 still supports them for backward compatibility.</p>
<p>Some examples of integer literals are:</p>
<pre class="eval">0, 117 and -345 (decimal, base 10)
015, 0001 and -077 (octal, base 8) 
0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
</pre>
<h3>Floating-point literals</h3>
<p>A floating-point literal can have the following parts:</p>
<ul> <li>A decimal integer which can be signed (preceded by "+" or "-"),</li> <li>A decimal point ("."),</li> <li>A fraction (another decimal number),</li> <li>An exponent.</li>
</ul>
<p>The exponent part is an "e" or "E" followed by an integer, which can be signed (preceded by "+" or "-"). A floating-point literal must have at least one digit and either a decimal point or "e" (or "E").</p>
<p>Some examples of floating-point literals are 3.1415, -3.1E12, .1e12, and 2E-12.</p>
<p>More succinctly, the syntax is:</p>
<pre class="eval">[digits][.digits][(E|e)[(+|-)]digits]
</pre>
<p>For example:</p>
<pre class="eval">3.14
2345.789
.3333333333333333333
</pre>
<h3>Object literals</h3>
<p>An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). You should not use an object literal at the beginning of a statement. This will lead to an error or not behave as you expect, because the { will be interpreted as the beginning of a block.</p>
<p>The following is an example of an object literal. The first element of the <code>car</code> object defines a property, <code>myCar</code>; the second element, the <code>getCar</code> property, invokes a function <code>(CarTypes("Honda"));</code> the third element, the <code>special</code> property, uses an existing variable (<code>Sales</code>).</p>
<pre class="eval deki-transform">var Sales = "Toyota";

function CarTypes(name) {
  return (name == "Honda") ?
    name :
    "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 
</pre>
<p>Additionally, you can use a numeric or string literal for the name of a property or nest an object inside another. The following example uses these options.</p>
<pre class="eval deki-transform">var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda
</pre>
<p>Please note:</p>
<pre class="eval deki-transform">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
</pre>
<h3>String literals</h3>
<p>A string literal is zero or more characters enclosed in double (<code>"</code>) or single (<code>'</code>) quotation marks. A string must be delimited by quotation marks of the same type; that is, either both single quotation marks or both double quotation marks. The following are examples of string literals:</p>
<ul> <li><code>"foo"</code></li> <li><code>'bar'</code></li> <li><code>"1234"</code></li> <li><code>"one line \n another line"</code></li> <li><code>"John's cat"</code></li>
</ul>
<p>You can call any of the methods of the String object on a string literal value—JavaScript automatically converts the string literal to a temporary String object, calls the method, then discards the temporary String object. You can also use the <code>String.length</code> property with a string literal:</p>
<pre class="deki-transform">"John's cat".length
</pre>
<p>You should use string literals unless you specifically need to use a String object. See <a href="/en/JavaScript/Guide/Predefined_Core_Objects#String_Object" title="en/JavaScript/Guide/Predefined Core Objects#String Object">String Object</a> for details on <code>String</code> objects.</p>
<h4>Using special characters in strings</h4>
<p>In addition to ordinary characters, you can also include special characters in strings, as shown in the following example.</p>
<pre class="eval deki-transform">"one line \n another line"
</pre>
<p>The following table lists the special characters that you can use in JavaScript strings.</p>
<table class="standard-table"> <caption style="text-align: left;">Table 2.1 JavaScript special characters</caption> <thead> <tr> <th scope="col">Character</th> <th scope="col">Meaning</th> </tr> </thead> <tbody> <tr> <td><code>\b</code></td> <td>Backspace</td> </tr> <tr> <td><code>\f</code></td> <td>Form feed</td> </tr> <tr> <td><code>\n</code></td> <td>New line</td> </tr> <tr> <td><code>\r</code></td> <td>Carriage return</td> </tr> <tr> <td><code>\t</code></td> <td>Tab</td> </tr> <tr> <td><code>\v</code></td> <td>Vertical tab</td> </tr> <tr> <td><code>\'</code></td> <td>Apostrophe or single quote</td> </tr> <tr> <td><code>\"</code></td> <td>Double quote</td> </tr> <tr> <td><code>\\</code></td> <td>Backslash character (\).</td> </tr> <tr> <td><code>\<em>XXX</em></code></td> <td>The character with the Latin-1 encoding specified by up to three octal digits <em>XXX</em> between 0 and 377. For example, \251 is the octal sequence for the copyright symbol.</td> </tr> <tr> <td><code>\x<em>XX</em></code></td> <td>The character with the Latin-1 encoding specified by the two hexadecimal digits <em>XX</em> between 00 and FF. For example, \xA9 is the hexadecimal sequence for the copyright symbol.</td> </tr> <tr> <td><code>\u<em>XXXX</em></code></td> <td>The Unicode character specified by the four hexadecimal digits <em>XXXX</em>. For example, \u00A9 is the Unicode sequence for the copyright symbol. See {{ web.link("#Unicode_escape_sequences", "Unicode escape sequences") }}.</td> </tr> </tbody>
</table>
<h4>Escaping characters</h4>
<p>For characters not listed in Table 2.1, a preceding backslash is ignored, but this usage is deprecated and should be avoided.</p>
<p>You can insert a quotation mark inside a string by preceding it with a backslash. This is known as <em>escaping</em> the quotation mark. For example:</p>
<pre class="eval deki-transform">var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);
</pre>
<p>The result of this would be:</p>
<pre class="eval">He read "The Cremation of Sam McGee" by R.W. Service.
</pre>
<p>To include a literal backslash inside a string, you must escape the backslash character. For example, to assign the file path <code>c:\temp</code> to a string, use the following:</p>
<pre class="eval deki-transform">var home = "c:\\temp";
</pre>
<p>You can also escape line breaks by preceding them with backslash.  The backslash and line break are both removed from the value of the string.</p>
<pre class="deki-transform">var str = "this string \
is broken \
across multiple\
lines."
<span class="objectBox objectBox-text ">console.log(str);</span>   // <span class="objectBox objectBox-text ">this string is broken across multiplelines.</span>
</pre>
<p>Although JavaScript does not have "heredoc" syntax, you can get close by adding a linebreak escape and an escaped linebreak at the end of each line:</p>
<pre class="deki-transform">var poem = 
"Roses are red,\n\
Violets are blue.\n\
I'm schizophrenic,\n\
And so am I."
</pre>
<h2>Unicode</h2>
<p>Unicode is a universal character-coding standard for the interchange and display of principal written languages. It covers the languages of the Americas, Europe, Middle East, Africa, India, Asia, and Pacifica, as well as historic scripts and technical symbols. Unicode allows for the exchange, processing, and display of multilingual texts, as well as the use of common technical and mathematical symbols. It hopes to resolve internationalization problems of multilingual computing, such as different national character standards. Not all modern or archaic scripts, however, are currently supported.</p>
<p>The Unicode character set can be used for all known encoding. Unicode is modeled after the ASCII (American Standard Code for Information Interchange) character set. It uses a numerical value and name for each character. The character encoding specifies the identity of the character and its numeric value (code position), as well as the representation of this value in bits. The 16-bit numeric value (code value) is defined by a hexadecimal number and a prefix U, for example, U+0041 represents A. The unique name for this value is LATIN CAPITAL LETTER A.</p>
<p><strong>Unicode is not supported in versions of JavaScript prior to 1.3.</strong></p>
<h3>Unicode compatibility with ASCII and ISO</h3>
<p>Unicode is fully compatible with the International Standard ISO/IEC 10646-1; 1993, which is a subset of ISO 10646.</p>
<p>Several encoding standards (including UTF-8, UTF-16 and ISO UCS-2) are used to physically represent Unicode as actual bits.</p>
<p>The UTF-8 encoding of Unicode is compatible with ASCII characters and is supported by many programs. The first 128 Unicode characters correspond to the ASCII characters and have the same byte value. The Unicode characters U+0020 through U+007E are equivalent to the ASCII characters 0x20 through 0x7E. Unlike ASCII, which supports the Latin alphabet and uses a 7-bit character set, UTF-8 uses between one and four octets for each character ("octet" meaning a byte, or 8 bits.) This allows for several million characters. An alternative encoding standard, UTF-16, uses two octets to represent Unicode characters. An escape sequence allows UTF-16 to represent the whole Unicode range by using four octets. The ISO UCS-2 (Universal Character Set) uses two octets.</p>
<p>JavaScript and Navigator support for UTF-8/Unicode means you can use non-Latin, international, and localized characters, plus special technical symbols in JavaScript programs. Unicode provides a standard way to encode multilingual text. Since the UTF-8 encoding of Unicode is compatible with ASCII, programs can use ASCII characters. You can use non-ASCII Unicode characters in the comments, string literals, identifiers, and regular expressions of JavaScript.</p>
<h3>Unicode escape sequences</h3>
<p>You can use the Unicode escape sequence in string literals, regular expressions, and identifiers. The escape sequence consists of six ASCII characters: \u and a four-digit hexadecimal number. For example, \u00A9 represents the copyright symbol. Every Unicode escape sequence in JavaScript is interpreted as one character.</p>
<p>The following code returns the copyright symbol and the string "Netscape Communications".</p>
<pre class="deki-transform">var x = "\u00A9 Netscape Communications";</pre>
<p>The following table lists frequently used special characters and their Unicode value.</p>
<table class="standard-table"> <caption style="text-align: left;">Table 2.2 Unicode values for special characters</caption> <thead> <tr> <th scope="col">Category</th> <th scope="col">Unicode value</th> <th scope="col">Name</th> <th scope="col">Format name</th> </tr> </thead> <tbody> <tr> <td rowspan="4">White space values</td> <td>\u0009</td> <td>Tab</td> <td>&lt;TAB&gt;</td> </tr> <tr> <td>\u000B</td> <td>Vertical Tab</td> <td>&lt;VT&gt;</td> </tr> <tr> <td>\u000C</td> <td>Form Feed</td> <td>&lt;FF&gt;</td> </tr> <tr> <td>\u0020</td> <td>Space</td> <td>&lt;SP&gt;</td> </tr> <tr> <td rowspan="2">Line terminator values</td> <td>\u000A</td> <td>Line Feed</td> <td>&lt;LF&gt;</td> </tr> <tr> <td>\u000D</td> <td>Carriage Return</td> <td>&lt;CR&gt;</td> </tr> <tr> <td rowspan="5">Additional Unicode escape sequence values</td> <td>\u0008</td> <td>Backspace</td> <td>&lt;BS&gt;</td> </tr> <tr> <td>\u0009</td> <td>Horizontal Tab</td> <td>&lt;HT&gt;</td> </tr> <tr> <td>\u0022</td> <td>Double Quote</td> <td>"</td> </tr> <tr> <td>\u0027</td> <td>Single Quote</td> <td>'</td> </tr> <tr> <td>\u005C</td> <td>Backslash</td> <td>\</td> </tr> </tbody>
</table>
<p>The JavaScript use of the Unicode escape sequence is different from Java. In JavaScript, the escape sequence is never interpreted as a special character first. For example, a line terminator escape sequence inside a string does not terminate the string before it is interpreted by the function. JavaScript ignores any escape sequence if it is used in comments. In Java, if an escape sequence is used in a single comment line, it is interpreted as an Unicode character. For a string literal, the Java compiler interprets the escape sequences first. For example, if a line terminator escape character (e.g., \u000A) is used in Java, it terminates the string literal. In Java, this leads to an error, because line terminators are not allowed in string literals. You must use \n for a line feed in a string literal. In JavaScript, the escape sequence works the same way as \n.</p>
<h3>Unicode characters in JavaScript files</h3>
<p>Earlier versions of <a href="/en/Gecko" title="en/Gecko">Gecko</a> assumed the Latin-1 character encoding for JavaScript files loaded from XUL. Starting with Gecko 1.8, the character encoding is inferred from the XUL file's encoding. Please see <a href="/en/International_characters_in_XUL_JavaScript" title="en/International_characters_in_XUL_JavaScript">International characters in XUL JavaScript</a> for more information.</p>
<h3>Displaying characters with Unicode</h3>
<p>You can use Unicode to display the characters in different languages or technical symbols. For characters to be displayed properly, a client such as Mozilla Firefox or Netscape needs to support Unicode. Moreover, an appropriate Unicode font must be available to the client, and the client platform must support Unicode. Often, Unicode fonts do not display all the Unicode characters. Some platforms, such as Windows 95, provide partial support for Unicode.</p>
<p>To receive non-ASCII character input, the client needs to send the input as Unicode. Using a standard enhanced keyboard, the client cannot easily input the additional characters supported by Unicode. Sometimes, the only way to input Unicode characters is by using Unicode escape sequences.</p>
<p>For more information on Unicode, see the <a class="external" href="http://www.unicode.org/">Unicode Home Page</a> and The Unicode Standard, Version 2.0, published by Addison-Wesley, 1996.</p>
<pre class="script" style="font-size: 16px;">autoPreviousNext("JSGChapters");
wiki.languages({
  "zh-tw": "zh_tw/Core_JavaScript_1.5_教學/JavaScript_概要",
  "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript",
  "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript",
  "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview",
  "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu",
  "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8"
});
</pre>
Zu dieser Version zurücksetzen