ECMAScript-referenssityypit

Viittauslajit kutsutaan yleensä luokiksi (class).

Tämä kurssi käsittelee suuren määrän ECMAScriptin esitäytettyjä viittauslajeja.

Viittauslajit

Viittauslajit kutsutaan yleensä luokiksi (class), eli kun käsitellään viittausarvoa, käsitellään objektia.

Tämä kurssi käsittelee suuren määrän ECMAScriptin esitäytettyjä viittauslajeja.

Tästä lähtien keskitymme keskustelussa läheisesti liittyviin alkuperäisiin tyyppien viittauslajeihin.

Huomioitavaa:Perinteisessä mielessä ECMAScript ei oikeastaan ole luokkaa. Itse asiassa, paitsi että luokan olemassaoloa ei mainita, sanaa 'luokka' ei esiinny lainkaan ECMA-262:ssa. ECMAScript määrittelee 'objektin määrittelyn', joka on loogisesti vastaava muissa ohjelmointikielissä olevia luokkia.

Vinkki:Tämä oppikirja käyttää termiä "objekti".

Objektit luodaan new-operaattorin avulla yhdessä objektin nimellä, jota halutaan instanssoida. Esimerkiksi seuraava koodi luo Object-objektin instanssin:

var o = new Object();

Tämä syntaksi on samanlainen kuin Java-kielen syntaksi, mutta ECMAScript vaatii sulkeiden käyttöä, kun on useita parametreja. Jos parametreja ei ole, kuten seuraavassa esimerkissä, sulkeet voidaan jättää pois:

var o = new Object;

Huomioitavaa:Vaikka sulkeet eivät ole välttämättömiä, on parasta käyttää niitä sekavuuden välttämiseksi.

Vinkki:Tutkimme objekteja ja niiden käyttäytymistä tarkemmin objektien perusteissa.

Tämä luku keskittyy objekteihin, joilla on vastaavat alkuperäiset tyyppien viittaukset.

Object-objekti

Object-objekti ei ole erityisen hyödyllinen, mutta ennen muiden luokkien ymmärtämistä sen tulisi olla tiedossa. Koska ECMAScriptissä Object-objekti on samanlainen kuin Java: n java.lang.Object, kaikki ECMAScript-objektit perivät tästä objektista, ja Object-objektin kaikki ominaisuudet ja metodit näkyvät myös muissa objekteissa, joten ymmärtämällä Object-objektin voi ymmärtää paremmin muita objekteja.

Object-objekti sisältää seuraavat ominaisuudet:

constructor
Viittaus luomisen funktioon (osoitin). Object-objektin osalta tämä osoitin viittaa alkuperäiseen Object()-funktioon.
Prototype
Viittaus objektin objektirotuun. Kaikille objekteille se palauttaa oletusarvoisesti Object-objektin instanssin.

Object-objekti sisältää myös useita menetelmiä:

hasOwnProperty(property)
Arvioi, onko objektilla tiettyä ominaisuutta. Ominaisuuden täytyy olla merkkijonona määritelty. (Esimerkiksi o.hasOwnProperty("name"))
IsPrototypeOf(object)
Arvioi, onko tämä objekti toisen objektin luetteloinnin alku.
PropertyIsEnumerable
Arvioi, voidaanko annettua ominaisuutta käsitellä for...in-lausekkeella.
ToString
Palauttaa objektin alkuperäisen merkkijonon esityksen. Object-objektin osalta ECMA-262 ei määrittele tätä arvoa, joten eri ECMAScript-实现illä on eri arvot.
ValueOf
Palauttaa sopivimman alkuperäisen arvon objektille. Monille objekteille tämä metodi palauttaa saman arvon kuin.ToString()

Kommentit:Yllä luetellut jokainen ominaisuus ja metodi korvataan muilla objekteilla.

Boolean-objekti

Boolean-objekti on Boolean-alkuperäisen tyyppinen viittauslaji.

Luo Boolean-objekti vain välittämällä Boolean-arvon parametrina:

var oBooleanObject = new Boolean(true);

Boolean-objekti korvaa Object-objektin ValueOf()-menetelmän palauttaen alkuperäisen arvon, eli true ja false..ToString()-menetelmä korvataan myös ja palauttaa merkkijonon "true" tai "false".

Valitettavasti Boolean-objekteja käytetään harvoin ECMAScriptissä, ja vaikka ne käytetään, ne ovat vaikeita ymmärtää.

Ongelmat ilmenevät yleensä, kun Boolean-objekteja käytetään Boolean-lausekkeissa. Esimerkiksi:

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

