Pagbabagong Tipo ng ECMAScript

Ang isa sa mga pinakamahalagang katangian ng lahat ng program design language ay ang pagkakaroon ng kakayahang gawin ang pagbabagong uri.

Ang ECMAScript ay nagbibigay ng malaking bilang ng mga simpleng method ng pagbabagong uri para sa mga developer.

Ang karamihan sa mga type ay may mga method na maaaring gamitin para sa simple na pagbabagong uri, at may ilang mga pangkalahatang method na maaaring gamitin para sa mas kumplikadong pagbabagong uri. Anuman ang kung anong uri, ang pagbabagong uri sa ECMAScript ay isang maliit na hakbang ng operasyon.

Pagbabagong string

Ang kagiliwgan ng mga primordial na halaga ng Boolean, bilang at string sa ECMAScript ay dahil sila ay mga pseudo-object, na nangangahulugan na mayroon silang mga katangian at mga method.

Halimbawa, upang makakuha ng haba ng string, maaaring gamitin ang sumusunod na code:

var sColor = "red";
alert(sColor.length); // Maglilista ng '3'

Kahit na ang 'red' ay isang primordial na string, ito ay may katangian na length na ginagamit upang imbento ang laki ng string.

Sa kabuuan, ang tatlong pangunahing primordial na uri ng type sa ECMAScript, ang mga Boolean value, ang bilang at ang string, mayroon din ang toString() method, na maaaring baguhin ang kanilang halaga sa string.

Mga tagubilin:Maaaring kayo ay magtanong, 'Mayroon ba ring toString() method ang string, ito ba ay labis na?' Oo, tunay naman ito, pero ang ECMAScript ay nagtatalaga na mayroong toString() method ang lahat ng object, kahit ito ay pseudo-object o tunay na object. Dahil ang String type ay isang pseudo-object, kaya mayroon itong toString() method.

Boolean 类型的 toString() 方法只是输出 "true" 或 "false"，结果由变量的值决定：

var bFound = false;
alert(bFound.toString());	//输出 "false"

Number 类型的 toString() 方法比较特殊，它有两种模式，即默认模式和基模式。采用默认模式，toString() 方法只是用相应的字符串输出数字值（无论是整数、浮点数还是科学计数法），如下所示：

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());	//输出 "10"
alert(iNum2.toString());	//输出 "10"

Komentaryo:在默认模式中，无论最初采用什么表示法声明数字，Number 类型的 toString() 方法返回的都是数字的十进制表示。因此，以八进制或十六进制字面量形式声明的数字输出的都是十进制形式的。

采用 Number 类型的 toString() 方法的基模式，可以用不同的基输出数字，例如二进制的基是 2，八进制的基是 8，十六进制的基是 16。

基只是要转换成的基数的另一种加法而已，它是 toString() 方法的参数：

var iNum = 10;
alert(iNum.toString(2));	//输出 "1010"
alert(iNum.toString(8));	//输出 "12"
alert(iNum.toString(16));	//输出 "A"

在前面的示例中，以 3 种不同的形式输出了数字 10，即二进制形式、八进制形式和十六进制形式。HTML 采用十六进制表示每种颜色，在 HTML 中处理数字时这种功能非常有用。

Komentaryo:对数字调用 toString(10) 与调用 toString() 相同，它们返回的都是该数字的十进制形式。

参阅：

Mangyaring basahin JavaScript 参考手册提供的有关 toString() 方法的详细信息：

Mag-convert sa numero

Ang ECMAScript ay nagbibigay ng dalawang paraan para baguhin ang mga nangungunang halaga na hindi numero bilang numero, na ang mga ito ay parseInt() at parseFloat().

Tulad ng inaasahan ninyo, ang unang method ang nagbabaguhin ng halaga bilang integer, at ang ikalawang method ang nagbabaguhin bilang floating-point number. Mahalaga na lamang gumamit ng mga ito sa String type para maayos na patakbuhin; kung ginamit ang iba pang type, ibabalik na NaN.

parseInt()

Bago mapag-aralan ang string kung ito'y numero o hindi, magiging masinsinang pagsusuri gawin ng parseInt() at parseFloat() ang string.

