ECMAScript Referentie Typen

Referentietypen worden meestal klassen genoemd (class).

Deze handleiding zal talrijke vooraf gedefinieerde referentietypen van ECMAScript bespreken.

Referentietypen

Referentietypen worden meestal klassen genoemd (class), wat betekent dat bij het behandelen van referentiewaarden, het gaat om objecten.

Deze handleiding zal talrijke vooraf gedefinieerde referentietypen van ECMAScript bespreken.

Vanaf nu af zal de nadruk liggen op referentietypen die nauw samenhangen met de reeds besproken primitieve types.

Let op:Van traditionele betekenis af gezien, heeft ECMAScript geen klassen. In feite wordt het woord 'klasse' in ECMA-262 niet genoemd, behalve om aan te geven dat er geen klassen zijn. ECMAScript definieert 'objectdefinitie', die logisch equivalent is aan klassen in andere programmeertalen.

Tip:Deze handleiding zal het termijn "object" gebruiken.

Objecten worden gecreëerd door de new-operators te combineren met de naam van het object dat moet worden geïnstancieerd. Bijvoorbeeld, de volgende code creëert een instance van het Object-object:

var o = new Object();

Deze syntaxis lijkt op het Java-taal, maar wanneer er meer dan één parameter is, vereist ECMAScript het gebruik van haakjes. Als er geen parameters zijn, zoals in de volgende code, kunnen de haakjes worden weggelaten:

var o = new Object;

Let op:Hoewel haakjes niet noodzakelijk zijn, is het het beste om ze te gebruiken om verwarring te voorkomen.

Tip:We zullen in het hoofdstuk over objectbasis dieper ingaan op objecten en hun gedrag.

Het belangrijkste van deze sectie is de referentietypen die gelijke oorspronkelijke types hebben.

Object-object

Het Object-object is niet erg nuttig op zichzelf, maar het is nog steeds belangrijk om het te begrijpen voordat je andere klassen leert. Omdat het Object-object in ECMAScript vergelijkbaar is met java.lang.Object in Java, zijn alle objecten in ECMAScript afgeleid van deze object, en alle eigenschappen en methoden van het Object-object verschijnen ook in andere objecten. Daarom, door het Object-object te begrijpen, kun je beter andere objecten begrijpen.

Het Object-object heeft de volgende eigenschappen:

constructor
Een verwijzing (pointer) naar de functie die het object heeft gecreëerd. Voor het Object-object wijst deze pointer naar de oorspronkelijke Object() functie.
Prototype
Een verwijzing naar de object-protoject van dit object. Voor alle objecten retourneert het standaard een instance van Object.

Het Object-object heeft ook enkele andere methoden:

hasOwnProperty(property)
Beoordeel of het object een specifieke eigenschap heeft. De eigenschap moet als string worden gespecificeerd. (Bijvoorbeeld, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Beoordeel of het object het prototype is van een ander object.
PropertyIsEnumerable
Beoordeel of de gegeven eigenschap kan worden geënumereerd met behulp van de for...in-statement.
ToString()
Retourneer de oorspronkelijke stringrepresentatie van het object. Voor het Object-object definieert ECMA-262 deze waarde niet, dus verschillende ECMAScript-implementaties hebben verschillende waarden.
ValueOf()
Retourneer de oorspronkelijke waarde die het beste past bij het object. Voor veel objecten is de waarde die deze methode retourneert dezelfde als die van ToString().

Opmerking:Elke eigenschap en methode die hierboven wordt vermeld, wordt overschreven door andere objecten.

Boolean-object

Het Boolean-object is een referentietype van het Boolean-primaire type.

Om een Boolean-object te maken, is het voldoende om een Boolean-waarde als parameter door te geven:

var oBooleanObject = new Boolean(true);

Het Boolean-object overschrijft de Method ValueOf() van het Object-object, die de oorspronkelijke waarde teruggeeft, dat wil zeggen true en false. De Method ToString() wordt ook overschreven, die de string "true" of "false" teruggeeft.

Helaas wordt het Boolean-object in ECMAScript zelden gebruikt, en zelfs als het wordt gebruikt, is het moeilijk te begrijpen.

Problemen treden vaak op wanneer Boolean-objecten worden gebruikt in Boolean-expressies. Bijvoorbeeld:

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

In deze code wordt een Boolean-object gemaakt met de waarde false. Vervolgens wordt deze waarde gecombineerd met de oorspronkelijke waarde true door een AND-operatie. Het resultaat van een AND-operatie tussen false en true in Boolean-bewerkingen is false. Echter, in deze regel wordt de waarde van oFalseObject berekend, niet zijn waarde false.

Net zoals eerder besproken, worden alle objecten in Boolean-expressies automatisch omgezet naar true, dus de waarde van oFalseObject is true. Vervolgens wordt true gecombineerd met true door een AND-operatie, het resultaat is true.

Let op:Hoewel je de beschikbaarheid van het Boolean-object zou moeten begrijpen, is het het beste om de Boolean-primaire waarde te gebruiken om problemen te voorkomen die in dit hoofdstuk worden besproken.

See

Voor meer informatie over het Boolean-object, bezoek Handleiding voor JavaScript Boolean-objecten.

Number-object

Net zoals je zou verwachten, is het Number-object een referentietype van de Number-primaire type. Om een Number-object te maken, gebruik je de volgende code:

var oNumberObject = new Number(68);

Je zou moeten herkennen dat in het vorige deel van dit hoofdstuk de Number-objecten (zoals Number.MAX_VALUE) werden besproken. Alle speciale waarden zijn statische eigenschappen van het Number-object.

Om de oorspronkelijke waarde van het Number-object te verkrijgen, is het voldoende om de method valueOf() te gebruiken:

var iNumber = oNumberObject.valueOf();

Natuurlijk, de klasse Number heeft ook een toString() methode, die in het hoofdstuk over typeconversie in detail is besproken.

Naast de standaardmethoden die worden geërfd van het Object-object, heeft het Number-object ook enkele specifieke methoden voor het verwerken van getallen.

De methode toFixed()

De methode toFixed() retourneert de stringrepresentatie van een getal met een bepaald aantal decimalen. Bijvoorbeeld:

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

Hier is het parameter van de methode toFixed() 2, wat betekent dat er twee decimalen moeten worden weergegeven. Deze methode retourneert "68.00", de lege stringposities worden aangevuld met 0. Voor toepassingen die betrekking hebben op valuta, is deze methode zeer nuttig. De methode toFixed() kan getallen met 0 tot 20 decimalen weergeven, waarden buiten dit bereik veroorzaken een fout.

De methode toExponential()

Een andere methode voor het formatteren van cijfers is toExponential(), die de stringrepresentatie van een getal in wetenschappelijke notatie retourneert.

Vergelijkbaar met de methode toFixed(), heeft de methode toExponential() ook een parameter die het aantal cijfers achter de komma specificeert. Bijvoorbeeld:

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

Het resultaat van dit codeblok is "6.8e+1", zoals eerder is uitgelegd, het representerd 6.8x101Het probleem is, wat als je niet weet in welke vorm (voorafgeordende vorm of exponentiële vorm) je het getal moet weergeven? Je kunt de methode toPrecision() gebruiken.

De methode toPrecision()

De methode toPrecision() retourneert de voorafgeordende vorm of exponentiële vorm van een getal op basis van de meest betekenisvolle vorm. Het heeft een parameter, namelijk het totale aantal cijfers dat wordt gebruikt om het getal te representeren (exclusief de exponent). Bijvoorbeeld,

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

De taak van dit codeblok is om het getal 68 af te beelden met één cijfer, het resultaat is "7e+1", in een andere vorm is dit 70. Zeker, de methode toPrecision() rondeert de getallen. Maar als je met 2 cijfers het getal 68 weergeeft, is het veel eenvoudiger:

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

Natuurlijk, de uitvoer is "68", omdat dit de exacte weergave van het getal is. Maar wat als er meer cijfers worden opgegeven dan nodig?

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

In this case, toPrecision(3) is equivalent to toFixed(1), and the output is "68.0".

The toFixed(), toExponential(), and toPrecision() methods all perform rounding operations to represent a number correctly with the correct number of decimal places.

Tip:Similar to the Boolean object, the Number object is also very important, but it should be used less to avoid potential problems. As far as possible, use the primitive representation of numbers.

See

For more information about the Number object, please visit Handleiding voor JavaScript Number-objecten.

String object

The String object is the object representation of the String primitive type, which is created in the following way:

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

Both the valueOf() and toString() methods of the String object return the original value of the String type:

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

If this code is run, the output is "true", indicating that these values are indeed equal.

Opmerking:The String object is one of the more complex reference types in ECMAScript. Similarly, the focus of this section is only on the basic functions of the String class. For more advanced features, please read the relevant sections of this tutorial or refer to Handleiding voor JavaScript String-objecten.

length property

The String object has a property called length, which is the number of characters in the string:

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

This example outputs "11", which is the number of characters in "hello world". Note that even if the string contains double-byte characters (in contrast to ASCII characters, which only occupy one byte), each character is counted as one character.

charAt() and charCodeAt() methods

The String object also has a large number of methods.

Firstly, both the charAt() and charCodeAt() methods access single characters within a string. Both methods have one parameter, which is the position of the character to be operated on.

The charAt() method returns a string containing the character at the specified position:

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

In de string "hello world", is het karakter op positie 1 "e". In het hoofdstuk "ECMAScript primitive types" hebben we besproken dat de positie van de eerste karakter 0 is, de positie van de tweede karakter 1, enz. Dus retourneert charAt(1) het karakter "e".

Als je niet een karakter, maar een charactercode wilt, kun je de charCodeAt() methode aanroepen:

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

Deze voorbeelduitvoer geeft "101" terug, het charactercode van de kleine letter "e".

De concat() methode

Vervolgens is er de concat() methode, die wordt gebruikt om een of meerdere strings toe te voegen aan de oorspronkelijke waarde van de String-object. Deze methode retourneert de oorspronkelijke waarde van de String, zonder de oorspronkelijke String-object te wijzigen:

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

In dit stuk code wordt de concat() methode aangeroepen om "hello world" te retourneren, terwijl de String-object nog steeds "hello " bevat. Om deze reden is het gebruikelijker om strings te koppelen met een pluspunt (+), omdat dit op een logische manier het gedrag aangeeft:

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

De indexOf() en lastIndexOf() methoden

Tot nu toe zijn er methoden besproken om strings te koppelen en individuele karakters in een string te bereiken. Maar wat als je niet weet of een karakter daadwerkelijk in een string voorkomt? In dat geval kun je de indexOf() en lastIndexOf() methoden aanroepen.

De indexOf() en lastIndexOf() methoden retourneren de positie van de opgegeven substring in een andere string. Als de substring niet wordt gevonden, wordt -1 geretourneerd.

Het verschil tussen deze twee methoden ligt in het feit dat de indexOf() methode de string vanaf het begin (positie 0) doorzoekt, terwijl de lastIndexOf() methode van het einde van de string begint. Bijvoorbeeld:

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

Hier verschijnt de eerste "o" string op positie 4, dat is de "o" in "hello"; de laatste "o" verschijnt op positie 7, dat is de "o" in "world". Als er in de string maar één "o" string is, zijn de posities geretourneerd door indexOf() en lastIndexOf() hetzelfde.

localeCompare() methode

De volgende methode is localeCompare(), die strings sorteert. Deze methode heeft één parameter - de te vergelijken string, en retourneert één van de volgende drie waarden:

  • Als de String object volgens de letterlijke volgorde voor de string in de parameter staat, wordt een negatief getal geretourneerd.
  • Als de String object gelijk is aan de string in de parameter, wordt 0 geretourneerd
  • Als de String object volgens de letterlijke volgorde na de string in de parameter staat, wordt een positief getal geretourneerd.

Opmerking:Als de retourwaarde negatief is, is het meestal -1, maar wat echt wordt geretourneerd, wordt bepaald door de implementatie. Als de retourwaarde positief is, is het meestal 1, maar wat echt wordt geretourneerd, wordt bepaald door de implementatie.

Hier is een voorbeeld:

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

In deze code wordt de string "yellow" vergeleken met 3 waarden, te weten "brick", "yellow" en "zoo". Omdat ze in alfabetische volgorde zijn gesorteerd, staat "yellow" na "brick", dus retourneert localeCompare() 1; "yellow" is gelijk aan "yellow", dus retourneert localeCompare() 0; "zoo" staat na "yellow", dus retourneert localeCompare() -1. We herhalen nogmaals dat de retourwaarde door de implementatie wordt bepaald, dus het is het beste om de localeCompare() methode op de volgende manier aan te roepen:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " komt voor " + oStringObject2);
} else if (iResult > 0) {
  alert(oStringObject1 + " komt na " + oStringObject2);
} else {
  alert("De twee strings zijn gelijk");
}

