Reference Type ng ECMAScript

Ang uri ng paggamit na tinatawag na klase.

Ang tutorial na ito ay magbibigay ng talakayan sa malaking bilang ng naunang pinagkakaroon na uri ng paggamit ng ECMAScript.

Uri ng paggamit

Ang uri ng paggamit na tinatawag na klase, ibig sabihin, kapag nakakita tayo ng uri ng paggamit, ang bagay na pinagmamanmanan ay ang objekto.

Ang tutorial na ito ay magbibigay ng talakayan sa malaking bilang ng naunang pinagkakaroon na uri ng paggamit ng ECMAScript.

Simula ngayon, ang pag-usapan ay tungkol sa mga uri ng paggamit na malapit sa naunang napag-usapan na mga pangunahing uri.

Babala:Sa tradisyonal na kahulugan, ang ECMAScript ay walang tunay na klase. Sa katunayan, bukod sa paglalarawan na wala, ang salitang 'klase' ay wala sa ECMA-262. Ang ECMAScript ay nagbigay ng 'pamamaraan ng paglalarawan ng objekto', na kung saan ay kahawig sa 'klase' sa ibang wika ng programadikong pangkabuhayan.

Mga Tip:Ang tutorial na ito ay maggamit ng termino "bagay".

Ang bagay ay nilikha sa pamamagitan ng operator na new kasama ang pangalan ng bagay na ibibigay bilang halimbawa. Halimbawa, ang sumusunod na code ay nilikha ng isang instance ng bagay na Object:

var o = new Object();

Ang syntax na ito ay katulad ng wika ng Java, ngunit kapag mayroong higit sa isang argumento, ang ECMAScript ay nangangailangan ng paggamit ng mga parangal. Kapag walang argumento, tulad ng sumusunod na code, ang mga parangal ay maaaring ipagwalang bahala:

var o = new Object;

Babala:Kahit na hindi kinakailangan ang mga parangal, ito ay mas mabuti na gamitin ang mga parangal upang maiwasan ang pagkakaroon ng kaguluhan.

Mga Tip:Magiging mas mabuti tayo na masusuri ang mga bagay at kanilang pag-uugali sa seksyon ng pangkalahatang base na bagay.

Ang pinakamahalagang bagay ng seksyon na ito ay ang uri ng reference na may katumbas na orihinal na uri.

Object na bagay

Ang bagay na Object ay hindi magagamit masyadong mabuti, ngunit dapat alamin ito bago maunawaan ang ibang klase. Dahil ang bagay na Object sa ECMAScript ay katulad ng java.lang.Object sa Java, lahat ng bagay sa ECMAScript ay lumilikha mula sa bagay na ito, ang lahat ng atributo at mga paraan ng bagay na ito ay makikita sa ibang bagay, kaya kapag naiintindihan ang bagay na Object, mas mabuti nang maunawaan ang ibang bagay.

Ang bagay na Object ay may mga sumusunod na atributo:

constructor
Ang paglilinaw ng function na gumawa ng bagay na ito (pointer). Para sa bagay na Object, ang pointer na ito ay tumutukoy sa orihinal na function na Object().
Prototype
Ang paglilinaw ng bagay na prototype ng bagay na ito. Para sa lahat ng bagay, ito ay naglalabas ng isang instance ng Object.

Ang bagay na Object ay may ilang mga paraan:

hasOwnProperty(property)
Huhusgahan kung ang bagay ay may partikular na atributo. Dapat gamitin ang string na naglalagay ng atributo.(Halimbawa, o.hasOwnProperty("name"))
IsPrototypeOf(object)
Huhusgahan kung ang bagay na ito ay prototype ng ibang bagay.
PropertyIsEnumerable
Huhusgahan kung ang ibinigay na atributo ay puwedeng pinapalitan sa pamamagitan ng for...in sentence.
ToString()
Ibinabalik ang orihinal na string na representasyon ng bagay. Para sa bagay na Object, walang tinukoy ang halaga na ito sa ECMA-262, kaya magkakaiba ang halaga na ibinabalik ng iba't-ibang ECMAScript implementation.
ValueOf()
Bumalik sa orihinal na halaga na pinamamangha para sa bagay na ito. Para sa maraming bagay, ang halaga na ibinabalik ng paraan na ito ay katulad ng halaga na ibinabalik ng ToString().

Komentaryo:Ang bawat atribute at method na nakalista sa ito ay papalitan ng ibang mga object.

Boolean object

