ECMAScript-Referenztypen

Referenztypen werden oft als Klassen (class) bezeichnet.

Dieses Tutorial wird viele vorgegebene Referenztypen von ECMAScript diskutieren.

Referenztypen

Referenztypen werden oft als Klassen (class) bezeichnet, das bedeutet, dass bei Referenzwerten mit Objekten gearbeitet wird.

Dieses Tutorial wird viele vorgegebene Referenztypen von ECMAScript diskutieren.

Von nun an wird der Fokus auf die Referenztypen gelegt, die eng mit den bereits diskutierten primitiven Typen verbunden sind.

Hinweis:In der traditionellen Bedeutung hat ECMAScript keine Klassen wirklich. Tatsächlich erscheint das Wort "Klasse" im ECMA-262 nicht einmal, um die Nichtexistenz von Klassen zu beschreiben. ECMAScript definiert "Objektdefinitionen", die logisch äquivalent zu Klassen in anderen Programmiersprachen sind.

Tipp:Dieses Tutorial wird den Begriff "Objekt" verwenden.

Objekte werden durch den Operator new zusammen mit dem Namen des zu instanzialisierenden Objekts erstellt. Zum Beispiel erstellt der folgende Code eine Instanz des Object-Objekts:

var o = new Object();

Diese Syntax ist ähnlich wie in der Sprache Java, aber ECMAScript erfordert bei mehreren Parametern die Verwendung von Klammern. Bei keinem Parameter, wie im folgenden Beispiel gezeigt, können die Klammern weggelassen werden:

var o = new Object;

Hinweis:Obwohl Klammern nicht obligatorisch sind, ist es am besten, Klammern zu verwenden, um Verwirrung zu vermeiden.

Tipp:Wir werden in diesem Kapitel über die Grundlagen der Objekte und ihr Verhalten eingehender diskutieren.

Der Schwerpunkt dieses Abschnitts ist die Referenztypen mit gleichen ursprünglichen Typen.

Object-Objekt

Das Object-Objekt ist nicht sehr nützlich, aber bevor andere Klassen verstanden werden, sollte es bekannt sein. Da der Object-Objekt in ECMAScript mit java.lang.Object in Java ähnlich ist, erben alle Objekte in ECMAScript von diesem Objekt, und alle Eigenschaften und Methoden des Object-Objekts erscheinen in anderen Objekten. Daher kann das Verständnis des Object-Objekts das Verständnis anderer Objekte verbessern.

Das Object-Objekt hat die folgenden Eigenschaften:

constructor
Referenz (Zeiger) auf die Funktion, die das Objekt erstellt (erzeugt). Für das Object-Objekt verweist dieser Zeiger auf die ursprüngliche Function Object()
Prototype
Referenz auf den Prototypen dieses Objekts. Für alle Objekte gibt es eine Standardrückgabe von Object-Objekt-Instanzen.

Das Object-Objekt hat noch einige Methoden:

hasOwnProperty(property)
Überprüfen, ob das Objekt eine bestimmte Eigenschaft hat. Es muss die Eigenschaft als Zeichenkette angegeben werden. (Zum Beispiel o.hasOwnProperty("name"))
IsPrototypeOf(object)
Überprüfen, ob dieses Objekt ein Prototyp eines anderen Objekts ist.
PropertyIsEnumerable
Überprüfen, ob die angegebene Eigenschaft mit dem for...in-Ausdruck auflistungsfähig ist.
ToString()
Rückgabe der ursprünglichen Zeichenkettenrepräsentation des Objekts. Für das Object-Objekt ist dieser Wert in ECMA-262 nicht definiert, daher haben verschiedene ECMAScript-Implementierungen unterschiedliche Werte.
ValueOf()
Rückgabe des ursprünglichen Wertes, der am besten zu dem Objekt passt. Für viele Objekte ist der von diesem Verfahren zurückgegebene Wert gleich dem Wert von ToString().

注释：Alle in der Liste aufgeführten Attribute und Methoden werden von anderen Objekten überschrieben.

Boolean-Objekt