Met deze structuur kan ervoor worden gezorgd dat dit stuk code correct werkt in alle implementaties.

De unieke kenmerken van de localeCompare() methode liggen in de nauwkeurige beschrijving van de locatie (locale, wat zowel land als taal omvat) waarin deze methode wordt uitgevoerd. In de Verenigde Staten is Engels het standaardtaal van de ECMAScript implementatie, en localeCompare() is hoofdlettergevoelig, waarbij hoofdletters achteraan in de lettervolgorde komen. In andere regio's kan dit echter anders zijn.

slice() en substring()

ECMAScript biedt twee methoden om stringwaarden te maken uit een substring, namelijk slice() en substring(). Beide methoden retourneren een substring van de te verwerken string en accepteren een of twee parameters. De eerste parameter is de positie van de te verkrijgen substring, en de tweede parameter (indien gebruikt) is de positie van het einde van de substring (dus, de karakter op de eindpositie wordt niet opgenomen in de retourwaarde). Als de tweede parameter wordt weggelaten, wordt de eindpositie standaard ingesteld op de lengte van de string.

Net als de concat() methode veranderen slice() en substring() niet de waarde van het String object zelf. Ze retourneren alleen de oorspronkelijke String waarde en houden het String object onveranderd.

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

In dit voorbeeld zijn de gebruiken van slice() en substring() hetzelfde, en ook de retourwaarden zijn hetzelfde. Als alleen parameter 3 wordt gebruikt, retourneren beide methoden "lo world", omdat de tweede "l" in "hello" zich op positie 3 bevindt. Als er twee parameters zijn, "3" en "7", retourneren beide methoden "lo w" (de letter "o" in "world" bevindt zich op positie 7, dus wordt deze niet in het resultaat opgenomen).