Ang Boolean object ay isang reference type ng orihinal na uri ng Boolean.

Para lumikha ng Boolean object, kailangan lamang ilagay ang halaga ng Boolean bilang argumento:

var oBooleanObject = new Boolean(true);

Ang Boolean object ay papalitan ang method na ValueOf() ng Object object, na ibibigay ang orihinal na halaga, na true at false. Ang method na ToString() ay papalitan din, na ibibigay ang string "true" o "false".

Malungkot, di gaanong ginagamit ang Boolean object sa ECMAScript, kahit na ginagamit, mahirap itong maunawaan.

Ang problema ay karaniwang dumadating kapag ginagamit ang Boolean object sa mga expression ng Boolean. Halimbawa:

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

Sa ito na code, gumagamit ng halaga na false sa paglikha ng Boolean object. Pagkatapos, ginamit ang halaga na ito sa operation na AND sa orihinal na halaga na true. Ang resulta ng operation na AND ng false at true sa pagkilos ng Boolean ay false. Gayunman, sa ito na linya ng code, ang nilikha ay oFalseObject, hindi ang halagang false nito.

Tulad ng nabanggit noon, sa mga expression ng Boolean, lahat ng mga object ay ayos na napapalitan sa true, kaya ang halaga ng oFalseObject ay true. Pagkatapos, ang true ay naiandandang sa true, ang resulta ay true.

Babala:Bagaman dapat mong alam ang availability ng Boolean object, mas mabuti pa lamang gamitin ang orihinal na halaga ng Boolean, upang maiwasan ang problema na nabanggit sa ito na section.

参阅

Para makakuha ng mas maraming impormasyon tungkol sa Boolean object, pumunta sa: Reference Manual ng JavaScript Boolean Object。

Number object

Tulad ng iyong inaasahan, ang Number object ay isang reference type ng orihinal na uri ng Number. Upang lumikha ng Number object, gamitin ang sumusunod na code:

var oNumberObject = new Number(68);

Dapat mo nang alam ang Number object na nabanggit sa naunang bahagi ng kabanata na talakayin ang mga espesyal na halaga (tulad ng Number.MAX_VALUE). Lahat ng espesyal na halaga ay mga statik na atribute ng Number object.

Para makakuha ng orihinal na halaga ng Number object, kailangan lamang gamitin ang method na valueOf():

var iNumber = oNumberObject.valueOf();

Of course, the Number class also has a toString() method, which has been discussed in detail in the section on type conversion.

In addition to the standard methods inherited from the Object object, the Number object also has several dedicated methods for handling numbers.

toFixed() method

The toFixed() method returns the string representation of a number with a specified number of decimal places. For example:

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

In this case, the parameter of the toFixed() method is 2, indicating that two decimal places should be displayed. This method returns "68.00", and the empty string positions are filled with 0. This method is very useful for applications dealing with currency. The toFixed() method can represent numbers with 0 to 20 decimal places, and values beyond this range will cause an error.

toExponential() method

Another method related to formatting numbers is toExponential(), which returns the string representation of the number in scientific notation.

Similar to the toFixed() method, the toExponential() method also has a parameter that specifies the number of decimal places to output. For example:

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

The result of this code is "6.8e+1", as explained earlier, it represents 6.8x101. The problem is, what if you don't know which form (predefined or exponential) to use to represent the number? You can use the toPrecision() method.

toPrecision() method

The toPrecision() method returns the predefined or exponential form of the number based on the most meaningful form. It has one parameter, which is the total number of digits used to represent the number (excluding the exponent). For example,

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

The task of this code is to represent the number 68 with one digit, the result is "7e+1", and in another form it is 70. Indeed, the toPrecision() method rounds the number. However, it is much easier to represent 68 with 2 digits:

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

Of course, the output is "68", because that is exactly how the number is represented. But what if the specified number of digits is more than needed?

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

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

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

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

参阅

如需更多有关 Number 对象的信息，请访问 Reference Manual ng JavaScript Number Object。

String 对象

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

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

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

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

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

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

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"

Sa string "hello world", ang character na nasa posisyon 1 ay "e" Sa "ECMAScript Original Type" section, naipaliwanag namin na ang unang character ay may posisyon 0, ikalawang character ay may posisyon 1, at iba pa. Kaya, ang pinagbabalik ng charAt(1) ay "e".

Kung ang kailangan ay ang character code kaysa sa character, maaaring itawagan ang charCodeAt() method:

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

