ECMAScript referencetyper

Referencetyper kaldes ofte klasser (class).

Dette tutorial vil diskutere et bredt udvalg af foruddefinerede referencetyper i ECMAScript.

Referencetyper

Referencetyper kaldes ofte klasser (class), hvilket betyder, at når man håndterer referencewærdier, håndterer man objekter.

Dette tutorial vil diskutere et bredt udvalg af foruddefinerede referencetyper i ECMAScript.

Fra nu af vil vi fokusere på referencetyper, der er tæt forbundet med de allerede diskuterede primitive typer.

Bemærk:Ifølge den traditionelle betydning har ECMAScript ikke rigtig klasser. Faktisk optræder ordet 'klasse' ikke engang i ECMA-262. ECMAScript definerer 'objektdefinition', som logisk set er lig med klasser i andre programmeringssprog.

Tip:This tutorial will use the term "object".

Objects are created by the new operator followed by the name of the object to be instantiated. For example, the following code creates an instance of the Object object:

var o = new Object();

This syntax is similar to the Java language, but when there are more than one parameter, ECMAScript requires the use of parentheses. If there are no parameters, as shown in the following code, parentheses can be omitted:

var o = new Object;

Bemærk:Although parentheses are not required, it is best to use them to avoid confusion.

Tip:We will delve deeper into objects and their behavior in the chapter on object basics.

This section focuses on reference types that have equivalent primitive types.

Object object

The Object object is not very useful on its own, but it is still worth understanding it before learning other classes. Because the Object object in ECMAScript is similar to java.lang.Object in Java, all objects in ECMAScript inherit from this object, and all properties and methods in the Object object will appear in other objects, so understanding the Object object can better understand other objects.

The Object object has the following properties:

constructor
Reference (pointer) to the function that creates the object. For the Object object, this pointer points to the original Object() function.
Prototype
Reference to the object prototype of the object. For all objects, it defaults to returning an instance of the Object object.

The Object object also has several methods:

hasOwnProperty(property)
Determine whether the object has a specific property. The property must be specified as a string. (For example, o.hasOwnProperty("name")
IsPrototypeOf(object)
Determine whether the object is the prototype of another object.
PropertyIsEnumerable
Determine whether the given property can be enumerated by the for...in statement.
ToString()
Return the original string representation of the object. For the Object object, ECMA-262 does not define this value, so different ECMAScript implementations have different values.
ValueOf()
Return the original value that is most suitable for the object. For many objects, the value returned by this method is the same as the value returned by ToString().

Kommentarer:Enhver egenskab og metode, der er nævnt ovenfor, vil blive overskrevet af andre objekter.

Boolean-objekt

Boolean-objektet er en referencetype til Boolean-primærtypen.

For at oprette et Boolean-objekt skal du kun overføre en Boolean-værdi som parameter:

var oBooleanObject = new Boolean(true);

Boolean-objektet erstatter Object-objektets ValueOf() metode og returnerer den oprindelige værdi, dvs. true og false. ToString() metoden erstattes også og returnerer strengen "true" eller "false".

Desværre bruges Boolean-objekter sjældent i ECMAScript, og selv når de bruges, er det svært at forstå.

Problemer opstår ofte, når Boolean-objekter bruges i Boolean-udtryk. For eksempel:

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

I denne kode oprettes et Boolean-objekt med værdien false. Derefter udføres AND-operation mellem dette værdi og den oprindelige værdi true. Resultatet af AND-operationen mellem false og true er false. Men i denne linje beregnes oFalseObject, ikke dens værdi false.

Som diskuteret tidligere, konverteres alle objekter automatisk til true i Boolean-udtryk, så oFalseObject's værdi er true. Derefter udføres AND-operation mellem true og true, hvilket resulterer i true.

Bemærk:Selvom du bør kende til tilgængeligheden af Boolean-objektet, er det bedre at bruge Boolean-primærtypen for at undgå de problemer, der nævnes i dette afsnit.

See

For mere information om Boolean-objektet, besøg JavaScript Boolean 对象参考手册.

Number-objekt

Som du måske har tænkt dig, er Number-objektet en referencetype til Number-primærtypen. For at oprette et Number-objekt, brug følgende kode:

var oNumberObject = new Number(68);

Du bør allerede have genkendt Number-objektet, der blev diskuteret i kapitelens tidligere afsnit om specialværdier (som Number.MAX_VALUE). Alle specialværdier er statiske egenskaber for Number-objektet.

For at få nummerobjektets oprindelige værdi, skal du bruge valueOf() metoden:

var iNumber = oNumberObject.valueOf();

Selvfølgelig har Number-klassen også en toString() metode, som er detaljeret diskuteret i afsnittet om typekonvertering.

Udover de standardmetoder, der arves fra Object-objektet, har Number-objektet også nogle specifikke metoder til håndtering af tal.

toFixed() metoden

toFixed() metoden returnerer en strengrepræsentation af et tal med et bestemt antal decimaler. For eksempel:

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

Her er parameteren for toFixed() metoden 2, hvilket betyder, at der skal vises to decimaler. Denne metode returnerer "68.00", tomme strengpositioner suppleres med 0. For programmer, der håndterer valuta, er denne metode meget nyttig. toFixed() metoden kan repræsentere tal med 0 til 20 decimaler, værdier over dette område vil udløse en fejl.

toExponential() metoden

En anden metode relateret til formatering af tal er toExponential(), som returnerer tallet i en strengform i videnskabelig notation.

Ligesom toFixed() metoden har toExponential() metoden også en parameter, der angiver antallet af decimaler, der skal outputtes. For eksempel:

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

Dette kodes resultat er "6.8e+1", som tidligere forklaret, det repræsenterer 6.8x101Problemet er, hvad hvis man ikke ved, hvilket format (forudbestemt format eller eksponentielt format) der skal bruges til at repræsentere tallet? Man kan bruge toPrecision() metoden.

toPrecision() metoden

toPrecision() metoden returnerer det forudbestemte format eller eksponentielle format for et tal baseret på det mest betydningsfulde format. Den har en parameter, der er det samlede antal cifre, der bruges til at repræsentere tallet (inkluderer ikke eksponenten). For eksempel,

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

Dette kodes opgave er at repræsentere tallet 68 med ét ciffer, resultatet er "7e+1", udtrykt på en anden måde er det 70. Sandelig, toPrecision() metoden runder tal af.

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

Selvfølgelig, output er "68", fordi dette netop er det nøjagtige udtryk for dette tal. Men hvad hvis det angivne antal cifre er flere end nødvendige?

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 correctly represent a number 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 often to avoid potential problems. As far as possible, use the primitive representation of numbers.

See

For more information about the Number object, please visit JavaScript Number 对象参考手册.

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");

The valueOf() and toString() methods of the String object both 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.

Kommentarer: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 chapters of this tutorial or refer to JavaScript String 对象参考手册.

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 (compared 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 individual characters in a string. Both methods have a parameter, which is the position of the character to be operated on.

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

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

I strengen "hello world" er den karakter på position 1 "e" i afsnittet "ECMAScript grundlæggende typer" har vi tidligere diskuteret, at den første karakterposition er 0, den anden karakterposition er 1, osv. Derfor returnerer charAt(1) "e".

Hvis man ønsker at få fat i ikke en karakter, men en karakterkode, kan man kalde charCodeAt() metoden:

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

Dette eksempel outputter "101", som er det karakterkode for den lille bogstav "e".

concat() metoden

Næste er concat() metoden, som bruges til at tilføje en eller flere strenger til den oprindelige værdi af String-objektet. Denne metode returnerer den oprindelige værdi af String-objektet og ændrer ikke det oprindelige String-objekt:

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

I dette stykke kode returnerer concat() metoden "hello world", mens String-objektet stadig indeholder "hello " pga. denne grund er det mere almindeligt at bruge plus (+) for at koble strenger sammen, fordi denne form fra et logisk synspunkt viser det faktiske opførsel:

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

indexOf() og lastIndexOf() metoderne

Indtil videre har vi diskuteret metoder til at koble strenger sammen og til at få adgang til en enkelt karakter i en streng. Men hvad skal man kalde, hvis man ikke er sikker på, om en bestemt karakter faktisk findes i en streng? I dette tilfælde kan man kalde indexOf() og lastIndexOf() metoderne.

indexOf() og lastIndexOf() metoderne returnerer alle de specifikke understrenges positioner i en anden streng. Hvis understrengen ikke findes, returneres -1.

De to metoder adskiller sig i, at indexOf() metoden starter at søge i strengen fra begyndelsen (position 0), mens lastIndexOf() metoden starter fra slutningen af strengen. For eksempel:

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

Her er den første "o"-streng på position 4, dvs. "hello"'s "o"; den sidste "o" er på position 7, dvs. "world"'s "o". Hvis der kun er én "o"-streng i strengen, returnerer indexOf() og lastIndexOf() metoderne samme position.

localeCompare() metoden

Næste metode er localeCompare(), der sorterer strenge. Denne metode har en parameter - den streng, der skal sammenlignes med, og returnerer en af følgende tre værdier:

  • Hvis et String-objekt er sorteret efter bogstaver i stigende rækkefølge før den angivne streng, returneres et negativt tal.
  • Hvis et String-objekt er lig med den angivne streng, returneres 0.
  • Hvis en String-objekt er sorteret efter bogstaver i stigende rækkefølge efter den angivne streng, returneres et positivt tal.

Kommentarer:Hvis der returneres et negativt tal, er det oftest -1, men det faktiske tal returneres af implementeringen. Hvis der returneres et positivt tal, er det oftest 1, men det faktiske tal returneres af implementeringen.

Her er et eksempel:

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

I dette stykket kode sammenlignes strengen "yellow" med 3 værdier, nemlig "brick", "yellow" og "zoo". Da de er sorteret alfabetisk, er "yellow" efter "brick", så localeCompare() returnerer 1; "yellow" er lig med "yellow", så localeCompare() returnerer 0; "zoo" er efter "yellow", så localeCompare() returnerer -1. Lad os gentage, at værdien, der returneres, er bestemt af implementeringen, så det er bedst at kalde localeCompare() metoden på denne måde:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " kommer før " + oStringObject2);
}
  alert(oStringObject1 + " kommer efter " + oStringObject2);
}
  alert("De to strenge er ens");
}