Tässä koodissa luodaan Boolean-objekti false-arvolla. Tämän jälkeen tämä arvo suorittaa AND-operaation alkuperäisen true-arvon kanssa. Boolean-laskennassa false ja true:n AND-operaation tulos on false. Tässä riveissä kuitenkin lasketaan oFalseObject, ei sen arvo false.

Kuten edellä on käsitelty, kaikkia objekteja muunnetaan automaattisesti totuusarvoksi Boolean-lausekkeissa, joten oFalseObject-arvo on true. Tämän jälkeen true suorittaa AND-operaation true:n kanssa, ja tulos on true.

Huomioitavaa:Vaikka sinun tulisi tuntea Boolean-objektin saatavuuden, on parasta käyttää Boolean-alkuperäisiä arvoja välttääksesi tässä luvussa mainitut ongelmat.

参阅

Lisätietoja Boolean-objektista löydät JavaScript Boolean 对象参考手册。

Number-objekti

Kuten saatat odottaa, Number-objekti on Number-alkuperäisen tyyppinen viittauslaji. Luodaksesi Number-objektin, käytä seuraavaa koodia:

var oNumberObject = new Number(68);

Olet todennäköisesti tunnistanut tämän luvun aikaisemmassa osiossa käsitellyn Number-objektin, joka keskusteli erityisistä arvoista (kuten Number.MAX_VALUE). Kaikki erityisarvot ovat Number-objektin staattisia ominaisuuksia.

Saadaksesi numeronäytteen alkuperäisen Number-arvon, tarvitset vain käyttää valueOf()-menetelmää:

var iNumber = oNumberObject.valueOf();

Totta kai, Number-luokalla on myös toString() -metodi, jota on käsitelty yksityiskohtaisesti tyypin muuntamisen osiossa.

Lisäksi Number-objekti sisältää useita erityisiä metodeja, jotka käsittelevät lukuja, paitsi perusmetodit, jotka on peritty Object-objektilta.

toFixed() -metodi

toFixed() -metodi palauttaa luvun merkkijonon, jossa on tietty määrä desimaaleja. Esimerkiksi:

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

Tässä, toFixed() -metodin parametri on 2, mikä tarkoittaa, että tulisi näyttää kaksi desimaalia. Tämä metodi palauttaa "68.00", tyhjät merkkijonon sijasta täytetään nollilla. Tämä metodi on erittäin hyödyllinen valuutan käsittelyyn sovelluksissa. toFixed() -metodi voi esittää numeroita, joilla on 0-20 desimaalia, yli tämän arvon arvot aiheuttavat virheen.

toExponential() -metodi

toExponential() -metodi palauttaa luvun tieteellisen laskennan muodossa olevan merkkijonon. Esimerkiksi:

toExponential() -metodi on samanlainen kuin toFixed() -metodi, sillä on parametri, joka määrittää tulostettavien desimaalien määrän. Esimerkiksi:

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

Tämän koodin tuloksena on "6.8e+1", kuten on selitetty aiemmin, se edustaa 6.8x101Ongelma on, jos ei tiedetä, minkä tyyppistä muotoa (ennakkotarkistettu muoto tai eksponenttimuoto) lukuun tulisi käyttää. Voit käyttää toPrecision() -metodia.

toPrecision() -metodi

toPrecision() -metodi palauttaa luvun esityksen ennakkotarkistettuna muodossa tai eksponenttimuodossa. sillä on yksi parametri, joka määrittää luvun esityksen numeroiden kokonaismäärän (ei mukaan lukien eksponentti). Esimerkiksi:

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

Tämän koodin tehtävänä on esittää luku 68 yhdellä numerolla, tuloksena on "7e+1", joka toisessa muodossa on 70. Totta kai, toPrecision() -metodi sujuvuuslaskutoimituksia.

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

Totta kai, tulostettava arvo on "68", koska se on juuri oikea luvun esitys. Mutta mitä, jos määritettyä määrää on enemmän kuin tarvittavaa?

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

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

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

Vinkki:与 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"，说明这些值真的相等。

Kommentit: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"

Merkkijonossa "hello world" sijainnissa 1 oleva merkki on "e". "ECMAScript alkuperäistyyppien" osiossa olemme puhuneet siitä, että ensimmäisen merkin sijainti on 0, toisen merkin sijainti on 1 ja niin edelleen. Siksi charAt(1) -kutsu palauttaa "e".

Jos haluat saada merkin sijasta merkkikoodin, voit kutsua charCodeAt() -menetelmää:

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

Tämä esimerkki tulostaa "101", joka on pienikirjaimen "e" merkkikoodi.

concat() -menetelmä

Seuraavaksi on concat() -menetelmä, joka yhdistää yhden tai useamman merkkijonon String-objektin alkuperäiseen arvoon. Tämä menetelmä palauttaa String-alkuperäisen arvon ja säilyttää alkuperäisen String-objektin muuttumattomana:

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