Waarom zijn er twee methoden met volledig dezelfde functionaliteit? In feite zijn deze methoden niet volledig hetzelfde, maar ze verschillen alleen iets in de manier waarop ze negatieve parameters behandelen.

Voor negatieve parameters gebruikt de slice() methode de lengte van de string plus het parameter, terwijl substring() het als 0 behandelt (dus wordt het genegeerd). Bijvoorbeeld:

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

Op deze manier is het duidelijk wat de主要 verschil is tussen slice() en substring() methoden.

Als alleen parameter -3 wordt gebruikt, retourneert slice() "rld", terwijl substring() "hello world" retourneert. Dit komt doordat slice("-3") voor de string "hello world" wordt omgezet naar slice("8"), en substring("-3") wordt omgezet naar substring("0").

Ook is het verschil duidelijk wanneer parameter 3 en -4 worden gebruikt. slice() wordt omgezet naar slice(3, 7), net als in de vorige voorbeelden, en retourneert "lo w". De substring() methode interpreteert de parameters echter als substring(3, 0), wat eigenlijk substring(0, 3) is, omdat substring() altijd de kleinere getal als startpositie en het grotere getal als eindpositie gebruikt. Daarom retourneert substring("3, -4") "hel". De laatste regel code wordt gebruikt om te illustreren hoe deze methoden worden gebruikt.

toLowerCase(), toLocaleLowerCase(), toUpperCase() en toLocaleUpperCase()

Het volgende set van methoden die we bespreken, gaat over het omzetten van hoofd- en kleine letters. Er zijn vier methoden die de omzetting van hoofd- en kleine letters uitvoeren, namelijk

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

Zoals de namen aangeven, gebruiken de eerste twee methoden om een string om te zetten naar lage letters, terwijl de laatste twee methoden gebruikt worden om een string om te zetten naar grote letters.

toLowerCase() en toUpperCase() methoden zijn origineel en zijn geïmplementeerd op basis van dezelfde methoden in java.lang.String.

toLocaleLowerCase() en toLocaleUpperCase() methoden zijn gebaseerd op een specifieke regio (net als met localeCompare() methoden). In veel regio's zijn de regio-specifieke methoden identiek aan de algemene methoden. Er zijn echter enkele talen die specifieke regels toepassen op Unicode-groot-kleesomzetting (bijvoorbeeld Turks), dus moet de regio-specifieke methode worden gebruikt om een juiste conversie uit te voeren.

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

In deze code geven toUpperCase() en toLocaleUpperCase() beide "HELLO WORLD" uit, terwijl toLowerCase() en toLocaleLowerCase() beide "hello world" uitvoeren. Over het algemeen is het veiliger om de regionaal specifieke methoden te gebruiken als je niet weet in welke encoding een taal wordt uitgevoerd.

Tip:Onthoud dat alle eigenschappen en methoden van het String-object kunnen worden toegepast op de String-rawwaarde, omdat ze pseudo-objecten zijn.

instanceof-betekenis

Bij het gebruiken van de typeof-betekenis kan een probleem optreden als referenties worden opgeslagen met een referentiesoort, want het retourneert "object" ongeacht het type object dat wordt gerefereerd. ECMAScript heeft een andere Java-betekenis, instanceof, geïntroduceerd om dit probleem op te lossen.

De instanceof-betekenis is vergelijkbaar met de typeof-betekenis, gebruikt om het type van het object dat wordt verwerkt te identificeren. In tegenstelling tot de typeof-methode vereist de instanceof-methode dat ontwikkelaars expliciet bevestigen dat het object van een specifiek type is. Bijvoorbeeld:

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

Deze code vraagt zich af of 'variable oStringObject' een instantie is van het String-object? oStringObject is inderdaad een instantie van het String-object, dus het resultaat is "true". Hoewel het minder flexibel is dan de typeof-methode, is de instanceof-methode toch zeer nuttig wanneer typeof "object" teruggeeft.