ECMAScript referenstyper

Referenstyper kallas ofta klasser (class).

Denna kurs kommer att diskutera ett brett utbud av fördefinierade referenstyper i ECMAScript.

Referenstyper

Referenstyper kallas ofta klasser (class), vilket innebär att när man hanterar referensvärden, handlar det om objekt.

Denna kurs kommer att diskutera ett brett utbud av fördefinierade referenstyper i ECMAScript.

Från och med nu kommer vi att fokusera på referenstyper som är nära relaterade till de redan diskuterade ursprungliga typerna.

Observera:Icke traditionellt sett har ECMAScript inte klasser. Faktiskt, förutom att det inte finns några klasser, nämns ordet "klass" inte ens i ECMA-262. ECMAScript definierar "objektdefiniering", som logiskt är ekvivalent med klasser i andra programmeringsspråk.

Tips:Denna tutorial kommer att använda termen "objekt".

Objekt skapas genom att använda new-operatorn tillsammans med namnet på det objekt som ska instansieras. Till exempel skapar följande kod en instans av Object-objektet:

var o = new Object();

Denna syntax liknar Java-språket, men när det finns mer än en parameter kräver ECMAScript att parenteser används. Om det inte finns några parametrar, kan parenteserna utelämnas, som i följande kod:

var o = new Object;

Observera:Även om parenteser inte är nödvändiga, är det bäst att använda dem för att undvika förvirring.

Tips:Vi kommer att utforska objekt och deras beteende mer djupt i kapitlet om objekter.

Denna sektion fokuserar på referenstyper som har ekvivalenta ursprungliga datatyper.

Object-objektet

Object-objektet är inte så användbart i sig själv, men det är ändå bra att förstå det innan man lär sig andra klasser. Eftersom Object-objektet i ECMAScript liknar java.lang.Object i Java, är alla objekt i ECMAScript avledna från detta objekt, och alla egenskaper och metoder i Object-objektet kommer att dyka upp i andra objekt. Därför, genom att förstå Object-objektet, kan man bättre förstå andra objekt.

Object-objektet har följande egenskaper:

constructor
En referens (pekare) till funktionen som skapade objektet. För Object-objekt pekar denna pekare på den ursprungliga Object()-funktionen.
Prototype
En referens till objektets objektprototyp. För alla objekt returnerar den standardmässigt en instans av Object-objektet.

Object-objektet har också några metoder:

hasOwnProperty(property)
Avgör om objektet har en specifik egenskap. Det måste anges som en sträng. (Till exempel, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Avgör om detta objekt är prototypen för ett annat objekt.
PropertyIsEnumerable
Avgör om den givna egenskapen kan enumereras med for...in-satsen.
ToString()
Returnerar objektets ursprungliga strängrepresentation. För Object-objekt har ECMA-262 inte definierat detta värde, så olika ECMAScript-implementeringar har olika värden.
ValueOf()
Återställ den ursprungliga värdet som är mest lämpligt för objektet. För många objekt är värdet som returneras av denna metod detsamma som värdet som returneras av ToString().

Kommentar:Varje egenskap och metod som listas ovan kommer att överskrivas av andra objekt.

Boolean-objekt

Boolean-objekt är referenstyper för den grundläggande Boolean-typen.

För att skapa ett Boolean-objekt behöver du endast överföra ett Boolean-värde som parameter:

var oBooleanObject = new Boolean(true);

Boolean-objektet överskriver ValueOf() -metoden i Object-objektet och returnerar det ursprungliga värdet, dvs. true och false..ToString() -metoden överskrivs också och returnerar strängen "true" eller "false".

Tyvärr används Boolean-objekt sällan i ECMAScript, och även om de används, är de svåra att förstå.

Problemen uppstår ofta när Boolean-objekt används i Boolean-uttryck. Till exempel:

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

I detta kodexempel skapas ett Boolean-objekt med false-värdet. Därefter utförs en AND-operation med det ursprungliga värdet true. Resultatet av en AND-operation mellan false och true är false. Men i denna rad beräknas oFalseObject, inte dess värde false.

Som diskuterats tidigare, omvandlas alla objekt automatiskt till true i Boolean-uttryck, så oFalseObject är true. Därefter utförs en AND-operation med true, vilket resulterar i true.

Observera:Även om du bör känna till tillgängligheten av Boolean-objekt, är det bäst att använda de grundläggande Boolean-värdena för att undvika de problem som nämns i detta avsnitt.

参阅

För mer information om Boolean-objekt, besök JavaScript Boolean 对象参考手册。

Number-objekt

Som du kanske tänker dig är Number-objektet en referenstyp för det grundläggande numeriska typen. För att skapa ett Number-objekt, använd följande kod:

var oNumberObject = new Number(68);

Du bör redan ha igenkännt Number-objektet som nämns i föregående avsnitt i detta kapitel, när vi diskuterade specialvärden (t.ex. Number.MAX_VALUE). Alla specialvärden är statiska egenskaper för Number-objektet.

För att få det ursprungliga värdet av ett numeriskt objekt, behöver du använda valueOf() -metoden:

var iNumber = oNumberObject.valueOf();

Naturligtvis har Number-klassen också en toString() metod, som har diskuterats i detalj i avsnittet om typkonvertering.

Förutom de standardmetoder som ärver Object-objektet, har Number-objektet också några specialmetoder för att hantera numeriska värden.

toFixed() metoden

toFixed() metoden returnerar en sträng som representerar ett tal med ett visst antal decimaler. Till exempel:

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

Här är parametern för toFixed() metoden 2, vilket innebär att två decimaler ska visas. Denna metod returnerar "68.00", de tomma tecknen fylls med 0. För applikationer som hanterar valuta är denna metod mycket användbar. toFixed() metoden kan representera tal med 0 till 20 decimaler, värden utanför detta intervall orsakar ett fel.

toExponential() metoden

En annan metod för att formatera tal är toExponential(), som returnerar en sträng som representerar talet i vetenskaplig notation.

Liksom toFixed() metoden har toExponential() metoden också en parameter som specificerar antalet decimaler som ska utmatas. Till exempel:

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

Resultatet av detta kodsegment är "6.8e+1", vilket har förklarat tidigare, det representerar 6.8x101Problemet är, vad om man inte vet vilket format (förutbestämt eller exponentiellt) som ska användas för att representera talet? Man kan använda toPrecision() metoden.

toPrecision() metoden

toPrecision() metoden returnerar den förutbestämda formen eller exponentformerna för ett tal baserat på det mest meningsfulla formatet. Den har en parameter, det är det totala antalet siffror som används för att representera talet (exklusive exponent). Till exempel,

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

Uppgiften för detta kodsegment är att representera talet 68 med ett siffra, resultatet är "7e+1", representerat på ett annat sätt är det 70. Det är sant, toPrecision() metoden ronderar tal. Men om man använder 2 siffror för att representera 68, blir det mycket enklare:

var oNumberObject = new Number(68);
alert(oNumberObject.toPrecision(2));  //Utmattningen är "68"

Naturligtvis är utmatningen "68", eftersom detta är den exakta representationen av talet. Men vad händer om det specificeras fler siffror än nödvändiga?

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

在这种情况下，toPrecision(3) 等价于 toFixed(1)，输出的是 "68.0"。

toFixed()、toExponential() 和 toPrecision() 方法都会进行舍入操作，以便用正确的小数位数正确地表示一个数。

Tips:与 Boolean 对象相似，Number 对象也很重要，不过应该少用这种对象，以避免潜在的问题。只要可能，都使用数字的原始表示法。

参阅

如需更多有关 Number 对象的信息，请访问 JavaScript Number 对象参考手册。

String 对象

String 对象是 String 原始类型的对象表示法，它是以下方式创建的：

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

String 对象的 valueOf() 方法和 toString() 方法都会返回 String 类型的原始值：

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

如果运行这段代码，输出是 "true"，说明这些值真的相等。

Kommentar:String 对象是 ECMAScript 中比较复杂的引用类型之一。同样，本节的重点只是 String 类的基本功能。更多的高级功能请阅读本教程相关的章节，或参阅 JavaScript String 对象参考手册。

length 属性

String 对象具有属性 length，它是字符串中的字符个数：

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

这个例子输出的是 "11"，即 "hello world" 中的字符个数。注意，即使字符串包含双字节的字符（与 ASCII 字符相对，ASCII 字符只占用一个字节），每个字符也只算一个字符。

charAt() 和 charCodeAt() 方法

String 对象还拥有大量的方法。

首先，两个方法 charAt() 和 charCodeAt() 访问的是字符串中的单个字符。这两个方法都有一个参数，即要操作的字符的位置。

charAt() 方法返回的是包含指定位置处的字符的字符串：

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

I strängen "hello world" är tecknet vid position 1 "e". I avsnittet "ECMAScript originaltyp" har vi talat om att den första teckenpositionen är 0, den andra teckenpositionen är 1, och så vidare. Därför returnerar charAt(1) "e".

Om du vill få teckenkoden snarare än tecknet själv, kan du anropa charCodeAt() -metoden:

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

Denna exempeloutput är "101", vilket är teckenkoden för den lille bokstaven "e".

concat() metoden

Nästa är concat() -metoden, som används för att foga till en eller flera strängar till den ursprungliga värdet på String-objektet. Denna metod returnerar String-ursprungsvärdet, utan att ändra det ursprungliga String-objektet:

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

I detta stycke kod returnerar concat() -metoden "hello world", medan String-objektet förvarar fortfarande "hello ". Av denna anledning är det vanligare att använda plus (+) för att ansluta strängar, eftersom detta format logiskt visar det verkliga beteendet:

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

indexOf() och lastIndexOf() metoder

Hittills har vi diskuterat metoder för att ansluta strängar och metoder för att komma åt enskilda tecken i en sträng. Men om du inte kan fastställa om ett tecken verkligen finns i en sträng, vad bör du då anropa? I detta fall kan du anropa indexOf() och lastIndexOf() -metoderna.

Båda indexOf() och lastIndexOf() -metoderna returnerar positionen för den specifika delsträngen i en annan sträng. Om delsträngen inte hittas, returneras -1.

Dessa två metoder skiljer sig från varandra genom att indexOf() -metoden söker efter en delsträng från början av en sträng (position 0), medan lastIndexOf() -metoden söker från slutet av strängen. Till exempel:

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

Här finns den första "o"-strängen på position 4, det vill säga "hello"-strängens "o"; den sista "o"-strängen finns på position 7, det vill säga "world"-strängens "o". Om strängen endast innehåller en "o"-sträng, returnerar indexOf() och lastIndexOf()-metoderna samma position.

localeCompare() metod

Nästa metod är localeCompare(), som sorterar strängar. Denna metod har ett parameter - den sträng som ska jämföras, och returnerar en av följande tre värden:

  • Om ett String-objekt är ordnat efter bokstavsordning innan den angivna strängen, returneras ett negativt tal.
  • Om ett String-objekt är lika med den angivna strängen, returneras 0
  • Om en String-objekt är ordnat efter bokstavsordning efter den angivna strängen, returneras ett positivt tal.

Kommentar:Om det returneras ett negativt tal, är det vanligast att det är -1, men det som faktiskt returneras bestäms av implementeringen. Om det returneras ett positivt tal, är det också vanligast att det är 1, men det som faktiskt returneras bestäms av implementeringen.

Ett exempel visas nedan:

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

I detta kodavsnitt jämförs strängen "yellow" med 3 värden, nämligen "brick", "yellow" och "zoo". Eftersom de är ordnade i bokstavsordning ligger "yellow" efter "brick", så returnerar localeCompare() 1; "yellow" är lika med "yellow", så localeCompare() returnerar 0; "zoo" ligger efter "yellow", så localeCompare() returnerar -1. Återigen, eftersom det är implementeringen som bestämmer de returnerade värdena, är det bäst att anropa localeCompare() metoden på följande sätt:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " kommer före " + oStringObject2);
}
  alert(oStringObject1 + " kommer efter " + oStringObject2);
}
  alert("De två strängarna är lika");
}

