ប្រភេទដើម ECMAScript

Ang ECMAScript ay may limang pangunahing uri (primitive type), na Undefined, Null, Boolean, Number at String.

Operator na typeof

Ang operator na typeof ay may isang argument, ang variable o halaga na dapat suriin. Halimbawa:

var sTemp = "test string";
alert (typeof sTemp);    // Output "string"
alert (typeof 86);    // Output "number"

Ang pagtawag sa operator na typeof ng variable o halaga ay magbibigay ng isa sa mga sumusunod na halaga:

  • undefined - kung ang variable ay uri ng Undefined
  • boolean - kung ang variable ay uri ng Boolean
  • number - kung ang variable ay uri ng Number
  • string - kung ang variable ay uri ng String
  • object - kung ang variable ay isang uri ng reference type o uri ng Null

Komentaryo:Maaring tanungin mo, bakit ang operator na typeof ay nagbibigay ng "Object" para sa halaga na null. Ito ay isang pagkakamali sa unang paglunsad ng JavaScript, na sinundan ng ECMAScript. Ngayon, ang null ay itinuturing na placeholder ng object, na nagpapaliwanag sa pagkakasalungat na ito, ngunit teknikal na ito ay nananatiling pangunahing halaga.

Uri na undefined

Ayon sa naunang binanggit, ang uri na mayroon lamang isang halaga, ang undefined. Kapag ang variable na itinakda ay hindi inilunsad, ang default na halaga ng variable na ito ay undefined.

var oTemp;

Ang unang linya ng code ay nagdeklara ng variable na oTemp, walang inilalagong halaga. Ang variable na ito ay ibibigay ang halaga na undefined, na kung saan ay ang literal na uri ng undefined. Maaari ring subukan ang code na ito upang subukan kung ang halaga ng variable ay katumbas ng undefined:

var oTemp;
alert(oTemp == undefined);

Ang code na ito ay maglalarawan na "true", na nagpapakita na ang dalawang halaga ay katumbas. Maaari ring ipakita ng operator na typeof kung ang halaga ng variable ay undefined:

var oTemp;
alert(typeof oTemp); // maglalarawan "undefined"

Paalala:Ang halaga ng undefined ay hindi katulad ng hindi naunang pinagbigay na halaga. Subalit ang operator na typeof ay hindi talagang pinaghihiwalay ang dalawang halaga. Isipin ang sumusunod na code:

var oTemp;
alert(typeof oTemp);  // maglalarawan "undefined"
alert(typeof oTemp2);  // maglalarawan "undefined"

Ang nakalagay na code ay naglalarawan sa dalawang variable na "undefined", kahit na lamang ang variable na oTemp2 ang hindi naging na-deklara. Kapag ginamit ang oTemp2 sa ibang operator kung hindi ang typeof, magiging error dahil ang ibang operator ay puwedeng gamitin lamang sa variable na naging na-deklara.

Halimbawa, ang sumusunod na code ay magiging maling error:

var oTemp;
alert(oTemp2 == undefined);

Kapag walang malinaw na pinagbabalik na halaga ng function, ang pinagbabalik din ay ang halaga "undefined", tulad ng ibaba:

function testFunc() {
{}
alert(testFunc() == undefined);  // maglalarawan "true"

Ang uri ng Null

Isa pang uri ng uri na may isang tanging halaga ay Null, na may isang eksklusibong halaga na null, na kung saan ay ang kanyang literal. Ang halaga ng undefined ay nagsimula mula sa halaga ng null, kaya tinukoy ng ECMAScript sila bilang katumbas.

alert(null == undefined);  // maglalarawan "true"

Kahit sila ay katumbas, ang kahulugan nila ay magkakaiba. Ang undefined ay ang halaga na pinagbibigay sa isang variable na hindi naunang inilagay sa inaasahang pinakamagandang halaga, habang ang null ay ginagamit upang ipakita na ang bagay ay wala pa (simple na itinukoy ito noong pagtalakay ng operator na typeof). Kapag ang nilalalingan ng isang function o method ay ang isang bagay, kung wala na ang bagay na iyon, malamang na itong ibabalik ay null.

Ang uri ng Boolean

Ang Boolean na uri ay isa sa pinaka ginagamit sa ECMAScript. Mayroon siyang dalawang halaga: true at false (na kung saan ang dalawang literal na Boolean).

即使 false 不等于 0，0 也可以在必要时被转换成 false，这样在 Boolean 语句中使用两者都是安全的。

var bFound = true;
var bLost = false;

Number 类型

ECMA-262 中定义的最特殊的类型是 Number 类型。这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。

直接输入的（而不是从另一个变量访问的）任何数字都被看做 Number 类型的字面量。例如，下面的代码声明了存放整数值的变量，它的值由字面量 86 定义：

var iNum = 86;

八进制数和十六进制数

整数也可以被表示为八进制（以 8 为底）或十六进制（以 16 为底）的字面量。八进制字面量的首数字必须是 0，其后的数字可以是任何八进制数字（0-7），如下面的代码所示：

var iNum = 070;  //070 等于十进制的 56

要创建十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。这些字母可以是大写的，也可以是小写的。例如：

var iNum = 0x1f;  //0x1f 等于十进制的 31
var iNum = 0xAB;  //0xAB 等于十进制的 171

Paalala:尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

浮点数

要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用 1.0 而不是 1）。这被看作浮点数字面量。例如：

var fNum = 5.0;

对于浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

科学计数法

对于非常大或非常小的数，可以用科学计数法表示浮点数，可以把一个数表示为数字（包括十进制数字）加 e（或 E），后面加乘以 10 的倍数。例如：

var fNum = 5.618e7

该符号表示的是数 56180000。把科学计数法转化成计算式就可以得到该值：5.618 x 107。

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(Dito, ang 10 ay nadagdagan sa -17 na pangalawang pagpili, na nangangahulugan na kailangan na ibahagi sa 10 nang 17 beses). Ang ECMAScript ay nagbabalik sa scientific notation ang mga floating-point na may 6 o higit pang naunang 0, na nangangahulugan na ang 10 ay nadagdagan sa -17 na pangalawang pagpili.

Paalala:Maaari ring mag-imbak ang mga halaga ng floating-point sa 64-bit IEEE 754 form, na nangangahulugan na ang decimal na halaga ay maaaring may hanggang 17 na decimal na bit. Ang mga halaga sa 17 na bit at sa ibang pagkakataon ay mawawala, na nagiging dahilan ng ilang maliit na matematikal na pagkakamali.

Espesyal na halaga ng Number

Mayroon ding ilang espesyal na halaga na tinukoy sa uri ng Number. Ang dalawang unang ay Number.MAX_VALUE at Number.MIN_VALUE, na tinukoy ang labi ng halaga ng Number. Lahat ng ECMAScript na bilang ay dapat nasa loob ng dalawang ito. Gayunpaman, ang nangalalabas na halaga ng pagkalkula ay hindi dapat nasa loob ng dalawang ito.

Kapag ang nangalalabas na bilang ay mas malaki kaysa sa Number.MAX_VALUE, ito ay magiging Number.POSITIVE_INFINITY, na nangangahulugan na walang ibang halaga na bilang. Kapag ang nangalalabas na halaga ng pagkalkula ay mas maliit kaysa sa Number.MIN_VALUE, ito ay magiging Number.NEGATIVE_INFINITY, na nangangahulugan na walang ibang halaga na bilang. Kung ang nangalalabas na halaga ay walang hanggan, ang nangalabas na resulta ay hindi na maaaring gamitin sa ibang kalkulasyon.

Sa katunayan, may mga espesyal na halaga na naglalarawan ng walang hanggan, (tulad ng inaasahan mo) na ang Infinity. Ang halaga ng Number.POSITIVE_INFINITY ay Infinity. Ang halaga ng Number.NEGATIVE_INFINITY ay -Infinity.

Dahil ang walang hanggan na bilang ay maaaring maging positibo o negatibo, ang isang paraan na mapagtingin kung ang isang bilang ay may hanggan (hindi nagtutulad sa pagtest ng bawat walang hanggan bilang). Maaaring tumawag sa isang method na isFinite() para sa anumang bilang, upang matiyak na ang bilang ay hindi walang hanggan. Halimbawa:

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
{}
else {
    alert("infinite");
{}

Ang pinakabagong espesyal na halaga ay NaN, na nangangahulugan na 'Hindi isang Bilang' (Not a Number). Ang NaN ay isang kakaibang espesyal na halaga. Karaniwan, ganito ang mangyayari kapag may pagbabagong uri (String, Boolean at iba pa) na nabigo. Halimbawa, ang pagbabagong uri ng salitang 'blue' ay magiging nabigo, sapagkat walang katumbas na bilang. Tulad ng walang hanggan, ang NaN ay hindi maaring gamitin sa aritmetikang kalkulasyon. Ang isa pang kakaibang katangian ng NaN ay, ito ay hindi magkapareho sa kanyang sarili, na nangangahulugan na ang sumusunod na code ay magbibigay ng false:

alert(NaN == NaN);  //កាត់បញ្ចាំង "false"

សំរាប់ហេតុនេះ មិនត្រូវបានលើកឡើងក្នុងការប្រើប្រាស់តួ NaN ខ្លួនឯង។ កម្មវិធី isNaN() នឹងធ្វើបានប្រសើរជាងចំនួន:

alert(isNaN("blue"));  //កាត់បញ្ចាំង "true"
alert(isNaN("666"));  //កាត់បញ្ចាំង "false"

String ប្រភេទ

ប្រភេទ String មានលក្ខណៈអស្ចារ្យដែលគ្មានទំហំមិនត្រឹមត្រូវទេ។ អ្នកអាចរក្សាពាក្យ 0 ទៅមួយចំនួន Unicode ដោយប្រើចំនួនជាង 16 ចំនួននិចត្រូវ (Unicode គឺជាក្រុមពាក្យអន្តរជាតិ និងនឹងត្រូវបានពិភាក្សាជាលក្ខណៈដែលក្រោយមកនេះ)。

រាល់ពាក្យនៅក្នុងសំឡេង មានទីតាំងជាក់លាក់ ដែលចាប់ផ្តើមពីទី 0 ហើយពាក្យទីពីរនៅទី 1 ដូចនេះ ដែលមានន័យថាទីតាំងរបស់ពាក្យចុងក្រោយនៅក្នុងសំឡេង គឺចំនួនរយៈពេលនៃសំឡេង - 1:

រង្វាស់របស់សញ្ញា និងទីតាំងរបស់តួអង្គ

លេខក្រូរសំឡេង គឺត្រូវបានបញ្ជាក់ដោយបន្ទាត់បញ្ចប់ (") ឬ (') ហើយ Java ប្រើ (") បញ្ជាក់សំឡេង និង (') បញ្ជាក់ពាក្យតុបណ្ឌិត។ ប៉ុន្តែពេល ECMAScript គ្មានប្រភេទពាក្យ ដូច្នេះអ្នកអាចប្រើម្យ៉ាងមួយក្នុងចំណោមការបញ្ជាក់ទាំងពីរ។ ឧទាហរណ៍ ពីរខ្សែកូដដែលខាងក្រោមមានភាពត្រឹមត្រូវ:

var sColor1 = "red";
var sColor2 = 'red';

ប្រភេទ String ក៏មានលេខក្រូរបស់វាដែរ ហើយអ្នកអភិវឌ្ឍន៍ Java、C និង Perl គួរសម្រេចចិត្តជាច្រើន។

ក្រោយនេះគឺចំណាត់ឈ្មោះលេខក្រូរបស់ ECMAScript:

លេខក្រូ ន័យ
\n បណ្តោយ
\t បណ្តោយ
\b សារធាតុ
\r បណ្តោយ
\f បណ្តោយ
\\\\ បណ្តោយ
\' បន្ទាត់បញ្ចប់
\" បន្ទាត់បញ្ចប់
\0nnn លេខក្រូហ្គ្រេត nnn តំណាងឲ្យពាក្យ (n n គឺជាចំណាត់ឈ្មោះខ្ទង់ចំណាត់តាំង 0 ទៅ 7
\xnn លេខក្រូហ្គ្រេត nn តំណាងឲ្យពាក្យ (n n គឺជាចំណាត់ឈ្មោះខ្ទង់ចំណាត់តាំង 0 ទៅ F
\unnnn លេខក្រូហ្គ្រេត nnnn តំណាងឲ្យពាក្យ Unicode (n n គឺជាចំណាត់ឈ្មោះខ្ទង់ចំណាត់តាំង 0 ទៅ F