Tässä koodissa concat() -menetelmän palauttama arvo on "hello world", mutta String-objekti sisältää edelleen "hello ". Tämän vuoksi yleisimmin käytetään plus (+) -merkkiä merkkijonojen yhdistämiseen, koska tämä muoto osoittaa todellisen toiminnan:

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

indexOf() ja lastIndexOf() -menetelmät

Tähän mennessä on käsitelty merkkijonojen yhdistämismenetelmiä ja tapoja saada yksittäisiä merkkejä merkkijonosta. Mutta jos ei ole varma, onko tiettyä merkkiä todella merkkijonossa, mitä menetelmää tulisi kutsua? Tässä tapauksessa voit kutsua indexOf() ja lastIndexOf() -menetelmiä.

indexOf() ja lastIndexOf() -menetelmät palauttavat aina määritetyn alimerkkiä toisessa merkkijonossa olevan sijainnin. Jos alimerkkiä ei löydy, palautetaan -1.

Näiden kahden menetelmän erona on, että indexOf() -menetelmä alkaa etsiä merkkijonoa alkupäästä (sijainti 0) ja lastIndexOf() -menetelmä alkaa etsiä alimerkkiä merkkijonojen lopusta. Esimerkiksi:

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

Tässä ensimmäinen "o"-merkkijono sijaitsee sijainnissa 4, eli "hello"-merkkijonossa oleva "o"; viimeinen "o" sijaitsee sijainnissa 7, eli "world"-merkkijonossa oleva "o". Jos merkkijonossa on vain yksi "o"-merkkijono, niin indexOf() ja lastIndexOf() -menetelmien palauttamat sijainnit ovat samat.

localeCompare() -menetelmä

Seuraava menetelmä on localeCompare(), joka järjestää merkkijonoja. Tällä menetelmällä on yksi parametri - vertailtava merkkijono, ja se palauttaa yhden kolmesta seuraavista arvoista:

  • Jos String-objekti sijoittuu parametrisessa merkkijonossa parametrisen merkkijonon edelle kirjainjärjestyksessä, se palauttaa negatiivisen luvun.
  • Jos String-objekti on yhtä suuri kuin parametrisessa merkkijonossa oleva merkkijono, se palauttaa 0.
  • Jos String-objekti sijoittuu parametrisessa merkkijonossa parametrisen merkkijonon jälkeen kirjainjärjestyksessä, se palauttaa positiivisen luvun.

Kommentit:Jos palautusarvo on negatiivinen, yleensä se on -1, mutta todellinen palautusarvo on määritetty toteutuksessa. Jos palautusarvo on positiivinen, samoin, yleensä se on 1, mutta todellinen palautusarvo on määritetty toteutuksessa.

Esimerkki seuraavaksi:

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

Tässä koodissa merkkijono "yellow" verrataan kolmeen arvoon, nimittäin "brick", "yellow" ja "zoo". Koska ne ovat järjestettyjä kirjainjärjestyksessä, "yellow" sijaitsee "brick" jälkeen, joten localeCompare() palauttaa 1; "yellow" on yhtä suuri kuin "yellow", joten localeCompare() palauttaa 0; "zoo" sijaitsee "yellow" jälkeen, localeCompare() palauttaa -1. Toistetaan vielä kerran, koska palautettu arvo on määritetty toteutuksessa, on parasta kutsua localeCompare() -menetelmää seuraavalla tavalla:

var oStringObject1 = new String("yellow");
var oStringObject2 = new String("brick");
var iResult = oStringObject1.localeCompare(oStringObject2);
if(iResult < 0) {
  alert(oStringObject1 + " comes before " + oStringObject2);
}
  alert(oStringObject1 + " comes after " + oStringObject2);
}
  alert("The two strings are equal");
}

Tämä rakenne takaa, että tämä koodi toimii oikein kaikissa toteutuksissa.

localeCompare() -menetelmän ainutlaatuisuus on, että toteutuksessa oleva alue (locale, joka viittaa sekä maahan että kieleen) määrittää tarkasti, miten tämä menetelmä toimii. Yhdysvalloissa englanti on ECMAScript-toteutuksen standardikieli, ja localeCompare() erottaa isokirjaimet ja pienikirjaimet, isokirjaimet sijoittuvat pienikirjaimien jälkeen kirjainten järjestyksessä. Mutta muilla alueilla tilanne voi olla erilainen.

slice() ja substring()