Med denne struktur kan man sikre, at dette stykke kode kører korrekt i alle implementeringer.

localeCompare() metodens unikke egenskab er, at den specifikke region (locale, der også refererer til land/region og sprog) præcist beskriver, hvordan denne metode kører. I USA er engelsk standard sprog for ECMAScript-implementeringen, og localeCompare() er forskelskelsesfølsom, hvor store bogstaver kommer efter små bogstaver i alfabetisk rækkefølge. Men i andre regioner kan dette ikke være tilfældet.

slice() og substring()

ECMAScript tilbyder to metoder til at oprette strengværdier fra understreng, nemlig slice() og substring(). Begge metoder returnerer understrengene, der skal håndteres, og accepterer en eller to parametre. Den første parameter er startpositionen for den ønskede understreng, og den anden parameter (hvis brugt) er positionen for afslutningen af understrengen (dvs. det karakter, der er på afslutningspositionen, inkluderer ikke i den returnerede værdi). Hvis den anden parameter udelades, er afslutningspositionen standardiseret til længden af strengen.

Som med concat() metoden ændrer slice() og substring() metoderne ikke String-objektets værdi selv. De returnerer kun den oprindelige String-værdi og bevares String-objektet uændret.

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

I dette eksempel er brugen af slice() og substring() ens, og de returnerer også de samme værdier. Når der kun er parameter 3, returnerer begge metoder "lo world", fordi den anden "l" i "hello" er på position 3. Når der er to parametre "3" og "7", returnerer begge metoder "lo w" (bogstaven "o" i "world" er på position 7, så den er ikke inkluderet i resultatet).