Genom att använda denna struktur kan man säkerställa att detta kodstycke fungerar korrekt i alla implementeringar.

localeCompare()-metodens unika egenskap är att den specifika regionen (locale, som också kan syfta på land/region och språk) exakt beskriver hur denna metod fungerar. I USA är engelska det standard språk för ECMAScript-implementeringen, och localeCompare() är känslig för bokstäver. Stora bokstäver kommer efter små bokstäver i bokstavsordning. Men i andra regioner kan detta inte vara fallet.

slice() och substring()

ECMAScript erbjuder två metoder för att skapa strängvärden från understrängar, nämligen slice() och substring(). Båda metoderna returnerar understrängar av den sträng som ska bearbetas och accepterar en eller två parametrar. Den första parametern är startpositionen för den understräng som ska hämtas, och den andra parametern (om den används) är positionen för att stoppa innan understrängen (detta innebär att tecknet vid den stopppositionen inte inkluderas i den returnerade värdet). Om den andra parametern utelämnas, blir stopppositionen standard till strängens längd.

Som med concat()-metoden ändrar inte slice() och substring()-metoder String-objektets egna värde. De returnerar bara det ursprungliga String-värdet och behåller String-objektet oförändrat.

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

I detta exempel är användningen av slice() och substring() samma, och de returnerar också samma värden. När endast parametern 3 används, returnerar båda metoderna "lo world", eftersom den andra "l" i "hello" ligger på position 3. När det finns två parametrar "3" och "7", returnerar båda metoderna "lo w" (bokstaven "o" i "world" ligger på position 7, så den inkluderas inte i resultatet).