ECMAScript tarjoaa kaksi tapaa luoda merkkijonon arvo osajonosta, nimittäin slice() ja substring(). Molemmat menetelmät palauttavat käsiteltävän merkkijonon osajonon ja ne hyväksyvät yhden tai kaksi parametria. Ensimmäinen parametri on halutun osajonon alkuperäinen sijainti, toinen parametri (jos sitä käytetään) on osajonon päättymispiste ennen loppusijaintia (eli päättymispisteessä oleva merkki ei sisälly palautettuun arvoon). Jos toista parametria ei mainita, päättymispiste asetetaan oletuksena merkkijonon pituuteen.

Kuten concat() -menetelmä, slice() ja substring() -menetelmät eivät muuta String-objektin arvoa itsessään. Ne vain palauttavat alkuperäisen String-arvon ja säilyttävät String-objektin muuttumattomana.

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

Tässä esimerkissä slice() ja substring() metodien käyttö ja palautusarvot ovat samanlaisia. Kun parametri on vain 3, molemmat metodit palauttavat "lo world", koska merkkijonon "hello" toinen "l" sijaitsee sijainnissa 3. Kun parametreja on kaksi, "3" ja "7", molemmat metodit palauttavat arvon "lo w" (merkkijonon "world" kirjain "o" sijaitsee sijainnissa 7, joten se ei sisälly tulokseen).

Miksi on olemassa kaksi täysin saman toiminnan omaavaa metodia? Itse asiassa ne eivät ole täysin samanlaisia, mutta ne käsittelevät parametreja hieman eri tavoin vain negatiivisten parametrien osalta.

Negatiivisten parametrien osalta slice() metodi lisää parametrin merkkijonon pituuteen, substring() metodi puolestaan käsittelee sen 0:na (eli se jättää sen huomiotta). Esimerkiksi:

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

Tällä tavalla voidaan nähdä slice() ja substring() metodien pääasiallinen ero.

Kun vain parametri -3 on määritetty, slice() palauttaa "rld", substring() puolestaan palauttaa "hello world". Tämä johtuu siitä, että merkkijonosta "hello world" slice("-3") muunnetaan slice("8"):ksi, ja substring("-3") muunnetaan substring("0"):ksi.

同样，使用参数 3 和 -4 时，差别也很明显。slice() 将被转换成 slice(3, 7)，与前面的例子相同，返回 "lo w"。而 substring() 方法则将两个参数解释为 substring(3, 0)，实际上即 substring(0, 3)，因为 substring() 总把较小的数字作为起始位，较大的数字作为终止位。因此，substring("3, -4") 返回的是 "hel"。这里的最后一行代码用来说明如何使用这些方法。

toLowerCase()、toLocaleLowerCase()、toUpperCase() 和 toLocaleUpperCase()

最后一套要讨论的方法涉及大小写转换。有 4 种方法用于执行大小写转换，即

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

从名字上可以看出它们的用途，前两种方法用于把字符串转换成全小写的，后两种方法用于把字符串转换成全大写的。

toLowerCase() 和 toUpperCase() 方法是原始的，是以 java.lang.String 中相同方法为原型实现的。

toLocaleLowerCase() 和 toLocaleUpperCase() 方法是基于特定的区域实现的（与 localeCompare() 方法相同）。在许多区域中，区域特定的方法都与通用的方法完全相同。不过，有几种语言对 Unicode 大小写转换应用了特定的规则（例如土耳其语），因此必须使用区域特定的方法才能进行正确的转换。

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

Tässä koodissa toUpperCase() ja toLocaleUpperCase() tulostavat molemmat "HELLO WORLD", ja toLowerCase() ja toLocaleLowerCase() tulostavat molemmat "hello world". Yleisesti ottaen, jos ei tiedetä, millä koodauksella kieltä käytetään, on turvallista käyttää aluekohtaisia menetelmiä.

Vinkki:Muista, että kaikki String-objektin ominaisuudet ja metodit voidaan soveltaa String-alkuperäiseen arvoon, koska ne ovat pseudolausekkeita.

instanceof operaattori

Kun käytetään typeof operaattoria viittaustyyppien tallentamiseen, ilmenee ongelma, koska riippumatta siitä, minkä tyyppistä objektia viitataan, se palauttaa aina "object". ECMAScript toi mukanaan toisen Java operaattorin instanceof, jotta tämä ongelma voitaisiin ratkaista.

instanceof operaattori on samankaltainen kuin typeof operaattori, ja se käytetään tunnistamaan käsiteltävän objektin tyyppi. Eroaakseen typeof-metodista instanceof-metodi vaatii kehittäjältä, että objekti varmistetaan tietystä tyyppisestä. Esimerkiksi:

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

Tämä koodi kysyy "oStringObject onko String-objektin esimerkki?" oStringObject on todella String-objektin esimerkki, joten tuloksena on "true". Vaikka se ei ole yhtä joustava kuin typeof-metodi, instanceof-metodi on edelleen hyödyllinen, kun typeof-metodi palauttaa "object".