Ang parseInt() method ay umaasikaso muna sa character sa posisyon 0, na ito'y pinagtingnan kung ito'y isang valid na numero; kung hindi, ibabalik ito ang NaN at hindi na ito magpatuloy sa ibang operasyon. Ngunit kung ang character ay valid na numero, ang method ay magtingnan din ang character sa posisyon 1, na gagawing parehong pagsusuri. Ang prosesong ito ay magpapatuloy hanggang sa matagpuan ang character na hindi valid na numero, na iconvert ng parseInt() ang string bago ang character na ito.

Halimbawa, kung gusto mong baguhin ang string "12345red" bilang integer, ibabalik ng parseInt() ang 12345, dahil kapag nakita niya ang character na r, ihahinto na niya ang prosesong pagcheck.

Ang numero sa string na nasa loob ay maaaring ma-convert ng maayos bilang numero, halimbawa, "0xA" ay maaaring ma-convert ng maayos bilang numero 10. Subalit, ang string "22.5" ay magiging 22, dahil ang decimal point ay hindi magiging valid character para sa integer.

Ang mga halimbawa ay sumusunod:

var iNum1 = parseInt("12345red");	// ibabalik 12345
var iNum1 = parseInt("0xA");	// ibabalik 10
var iNum1 = parseInt("56.9");	// ibabalik 56
var iNum1 = parseInt("red");	// ibabalik NaN

Mayroon ding base mode ang parseInt() method, na maaaring baguhin ang string na binary, octal, hexadecimal, o kahit anong base na bilang. Ang base ay tinukoy ng pangalawang argumento ng parseInt() method, kaya upang pagsalin ang halaga ng hexadecimal, kailangan gumamit ng ganitong paraan ng parseInt() method:

var iNum1 = parseInt("AF", 16);	// ibabalik 175

Nakikita po, maari ring gumamit ng ganitong paraan sa parseInt() method para sa binary, octal, at kahit decimal (default mode):

var iNum1 = parseInt("10", 2);	// ibabalik 2
var iNum2 = parseInt("10", 8);	//Bumalik 8
var iNum3 = parseInt("10", 10);	//Bumalik 10

Kung ang decimal number ay may naunang 0, mas mahusay gamitin ang base 10 upang hindi makakakuha ng di inaasahang octal value. Halimbawa:

var iNum1 = parseInt("010");	//Bumalik 8
var iNum2 = parseInt("010", 8);	//Bumalik 8
var iNum3 = parseInt("010", 10);	//Bumalik 10

Sa paling sabay na panglilinaw na ito, dalawang panglilinaw na linya ng kodigo ay inihahalal ang string "010" bilang numero. Ang unang linya ng kodigo ay inihahalal bilang octal value, na katulad ng ikalawang linya ng kodigo (na ipinahayag ang base bilang 8). Ang huling linya ng kodigo ay ipinahayag ang base bilang 10, kaya ang iNum3 ay tumatagal ng 10 sa huli.

Mangyaring basahin

Mangyaring basahin JavaScript 参考手册Narito ang detalyadong impormasyon tungkol sa parseInt() metoda:parseInt().

parseFloat()

Ang parseFloat() metoda ay katulad sa paggamit ng parseInt() metoda, magsisimula mula sa posisyon 0 at tinitingnan ang bawat character hanggang sa makita ang unang hindi wastong character, pagkatapos ay ihahalal ang string bago ang character na ito bilang numero.

Gayunpaman, para sa metoda na ito, ang unang lumitaw na titik na puntos ay isang wastong character. Kung mayroong dalawang titik na puntos, ang ikalawang titik na puntos ay itatawag na hindi wasto. Ang parseFloat() ay ituturing ang mga character bago ang titik na puntos bilang numero. Ito nangangahulugan na ang string "11.22.33" ay maihahalal bilang 11.22.

Isa pang kaibahan sa paggamit ng parseFloat() metoda ay ang string ay dapat ibalik bilang decimal floating-point number, hindi bilang octal o hexadecimal. Ang metoda na ito ay aalis ang mga naunang 0, kaya ang octal number 0102 ay maihahalal bilang 102. Para sa hexadecimal number 0xA, ang metoda na ito ay ibabalik NaN, dahil sa floating-point number, x ay hindi isang wastong character. (Komentaryo:Inilabas sa pagsubok, ang tiyak na pagpapatugtug ng browser ay ibabalik 0, hindi NaN.)

Bilang karagdagan, walang base pattern ang parseFloat() metoda.

Narito ang ilang halimbawa sa paggamit ng parseFloat() metoda:

var fNum1 = parseFloat("12345red");	//Bumalik 12345
var fNum2 = parseFloat("0xA");	//Bumalik NaN
var fNum3 = parseFloat("11.2");	//Bumalik 11.2
var fNum4 = parseFloat("11.22.33");	//Bumalik 11.22
var fNum5 = parseFloat("0102");	//ibibigay 102
var fNum1 = parseFloat("red");	//ibibigay NaN

Subukan nang personal na

Mangyaring basahin

Mangyaring basahin JavaScript 参考手册Mga detalye na may kaugnayan sa method na parseFloat():parseFloat().

Pagkonversa ng type

Maaari mo ring gamitinPagkonversa ng type (type casting)Upang pamahalaan ang uri ng halaga ng pagkonversa, maaaring gamitin ang pagkonversa ng type. Ang paggamit ng pagkonversa ng type ay magbibigay ng akses sa partikular na halaga, kahit na ito ay isa pang uri ng type.

Nagkakomentaryo ang tagapag-ulat:Ang cast ay may kahulugan na "paggawa" na katutubuhan sa kahulugan ng "pagkonversa."

Ang tatlong uri ng pagkonversa na available sa ECMAScript ay ang sumusunod:

  • Boolean(value) - nagkonversa ng ibigay na halaga sa Boolean type;
  • Number(value) - nagkonversa ng ibigay na halaga sa numero (maaaring ito ay integer o floating-point number);
  • String(value) - nagkonversa ng ibigay na halaga sa string;

Sa pamamagitan ng paggamit ng isa sa tatlong mga function na ito, ang pagkonversa ng halaga ay maglikha ng bagong halaga, na maglalagay ng direktang konversa ng orihinal na halaga. Ito ay maaring magdulot ng hindi inaasahang konsekwensya.

Boolean() function

Kung ang halaga na ito ay string na may kahit anong character, non-zero number o object, ang Boolean() function ay magbibigay ng true. Kung ang halaga ay empty string, number na zero, undefined o null, ito ay magbibigay ng false.

Maaaring gamitin ang sumusunod na code upang subukan ang pagkonversa ng Boolean type:

var b1 = Boolean("");		//false - empty string
var b2 = Boolean("hello");		//true - non-empty string
var b1 = Boolean(50);		//true - non-zero number
var b1 = Boolean(null);		//false - null
var b1 = Boolean(0);		//false - zero
var b1 = Boolean(new object());	//true - object

Number() function

Ang pagkonversa ng Number() ay katulad ng paggamit ng parseInt() at parseFloat(), ngunit ito ay nagkonversa ng buong halaga, hindi lamang ang bahagi nito.

Nababala ka ba, ang mga paraan ng parseInt() at parseFloat() ay nagkonversa lamang ng unang walang bisa na character ng string, kaya ang "1.2.3" ay magiging "1" at "1.2" ayon sa pagkakonversa.

Sa pagpapatunay ng uri gamit ang Number(), ang "1.2.3" ay magiging NaN dahil ang buong halaga ng string ay hindi ma-convert sa numero. Kapag ang halaga ng string ay maaaring buong ma-convert, ang Number() ay hahalal kung ang method na tinawag ay parseInt() o parseFloat().

Ang sumusunod na talahanayan ay naglalarawan kung anong mangyayari kapag tinawag ang Number() method para sa iba't ibang halaga:

Paggamit Resulta
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

String() function

Ang huling paraan ng pagpapatunay ng uri, String(), ay pinakasimpleng, dahil maaaring baguhin anumang halaga na maging string.

Upang gumawa ng pagpapatunay ng uri, kailangan lang ang pagtawag sa toString() method na inilagay bilang argumento, na nagiging "12" sa 12, "true" sa true, "false" sa false, at iba pa.

Ang tanging pagkakaiba ng pagpapatunay ng uri mula sa pagpapatunay ng string at pagtawag sa toString() ay ang pagpapatunay ng uri ng null at undefined na maaaring lumikha ng string na walang maling pagkakataon:

var s1 = String(null);	//"null"
var oNull = null;
var s2 = oNull.toString();	//Magiging mali

Kapag pinag-aaral ang mahinang uri ng wika tulad ng ECMAScript, ang pagpapatunay ng uri ay napaka-kapaki-pakinabang, ngunit dapat siguraduhin na ang tamang halaga ay ginagamit.