Ang halimbawa na ito ay naglalabas "101", na ang character code ng malalim na "e". Sa "ECMAScript Original Type" section, naipaliwanag namin ang unang character na may posisyon 0, ikalawang character na may posisyon 1, at iba pa. Kaya, ang pinagbabalik ng charAt(1) ay "e".

Ang concat() method

Susunod na ay ang concat() method, na ginagamit upang kumonekta ng isang o ilang string sa orihinal na halaga ng String object. Ang pinagbabalik ng method na ito ay ang String orihinal na halaga, na nananatili ang orihinal na String object:

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

Sa ganitong bloke ng code, ang pinagbabalik ng concat() method ay "hello world", habang ang String object ay nananatili sa "hello ". Dahil sa ganitong dahilan, mas karaniwan ang paggamit ng plus sign (+) sa pagkakabit ng string, dahil ang ganitong paraan ang nagpapakita ng tunay na pag-uugnay:

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

Ang indexOf() at lastIndexOf() method

Sa ngayon, ay napag-usapan na ang mga paraan ng pagkakabit ng string, at ang pagbubuksan ng isang solong character sa string. Gayunpaman, kung hindi sigurado ang pagkakaroon ng isang character sa string, anong method dapat itong tawagan? Sa ganitong pangyayari, maaaring itawagan ang indexOf() at lastIndexOf() method.

Ang indexOf() at lastIndexOf() method ay binabalik ang posisyon ng tinukoy na substring sa ibang string, kung wala ito ay ibabalik -1.

Ang pagkakaiba ng dalawang paraan na ito ay ang indexOf() method ay magsisimula sa simula ng string (sa posisyon 0) na hinahanap ang string, habang ang lastIndexOf() method ay magsisimula sa katapusan ng string na hinahanap ang substring. Halimbawa:

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

Dito, ang unang string na "o" ay nasa posisyon 4, na "hello" na may "o"; ang huling string na "o" ay nasa posisyon 7, na "world" na may "o". Kung may isang string na "o" lamang ang nasa string, ang indexOf() at lastIndexOf() method ay nagbabalik ng parehong posisyon.

Metoda ng localeCompare()

Ang susunod na metoda ay localeCompare(), na nagtatalaga ng pagkakasunod-sunod ng string. Ang metoda na ito ay may isang argumento - ang string na dapat pagkumpara, at ibabalik ng halaga ang tatlong sa mga sumusunod na halaga:

  • Kung ang String object ay nasa unahan ng string na nasa argumento sa pagkakasunod-sunod ng alpabeto, ibabalik ang negatibong halaga.
  • Kung ang String object ay katumbas ng string na nasa argumento, ibabalik ang 0.
  • Kung ang String object ay nasa likod ng string na nasa argumento sa pagkakasunod-sunod ng alpabeto, ibabalik ang positibong halaga.

Komentaryo:Kung ang ibabalik na halaga ay negatibo, ang pinakamadalas ay -1, ngunit ang tunay na ibabalik ay pinapili ng implementasyon. Kung ang ibabalik na halaga ay positibo, katulad din, ang pinakamadalas ay 1, ngunit ang tunay na ibabalik ay pinapili ng implementasyon.

Halimbawa nito:

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

Sa kodigo na ito, ang string na "yellow" ay pinagkumpara sa tatlong halaga, na "brick", "yellow", at "zoo". Dahil sa pagkakasunod-sunod ng alpabeto, ang "yellow" ay nasa likod ng "brick", kaya ang localeCompare() ay nagbabalik ng 1; "yellow" ay katumbas ng "yellow", kaya ang localeCompare() ay nagbabalik ng 0; ang "zoo" ay nasa likod ng "yellow", kaya ang localeCompare() ay nagbabalik ng -1. Muling pinagbigyan ng pansin, dahil ang ibabalik na halaga ay pinapili ng implementasyon, mas mahusay na tumawag sa paraan na ito ng localeCompare() metoda:

var oStringObject1 = new String("kuning");
var oStringObject2 = new String("tanso");
var iResult = oStringObject1.localeCompare(oStringObject2);
kung iResult < 0) {
  alert(oStringObject1 + " ay sumunod sa " + oStringObject2);
}
  alert(oStringObject1 + " ay sumunod sa " + oStringObject2);
}
  alert("Ang dalawang string ay katumbas");
}

Gumamit ng ganitong istraktura, masigurado na gumana nang maayos ang kodigo sa lahat ng mga pagpapatupad.