Varför finns det två metoder med helt identical funktioner? Faktiskt är de inte helt identiska, men de skiljer sig bara något när parametrarna är negativa. Hur de behandlar parametrarna skiljer sig något.

För negativa parametrar använder slice()-metoden strängens längd plus parametern, medan substring()-metoden behandlar den som 0 (det vill säga ignorerar den). Till exempel:

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

På detta sätt kan man se skillnaden mellan metoderna slice() och substring().

När endast parametern -3 används, returnerar slice() "rld", medan substring() returnerar "hello world". Detta beror på att för strängen "hello world", kommer slice("-3") att omvandlas till slice("8"), medan substring("-3") kommer att omvandlas till substring("0").

Likaså, när används parametrar 3 och -4, skillnaden är också mycket tydlig. slice() kommer att konverteras till slice(3, 7), som i de tidigare exemplen, returnerar "lo w". Medan substring() metoden tolkar två parametrar som substring(3, 0), vilket i praktiken är substring(0, 3), eftersom substring() alltid använder den mindre numret som startposition och det större numret som slutposition. Därför returnerar substring("3, -4") "hel". Det sista raden kod används för att förklara hur man använder dessa metoder.

toLowerCase(), toLocaleLowerCase(), toUpperCase() och toLocaleUpperCase()

Det nästa att diskutera är metoderna för storlekskonvertering. Det finns 4 metoder för att utföra storlekskonvertering, dvs

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

Deras användning kan förstås från namnet, de två första metoderna används för att konvertera strängen till helt små bokstäver, de två sista metoderna används för att konvertera strängen till helt stora bokstäver.

toLowerCase() och toUpperCase() metoderna är ursprungliga och implementerade efter samma metod i java.lang.String.

toLocaleLowerCase() och toLocaleUpperCase() metoderna är baserade på specifika regioner (som är samma som localeCompare() metoden). I många regioner är region specifika metoder helt identiska med de allmänna metoderna. Men för några språk tillämpas specifika regler för Unicode storlekskonvertering (t.ex. turkiska), så det är nödvändigt att använda region specifika metoder för att genomföra korrekt konvertering.

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

I denna kod är utmatningen från toUpperCase() och toLocaleUpperCase() "HELLO WORLD", och utmatningen från toLowerCase() och toLocaleLowerCase() är "hello world". Generellt sett är det säkrare att använda regionsspecifika metoder om man inte vet i vilket kodningsspråk en språk körs.

Tips:Kom ihåg att alla egenskaper och metoder för String-objekt kan användas på String-ursprungliga värden, eftersom de är pseudookonter.

instanceof-operatoren

När man använder typeof-operatoren och lagrar värden i referenstyper uppstår ett problem, eftersom det oavsett vilken typ av objekt som refereras till returnerar det "object". ECMAScript introducerade en annan Java-operator, instanceof, för att lösa detta problem.

instanceof-operatoren liknar typeof-operatoren, och används för att identifiera typen av objekt som hanteras. Skillnaden är att instanceof-metoden kräver att utvecklaren tydligt bekräftar att objektet är av ett specifikt typ. Till exempel:

var oStringObject = new String("hello world");
alert(oStringObject instanceof String);	//Uppgiften är "true"

Denna kod frågar om "är variabeln oStringObject en instans av String-objekt?" oStringObject är verkligen en instans av String-objekt, så resultatet är "true". Även om det inte är lika flexibelt som typeof-metoden, är instanceof-metoden fortfarande mycket användbar när typeof-metoden returnerar "object".