Hvorfor er der to funktioner, der er helt ens? Faktisk er de ikke helt ens, men de adskiller sig kun lidt i, hvordan de håndterer negative parametre.

For negative parametre bruger slice() metoden længden af strengen plus parameteren, mens substring() metoden behandler det som 0 (dvs. ignorerer det). For eksempel:

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

På denne måde kan man se det vigtigste forskel mellem slice() og substring() metoderne.

Når der kun er parameter -3, returnerer slice() "rld" og substring() returnerer "hello world". Dette skyldes, at for strengen "hello world", konverteres slice("-3") til slice("8") og substring("-3") til substring("0").

Samme, når man bruger parameterne 3 og -4, er forskellen også meget tydelig. slice() vil blive konverteret til slice(3, 7), som i de tidligere eksempler, og returnere "lo w". substring() metoden vil dog fortolke de to parametre som substring(3, 0)，som faktisk er substring(0, 3)，fordi substring() altid bruger den mindre tal som startposition og den større tal som slutposition. Derfor returnerer substring("3, -4") "hel". Det sidste linje kode bruges til at forklare, hvordan man bruger disse metoder.

toLowerCase(), toLocaleLowerCase(), toUpperCase() og toLocaleUpperCase()

Det sidste sæt metoder, der skal diskuteres, involverer stor/klein skrift omzetting. Der er 4 metoder til at udføre stor/klein skrift omzetting, nemlig

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

Det kan ses af navnet, at de første to metoder bruges til at konvertere en streng til hele små bogstaver, og de sidste to metoder bruges til at konvertere en streng til hele store bogstaver.

toLowerCase() og toUpperCase() metoderne er primitive og er implementeret som prototyper af de samme metoder i java.lang.String.

toLocaleLowerCase() og toLocaleUpperCase() metoderne er baseret på specifikke regioner (som er tilfældet med localeCompare() metoden). I mange regioner er region-specifikke metoder helt ens med de generelle metoder. Dog anvender nogle sprog specifikke regler for Unicode stor/klein skrift omzetting (f.eks. tyrkisk), og derfor skal region-specifikke metoder bruges for at få korrekt omzetting.

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"

I denne kode outputter både toUpperCase() og toLocaleUpperCase() "HELLO WORLD", og både toLowerCase() og toLocaleLowerCase() outputter "hello world". Generelt set er det mere sikkert at bruge regionsspecifikke metoder, hvis man ikke ved, hvilken encoding et sprog kører i.

Tip:Husk, at alle egenskaber og metoder for String-objektet kan anvendes på String-primærværdien, fordi de er pseudoobjekter.

instanceof-operatoren

Når man bruger typeof-operatoren med referencetyper til at gemme værdier, opstår der et problem, uanset hvilken type objekt der refereres til, det returnerer altid "object". ECMAScript har introduceret en anden Java-operator, instanceof, for at løse dette problem.

instanceof-operatoren ligner typeof-operatoren og bruges til at identificere typen af det objekt, der håndteres. Forskellen på typeof-metoden er, at instanceof-metoden kræver, at udvikleren tydeligt bekræfter, at objektet er af en bestemt type. For eksempel:

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

Denne kode spørger "Er variablen oStringObject en instans af String-objektet?" oStringObject er virkelig en instans af String-objektet, så resultatet er "true". Selvom det ikke er så fleksibelt som typeof-metoden, er instanceof-metoden stadig meget nyttig, når typeof-metoden returnerer "object".