Das Boolean-Objekt ist ein Referenztyp des Boolean-Basistyps.

Um ein Boolean-Objekt zu erstellen, genügt es, einen Boolean-Wert als Parameter zu übergeben:

var oBooleanObject = new Boolean(true);

Das Boolean-Objekt überschreibt die Methode ValueOf() des Object-Objekts und gibt den ursprünglichen Wert zurück, d.h. true und false. Die Methode ToString() wird ebenfalls überschrieben und gibt den String "true" oder "false" zurück.

Leider werden Boolean-Objekte in ECMAScript selten verwendet, und selbst wenn, sind sie schwer zu verstehen.

Probleme treten oft auf, wenn Boolean-Objekte in Boolean-Ausdrücken verwendet werden. Zum Beispiel:

var oFalseObject = new Boolean(false);
var bResult = oFalseObject && true;	// Ausgabe true

In diesem Code wird ein Boolean-Objekt mit dem Wert false erstellt. Dieser Wert wird dann mit dem ursprünglichen Wert true AND-verknüpft. Das Ergebnis einer AND-Operation zwischen false und true im Boolean-Rechen ist false. In dieser Zeile wird jedoch oFalseObject berechnet, nicht sein Wert false.

Wie bereits diskutiert, werden alle Objekte in Boolean-Ausdrücken automatisch in true umgewandelt, daher ist der Wert von oFalseObject true. Dieser wird dann mit true AND-verknüpft, was zu true führt.

Hinweis:Obwohl Sie die Verfügbarkeit des Boolean-Objekts kennen sollten, ist es besser, die ursprünglichen Boolean-Werte zu verwenden, um die in diesem Abschnitt erwähnten Probleme zu vermeiden.

Siehe

Für weitere Informationen über das Boolean-Objekt besuchen Sie bitte JavaScript Boolean-Objekt Referenzhandbuch.

Number-Objekt

Wie Sie sich vorstellen können, ist das Number-Objekt ein Referenztyp des numerischen Basistyps. Um ein Number-Objekt zu erstellen, verwenden Sie den folgenden Code:

var oNumberObject = new Number(68);

Sie sollten bereits das Number-Objekt aus dem vorherigen Abschnitt dieses Kapitels kennen, in dem über besondere Werte (wie Number.MAX_VALUE) gesprochen wurde. Alle besonderen Werte sind statische Attribute des Number-Objekts.

Um den ursprünglichen Wert eines numerischen Objekts zu erhalten, genügt es, die Methode valueOf() zu verwenden:

var iNumber = oNumberObject.valueOf();

Natürlich hat die Number-Klasse auch die toString()-Methode, die im Abschnitt über Typkonvertierung bereits im Detail besprochen wurde.

Neben den Standardmethoden, die vom Object-Objekt geerbt werden, hat das Number-Objekt noch einige spezialisierte Methoden zur Verarbeitung von Zahlen.

toFixed() -Methode

Die toFixed()-Methode gibt die Zeichenkette der Zahl mit einer bestimmten Anzahl von Dezimalstellen zurück. Zum Beispiel:

var oNumberObject = new Number(68);
alert(oNumberObject.toFixed(2));  // Ausgabe "68.00"

Hier ist der Parameter der toFixed()-Methode 2, was bedeutet, dass zwei Dezimalstellen angezeigt werden sollten. Diese Methode gibt "68.00" zurück, leere Stellen werden durch 0 ergänzt. Für Anwendungen zur Verarbeitung von Währungen ist diese Methode sehr nützlich. Die toFixed()-Methode kann Zahlen mit 0 bis 20 Dezimalstellen darstellen, Werte außerhalb dieses Bereichs verursachen einen Fehler.

toExponential() -Methode

Eine andere Methode zur Formatierung von Zahlen ist die toExponential()-Methode, die die Zeichenkette der Zahl in wissenschaftlicher Notation zurückgibt.

Ähnlich wie die toFixed()-Methode hat auch die toExponential()-Methode einen Parameter, der die Anzahl der zu outputierenden Dezimalstellen angibt. Zum Beispiel:

var oNumberObject = new Number(68);
alert(oNumberObject.toExponential(1));  // Ausgabe "6.8e+1"

Das Ergebnis dieses Codes ist "6.8e+1", wie bereits erklärt, das bedeutet 6.8x101Das Problem ist, was tun, wenn nicht bekannt ist, in welcher Form (vorgesehene Form oder exponentielle Form) die Zahl dargestellt werden soll? Man kann die toPrecision()-Methode verwenden.

toPrecision() -Methode

Die toPrecision()-Methode gibt die vorgesehene oder exponentielle Form der Zahl zurück, abhängig von der bedeutungsvollsten Form. Sie hat einen Parameter, nämlich die Anzahl der für die Darstellung der Zahl benötigten Ziffern (ohne den Exponenten). Zum Beispiel,

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(1));  // Ausgabe "7e+1"

Die Aufgabe dieses Codes ist es, die Zahl 68 mit einer Ziffer darzustellen, das Ergebnis ist "7e+1", was auf eine andere Weise 70 bedeutet. Tatsächlich rundet die toPrecision()-Methode die Zahlen.

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  // Ausgabe "68"

Natürlich, das Ausgabeergebnis ist "68", denn das ist genau die genaue Darstellung dieser Zahl. Aber was ist, wenn mehr Stellen angegeben werden, als erforderlich sind?

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(3));  // Ausgabe "68.0"

In diesem Fall ist toPrecision(3) äquivalent zu toFixed(1) und gibt "68.0" aus.

Die Methoden toFixed(), toExponential() und toPrecision() führen Rundungsvorgänge durch, um eine Nummer mit der richtigen Anzahl von Dezimalstellen korrekt darzustellen.

Tipp:Wie das Boolean-Objekt ist auch das Number-Objekt wichtig, sollte jedoch weniger häufig verwendet werden, um potenzielle Probleme zu vermeiden. Verwenden Sie so oft wie möglich die ursprüngliche Darstellung der Zahlen.

Siehe

Für weitere Informationen zum Number-Objekt besuchen Sie JavaScript Number-Objekt Referenzhandbuch.

String-Objekt

Das String-Objekt ist die Objektdarstellung des String-Originaltyps und wird auf die folgenden Arten erstellt:

var oStringObject = new String("hello world");

Die Methoden valueOf() und toString() des String-Objekts geben den ursprünglichen Wert der String-Klasse zurück:

alert(oStringObject.valueOf() == oStringObject.toString());	// Ausgabe "true"

Wenn Sie diesen Code ausführen, ist die Ausgabe "true", was bedeutet, dass diese Werte tatsächlich gleich sind.

注释：Das String-Objekt ist eines der komplexeren Referenztypen in ECMAScript. Ebenso ist der Fokus dieses Abschnitts nur auf die grundlegenden Funktionen der String-Klasse gerichtet. Weitere fortgeschrittene Funktionen finden Sie in den entsprechenden Kapiteln dieses Tutorials oder siehe JavaScript String-Objekt Referenzhandbuch.

length-Eigenschaft

Das String-Objekt verfügt über die Eigenschaft length, die die Anzahl der Zeichen in der Zeichenkette angibt:

var oStringObject = new String("hello world");
alert(oStringObject.length);	// Ausgabe "11"

Dieser Beispielausgabe ist "11", was die Anzahl der Zeichen in "hello world" entspricht. Beachten Sie, dass selbst wenn die Zeichenkette mehrbyte Zeichen (im Gegensatz zu ASCII-Zeichen, die nur einen Byte belegen) enthält, wird jedes Zeichen als ein eigenständiges Zeichen gezählt.

charAt() und charCodeAt() Methoden

Das String-Objekt verfügt über eine Vielzahl von Methoden.

Zunächst sprechen die Methoden charAt() und charCodeAt() über einzelne Zeichen in einer Zeichenkette an. Beide Methoden haben einen Parameter, den die Position des zu verarbeitenden Zeichens ist.

Die Methode charAt() gibt einen String zurück, der den Zeichen an der angegebenen Position enthält:

var oStringObject = new String("hello world");
alert(oStringObject.charAt(1));	// Ausgabe "e"