Ang natatanging pagkakataon ng methodong localeCompare() ay ang eksaktong lugar (locale, na kabilang din ang bansa/teritoryo at wika) na inilalarawan ng pagpapatupad nito. Sa Estados Unidos, ang Ingles ay ang standard na wika ng ECMAScript implementation, at ang localeCompare() ay may pagtatanging kasukatan ng laki ng titik, na ang may malakas na titik ay nasa hulihan ng malabas na titik sa pagkakasunod-sunod ng titik. Subalit, sa ibang lugar, ang sitwasyon ay maaaring magkaiba.

slice() at substring()

Ang ECMAScript ay nagbibigay ng dalawang paraan para gumawa ng string value mula sa substring, totoo ay slice() at substring(). Ang mga ito ay lumalabas din ng substring ng string na ito, na tumanggap ng isang o dalawang parameter. Ang unang parameter ay ang pook na kailanganan para makuha ang substring, at ang ikalawang parameter (kung ginamit) ay ang pook na dapat makuha bago mapatigil (ito ay nangangahulugan na ang character na nasa pook na mapatigil ay hindi kasama sa ibabalik na halaga). Kung binigong iwanan ang ikalawang parameter, ang pook na mapatigil ay magiging default na ang haba ng string.

Kasama ng methodong concat(), hindi binabago ng slice() at substring() ang halimbawa ng String object. Lumalabas lamang sila ng orihinal na halimbawa ng String, pinapanatili ang String object na hindi nababago.

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"

Sa eksemplo na ito, ang paggamit at ang mga ibabalik na halaga ng slice() at substring() ay magkapareho. Kapag mayroon lamang ang argumento 3, ang dalawang methodo ay ibabalik ang "lo world", dahil ang ikalawang "l" sa "hello" ay nasa posisyon 3. Kapag mayroon ang dalawang argumento "3" at "7", ang dalawang methodo ay ibabalik ang "lo w" (ang "o" ng "world" ay nasa posisyon 7, kaya hindi ito kasama sa resulta).

Bakit mayroong dalawang methodong may parehong kakayahan? Sa katunayan, ang dalawang methodo ay hindi talaga magkakahiwalay, ngunit mayroon lamang pagkakaiba sa paggamit ng argumento na negatibo.

Para sa mga negatibong argumento, gagamitin ng methodong slice() ang haba ng string kasama ang argumento, habang gagawin ng methodong substring() ito bilang 0 (ito ay nangangahulugang ito ay ipagwalang bahala). Halimbawa:

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"

Ganito lang makikita ang pangunahing pagkakaiba ng mga methodong slice() at substring().

Kapag mayroon lamang ang argumento -3, ibabalik ng slice() ang "rld", habang ibabalik ng substring() ang "hello world". Ito ay dahil para sa string "hello world", ang slice("-3") ay gagawing slice("8"), at ang substring("-3") ay gagawing substring("0").

同样，使用参数 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()); // Output "hello world"

Sa code na ito, ang toUpperCase() at toLocaleUpperCase() ay nagbibigay ng "HELLO WORLD", at ang toLowerCase() at toLocaleLowerCase() ay nagbibigay ng "hello world". Karaniwan, kung hindi alam ang uri ng encoding na pinapatakbo ng isang wika, ang pang-rehiyong pamamaraan ay mas ligtas sa gamitin.

Mga Tip:Tandaan, ang lahat ng atrubuto at method ng String object ay maaring gamitin sa String na orihinal na halaga, dahil sila ay pseudo-object.

Instanceof operator

Ang problema ay maaaring lumitaw kapag ginagamit ang typeof operator para sa storage ng value na reference type, kung ano pa man ang uri ng object na inireference, ito ay nagbibigay ng "object". Ang ECMAScript ay nagbigay ng isa pang Java operator na instanceof upang malutas ito.

Ang instanceof operator ay katulad ng typeof operator, ginagamit para malaman ang uri ng object na kasalukuyang pinagpapatupad. Sa kabila ng typeof method, ang instanceof method ay nangangailangan ng tiyak na pagpapatunay ng developer na ang object ay isang partikular na uri ng object. Halimbawa:

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

Ang code na ito ay nagtatanong kung ang "oStringObject" ay isang instance ng String object? Si oStringObject ay talagang isang instance ng String object, kaya ang resulta ay "true". Bagaman hindi kasaliwang mabilis kagaya ng typeof method, ang instanceof method ay lubos na kapaki-pakinabang kapag ang typeof method ay nagbibigay ng "object".