Im String "hello world" ist das Zeichen an Position 1 "e" Der erste Buchstabe des "ECMAScript-Originaltyps"-Abschnitts haben wir gesagt, dass die Position des ersten Zeichens 0 ist, die Position des zweiten Zeichens 1 ist und so weiter. Daher gibt charAt(1) das "e" zurück.

Wenn nicht der Zeichen selbst, sondern der Zeichencode benötigt wird, kann die charCodeAt()-Methode aufgerufen werden:

var oStringObject = new String("hello world");
alert(oStringObject.charCodeAt(1));	// Ausgabe "101"

Dieser Beispiel gibt "101" aus, das ist der Zeichencode des Kleinbuchstaben "e".

concat() Methode

Nun geht es um die concat()-Methode, die eine oder mehrere Strings an den ursprünglichen Wert des String-Objekts anhängen. Diese Methode gibt den ursprünglichen String-Wert zurück und ändert den ursprünglichen String-Objekt nicht:

var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
alert(sResult);		// Ausgabe "hello world"
alert(oStringObject);	// Ausgabe "hello "

In diesem Code wird die concat()-Methode "hello world" zurückgegeben, während der String-Objekt weiterhin "hello " speichert. Aus diesem Grund ist es häufiger, Strings mit einem Pluszeichen (+) zu verknüpfen, da diese Form logisch das tatsächliche Verhalten zeigt:

var oStringObject = new String("hello ");
var sResult = oStringObject + "world";
alert(sResult);		// Ausgabe "hello world"
alert(oStringObject);	// Ausgabe "hello "

indexOf() und lastIndexOf() Methoden

Bisher haben wir die Methoden zur Verknüpfung von Strings und den Methoden zur Zugriffnahme auf einzelne Zeichen im String besprochen. Wenn jedoch nicht sicher ist, ob ein bestimmtes Zeichen in einem String tatsächlich vorhanden ist, sollten die indexOf()- und lastIndexOf()-Methoden aufgerufen werden.

Die indexOf()- und lastIndexOf()-Methoden geben die Position des angegebenen Substrings im anderen String zurück. Wenn der Substring nicht gefunden wird, wird -1 zurückgegeben.

Die Unterschiede zwischen diesen beiden Methoden bestehen darin, dass die indexOf()-Methode die Suche von Anfang an (Position 0) im String durchführt, während die lastIndexOf()-Methode von Ende an den Substring durchsucht. Zum Beispiel:

var oStringObject = new String("hello world!");
alert(oStringObject.indexOf("o"));		输出 "4"
alert(oStringObject.lastIndexOf("o"));	输出 "7"

在这里，第一个 "o" 字符串出现在位置 4，即 "hello" 中的 "o"；最后一个 "o" 出现在位置 7，即 "world" 中的 "o"。如果该字符串中只有一个 "o" 字符串，那么 indexOf() 和 lastIndexOf() 方法返回的位置相同。

localeCompare() 方法

下一个方法是 localeCompare()，对字符串进行排序。该方法有一个参数 - 要进行比较的字符串，返回的是下列三个值之一：

  • 如果 String 对象按照字母顺序排在参数中的字符串之前，返回负数。
  • 如果 String 对象等于参数中的字符串，返回 0
  • 如果 String 对象按照字母顺序排在参数中的字符串之后，返回正数。

注释：如果返回负数，那么最常见的是 -1，不过真正返回的是由实现决定的。如果返回正数，那么同样的，最常见的是 1，不过真正返回的是由实现决定的。

示例如下：

var oStringObject = new String("yellow");
alert(oStringObject.localeCompare("brick"));		//输出 "1"
alert(oStringObject.localeCompare("yellow"));		//输出 "0"
alert(oStringObject.localeCompare("zoo"));		//输出 "-1"

In diesem Codeblock wird der String "yellow" mit 3 Werten verglichen, nämlich "brick", "yellow" und "zoo". Da sie alphabetisch sortiert sind, liegt "yellow" nach "brick", daher gibt localeCompare() den Wert 1 zurück; "yellow" ist gleich "yellow", daher gibt localeCompare() den Wert 0 zurück; "zoo" liegt nach "yellow", daher gibt localeCompare() den Wert -1 zurück. Wiederholen wir noch einmal, da der zurückgegebene Wert vom Implementierungstyp abhängt, ist es am besten, localeCompare() wie folgt aufzurufen:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " folgt vor " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " folgt nach " + oStringObject2);
} else {
  alert("Die beiden Strings sind gleich");
}

Mit dieser Struktur kann sichergestellt werden, dass dieses Codeabschnitt in allen Implementierungen korrekt ausgeführt wird.

Der Besonderheit der localeCompare() -Methode liegt darin, dass der genaue Ort (Locale, was sowohl Land als auch Sprache umfasst) der Implementierung genau beschreibt, wie diese Methode ausgeführt wird. In den USA ist Englisch die StandardSprache der ECMAScript-Implementierung, localeCompare() ist groß- und kleinschreibungsabhängig, wobei Großbuchstaben im Alphabet nach Kleinbuchstaben stehen. Allerdings kann dies in anderen Regionen anders sein.

slice() und substring()

ECMAScript bietet zwei Methoden an, um aus einem Teilstring einen String-Wert zu erstellen, nämlich slice() und substring(). Beide Methoden geben eine Teilzeichenkette des zu verarbeitenden Strings zurück und akzeptieren einen oder zwei Parameter. Der erste Parameter ist die Position des zu verarbeitenden Teilstrings, der zweite Parameter (falls verwendet) ist die Position vor dem Ende des zu verarbeitenden Teilstrings (d.h., der Zeichen am Endeposition wird nicht im zurückgegebenen Wert enthalten). Wird der zweite Parameter weggelassen, ist die Endposition standardmäßig die Länge des Strings.

Wie die concat() -Methode ändern slice() und substring() keine Eigenschaft des String-Objekts. Sie geben nur den ursprünglichen String-Wert zurück und behalten das String-Objekt unverändert bei.

var oStringObject = new String("hello world");
alert(oStringObject.slice("3")); // Ausgabe "lo world"
alert(oStringObject.substring("3")); // Ausgabe "lo world"
alert(oStringObject.slice("3", "7")); // Ausgabe "lo w"
alert(oStringObject.substring("3", "7")); // Ausgabe "lo w"

In diesem Beispiel sind die Verwendung und die Rückgabewerte von slice() und substring() gleich. Wenn nur der Parameter 3 verwendet wird, geben beide Methoden "lo world" zurück, da der zweite "l" in "hello" an Position 3 liegt. Wenn zwei Parameter "3" und "7" verwendet werden, geben beide Methoden "lo w" zurück (das "o" im "world" liegt an Position 7, daher wird es nicht in das Ergebnis einbezogen).

Warum gibt es zwei Methoden mit vollkommen gleichen Funktionen? Tatsächlich sind diese beiden Methoden nicht vollkommen gleich, aber sie unterscheiden sich nur leicht in der Art und Weise, wie sie negative Parameter behandeln.

Bei negativen Parameters verwendet die slice()-Methode die Länge des Strings plus den Parameter, während substring() den Parameter als 0 behandelt (das bedeutet, dass er ignoriert wird). Zum Beispiel:

var oStringObject = new String("hello world");
alert(oStringObject.slice("-3")); // Ausgabe "rld"
alert(oStringObject.substring("-3")); // Ausgabe "hello world"
alert(oStringObject.slice("3, -4")); // Ausgabe "lo w"
alert(oStringObject.substring("3, -4")); // Ausgabe "hel"

So kann man die Hauptunterschiede zwischen slice() und substring() erkennen.

Wenn nur der Parameter -3 verwendet wird, gibt slice() "rld" zurück, während substring() "hello world" zurückgibt. Dies liegt daran, dass slice("-3") für den String "hello world" in slice("8") umgewandelt wird, während substring("-3") in substring("0") umgewandelt wird.

Gleichzeitig sind die Unterschiede bei der Verwendung der Parameter 3 und -4 ebenfalls sehr明显. slice() wird in slice(3, 7) umgewandelt, wie im vorherigen Beispiel, und gibt "lo w" zurück. Der substring()-Methoden wird jedoch die beiden Parameter als substring(3, 0) interpretiert, was实际上等于 substring(0, 3), da substring() immer die kleinere Zahl als Startposition und die größere Zahl als Endposition verwendet. Daher gibt substring("3, -4") "hel" zurück. Die letzte Zeile des Codes dient dazu, die Verwendung dieser Methoden zu erläutern.

toLowerCase(), toLocaleLowerCase(), toUpperCase() und toLocaleUpperCase()

Das letzte zu besprechende Set von Methoden bezieht sich auf die Groß- und Kleinbuchstabenkonvertierung. Es gibt vier Methoden, die zur Ausführung von Groß- und Kleinbuchstabenkonvertierungen dienen, nämlich

  • toLowerCase()
  • toLocaleLowerCase()
  • toUpperCase()
  • toLocaleUpperCase()

Wie der Name bereits andeutet, dienen die ersten beiden Methoden dazu, einen String in Kleinbuchstaben zu konvertieren, während die letzten beiden Methoden dazu dienen, einen String in Großbuchstaben zu konvertieren.

Die Methoden toLowerCase() und toUpperCase() sind ursprünglich und werden auf Basis der gleichen Methoden in java.lang.String implementiert.

Die Methoden toLocaleLowerCase() und toLocaleUpperCase() werden auf Basis einer spezifischen Region implementiert (wie auch die Methode localeCompare()). In vielen Regionen sind die regionsspezifischen Methoden mit den allgemeinen Methoden vollständig identisch. Allerdings wenden einige Sprachen spezifische Regeln für die Umwandlung von Unicode in Groß- und Kleinbuchstaben an (z.B. Türkisch), daher müssen die regionsspezifischen Methoden verwendet werden, um eine korrekte Umwandlung durchzuführen.

var oStringObject = new String("Hello World");
alert(oStringObject.toLocaleUpperCase());	// Ausgabe "HELLO WORLD"
alert(oStringObject.toUpperCase());		// Ausgabe "HELLO WORLD"
alert(oStringObject.toLocaleLowerCase());	// Ausgabe "hello world"
alert(oStringObject.toLowerCase());		// Ausgabe "hello world"

In diesem Code sind sowohl toUpperCase() und toLocaleUpperCase() als auch toLowerCase() und toLocaleLowerCase() die Ausgaben "HELLO WORLD" und "hello world". Im Allgemeinen ist es sicherer, regionsspezifische Methoden zu verwenden, wenn nicht bekannt ist, in welcher Kodierung eine Sprache ausgeführt wird.

Tipp:Denken Sie daran, dass alle Eigenschaften und Methoden des String-Objekts auf den String-Originalwerten angewendet werden können, da sie Pseudoobjekte sind.

instanceof-Operator

Bei der Verwendung des typeof-Operators kann ein Problem auftreten, wenn Referenztypen verwendet werden, um Werte zu speichern. Egal, welche Art von Objekt referenziert wird, es wird immer "object" zurückgegeben. ECMAScript hat den zusätzlichen Java-Operator instanceof eingeführt, um dieses Problem zu lösen.

Der instanceof-Operator ist ähnlich wie der typeof-Operator und wird verwendet, um den Typ des bearbeiteten Objekts zu identifizieren. Im Gegensatz zum typeof-Verfahren erfordert der instanceof-Operator, dass der Entwickler explizit bestätigt, dass das Objekt ein bestimmter Typ ist. Zum Beispiel:

var oStringObject = new String("hello world");
alert(oStringObject instanceof String);	// Ausgabe "true"

Diese Code fragt: "Ist das Variable oStringObject ein Beispiel des String-Objekts?" oStringObject ist tatsächlich ein Beispiel des String-Objekts, daher ist das Ergebnis "true". Obwohl es nicht so flexibel ist wie das typeof-Verfahren, ist das instanceof-Verfahren dennoch sehr nützlich, wenn typeof das "object" zurückgibt.