Expressions and operators

บทนี้อธิบายนิพจน์จาวาสคริปต์ และตัวดำเนินการต่างๆซึ่งประกอบด้วย การให้ค่า, การเปรียบเทียบ, เลขคณิต, บิท, ตรรกะ, สตริง, และตัวดำเนินการพิเศษ

นิพจน์ (Expressions)

นิพจน์คือ ส่วนของโค้ดที่หาค่าได้

แนวคิดพื้นฐาน, มีนิพจน์อยู่สองชนิด แบบแรกคือการให้ค่ากับตัวแปร และอีกแบบคือการหาค่าให้ได้

นิพจน์  x = 7,  คือตัวอย่างแบบแรก นิพจน์นี้ใช้ตัวดำเนินการ = เพื่อให้ค่าเจ็ดกับตัวแปร x โดยตัวนิพจน์เองจะมีค่าเป็นเจ็ด

นิพจน์  3 + 4,  คือตัวอย่างแบบที่สอง นิพจน์นี้ใช้ตัวดำเนินการ + ทำการรวมค่าสามและสี่เข้าด้วยกัน โดยไม่มีการให้ค่าผลลัพธ์เจ็ดกับตัวแปรใดๆ

จาวาสคริปต์ประกอบด้วยนิพจน์ประเภทต่างๆดังนี้

• คณิตศาสตร์: หาค่าตัวเลข เช่น, 3.14159 (โดยทั่วไปใช้ ตัวดำเนินการคณิตศาสตร์)
• สตริง: หาค่าสตริงของอักขระ เช่น, "Fred" หรือ "234" (โดยทั่วไปใช้ ตัวดำเนินการสตริง)
• ตรรกะ: หาค่าจริง (true) หรือเท็จ (false) (มักใช้กับ ตัวดำเนินการตรรกะ)
• อ็อบเจกต์: หาค่าอ็อบเจกต์ (ดูเพิ่มที่ ตัวดำเนินการพิเศษ แบบต่างๆที่คืนค่าเป็นอ็อบเจกต์)

ตัวดำเนินการ (Operators)

ในส่วนนี้เป็นการอธิบายตัวดำเนินการชนิดต่างๆ และลำดับความสำคัญของตัวดำเนินการ โดยจาวาสคริปต์มีตัวดำเนินการชนิดต่างๆดังนี้

• ตัวดำเนินการให้ค่า
• ตัวดำเนินการเปรียบเทียบ
• ตัวดำเนินการคณิตศาสตร์
• ตัวดำเนินการบิท
• ตัวดำเนินการตรรกะ
• ตัวดำเนินการสตริง
• ตัวดำเนินการพิเศษ

จาวาสคริปต์มีตัวดำเนินการแบบเดี่ยว แบบคู่, และแบบพิเศษ (ตัวดำเนินการเงื่อนไข) โดยตัวดำเนินการแบบคู่ ใช้กับตัวถูกดำเนินการสองตัว, อยู่ข้างหน้าและข้างหลังตัวดำเนินการ ดังนี้

ตัวถูกดำเนินการ ตัวดำเนินการ ตัวถูกดำเนินการ

ตัวอย่างเช่น, 3+4 หรือ x*y.

ตัวดำเนินการเดี่ยว ใช้กับตัวถูกดำเนินการตัวเดียว ไม่อยู่ข้างหน้าก็อยู่ข้างหลังตัวดำเนินการ

ตัวถูกดำเนินการ ตัวดำเนินการ

หรือ

ตัวดำเนินการ ตัวถูกดำเนินการ

ตัวอย่างเช่น, x++ หรือ ++x.

ตัวดำเนินการให้ค่า

ตัวดำเนินการให้ค่า ทำหน้าที่กำหนดค่าให้กับตัวแปรด้านซ้าย ด้วยค่าจากผลลัพธ์ด้านขวา โดยตัวดำเนินการให้ค่าแบบพื้นฐานแทนด้วยเครื่องหมายเท่ากับ (=) จะนำค่าที่อยู่ด้านขวาไปให้ตัวแปรที่อยู่ด้านซ้าย นั่นคือ x = y หมายถึงการนำค่า y ไปให้ x

ตัวดำเนินการให้ค่าแบบอื่นๆ มีรูปแบบอย่างย่อตามตารางต่อไปนี้

ตัวดำเนินการเปรียบเทียบ

This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="... ตัวดำเนินการเปรียบเทียบ ทำหน้าที่เปรียบเทียบตัวถูกดำเนินการทั้งสองว่ามีค่าเป็นจริงตามนั้นหรือไม่ และคืนค่าผลลัพธ์เป็นค่าข้อมูลตรรกะ โดยตัวถูกดำเนินการเป็นได้ทั้งตัวเลข, สตริง,  ตรรกะ, หรืออ็อบเจกต์ ที่เป็นสตริงจะถูกเปรียบเทียบจากลำดับในพจนานุกรมมาตรฐานด้วยค่ายูนิโค้ด โดยส่วนใหญ่แล้วถ้าตัวถูกดำเนินการทั้งสองไม่เป็นชนิดเดียวกัน, จาวาสคริปต์จะพยายามแปลงค่าให้เหมาะสมต่อการเปรียบเทียบ ซึ่งจะได้ผลลัพธ์เหมือนการเปรียบเทียบค่าตัวเลข แต่ก็มีข้อยกเว้นเมื่อทำการเปรียบเทียบด้วยตัวดำเนินการ === และ !== ซึ่งตัวดำเนินการสองตัวนี้จะไม่มีการแปลงค่าก่อนการเปรียบเทียบ โดยข้อมูลทั้งสองจะต้องเท่ากันจริง หรือไม่เท่ากันจริงเท่านั้น

ตารางต่อไปนี้แสดงตัวดำเนินการเปรียบเทียบค่าของตัวอย่างง่ายๆดังนี้

var var1 = 3, var2 = 4;

ตัวดำเนินการคณิตศาสตร์

ตัวดำเนินการคณิตศาสตร์ นำค่าตัวเลข (จากต้วข้อมูลหรือตัวแปร) มาดำเนินการทางคณิตศาสตร์ และคืนค่าผลลัพธ์เป็นค่าตัวเลขหนึ่งค่า ตัวดำเนินการคณิตศาสตร์มาตรฐานคือ บวก (+), ลบ (-), คูณ (*), และหาร (/) โดยตัวดำเนินการเหล่านี้ทำหน้าที่เหมือนในภาษาโปรแกรมส่วนใหญ่ เมื่อใช้กับตัวเลขจำนวนจริง (ที่พิเศษคือ การหารด้วยศูนย์จะได้ Infinity) ดังตัวอย่าง

console.log(1 / 2); /* prints 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* also this is true */

นอกจากที่กล่าวมา จาวาสคริปต์ยังมีตัวดำเนินการคณิตศาสตร์ให้ใช้เพิ่มเติม ตามตารางต่อไปนี้

ตัวดำเนินการบิท

ตัวดำเนินการบิท จัดการกับตัวถูกดำเนินการแบบเลขฐานสองจำนวน 32 บิท (ศูนย์และหนึ่ง), ไม่ใช่ฐานสิบ ฐานสิบหก หรือฐานแปด ตัวอย่าง เช่น, เลข 9 ในฐานสิบ เขียนแบบฐานสองได้ 1001 ซึ่งตัวดำเนินการแบบบิทจะจัดการค่าข้อมูลกับเลขฐานสองแบบนี้ และคืนผลลัพธ์เป็นค่าตัวเลขของจาวาสคริปต์

ตารางต่อไปนี้สรุปตัวดำเนินการบิทของจาวาสคริปต์

ตัวดำเนินการบิทแบบตรรกะ

โดยหลักการ, ตัวดำเนินการบิทแบบตรรกะทำงานดังนี้:

• ตัวถูกดำเนินการทั้งหมด ถูกแปลงให้เป็นเลขจำนวนเต็ม 32  บิท ในรูปแบบฐานสอง (ศูนย์และหนึ่ง)
• แต่ละบิทของตัวถูกดำเนินการตัวแรกจับคู่กับบิทที่ตรงกันของตัวที่สอง บิทแรกคู่บิทแรก, บิทสองคู่บิทสอง, จนครบทุกบิท
• ตัวดำเนินการ จัดการค่าในแต่ละคู่บิท ได้ผลลัพธ์แบบบิท

ตัวอย่าง เช่น, ฐานสองของเก้าคือ 1001, และฐานสองของสิบห้าคือ 1111 เมื่อนำมาดำเนินการบิทจะได้ผลลัพธ์ดังนี้:

หมายเหตุ  ค่า 32 บิททุกค่าจะถูกอินเวอร์ตโดยใช้ตัวดำเนินการบิท NOT, ถ้าค่านั้นมีบิทหลักซ้ายสุดเป็น 1 แสดงว่าเป็นเลขลบ (ใช้การแสดงแบบคู่ตรงข้าม)

ตัวดำเนินการบิทแบบเลื่อน

ตัวดำเนินการบิทแบบเลื่อน ใช้กับตัวถูกดำเนินการสองค่า ค่าแรกคือข้อมูลที่จะทำการเลื่อน ค่าที่สองคือจำนวนตำแหน่งบิทที่จะเลื่อน ทิศทางเลื่อนควบคุมโดยชนิดตัวดำเนินการที่ใช้

ตัวดำเนินการแบบเลื่อนนี้ จะแปลงค่าข้อมูลของตัวถูกดำเนินการให้เป็นจำนวนเต็มฐานสอง และคืนผลลัพธ์ที่ได้ด้วยข้อมูลแบบเดียวกับตัวถูกดำเนินการทางซ้าย

ตัวดำเนินการแบบเลื่อนมีรายละเอียดดังตารางต่อไปนี้

ตัวดำเนินการตรรกะ

ตัวดำเนินการตรรกะโดยทั่วไปใช้กับข้อมูลตรรกะ และคืนค่าเป็นข้อมูลตรรกะ แต่ตามจริงแล้ว, ตัวดำเนินการ && และ || จะคืนค่าใดค่าหนึ่งของตัวถูกดำเนินการ ดังนั้นถ้านำไปใช้กับค่าที่ไม่ใช่ข้อมูลตรรกะ อาจจะได้ผลลัพธ์ที่ไม่ใช่ข้อมูลตรรกะ ดังอธิบายได้ตามตารางต่อไปนี้

โดยนิพจน์ที่สามารถแปลงเป็น false ได้คือ นิพจน์ที่หาค่าได้เป็น ค่าว่าง, 0, NaN, สตริงว่าง ("") , หรือ undefined

โค้ดต่อไปนี้แสดงตัวอย่างการใช้ ตัวดำเนินการ && (ตรรกะ AND)

var a1 =  true && true;     // t && t returns true
var a2 =  true && false;    // t && f returns false
var a3 = false && true;     // f && t returns false
var a4 = false && (3 == 4); // f && f returns false
var a5 = "Cat" && "Dog";    // t && t returns Dog
var a6 = false && "Cat";    // f && t returns false
var a7 = "Cat" && false;    // t && f returns false

โค้ดต่อไปนี้แสดงตัวอย่างการใช้ ตัวดำเนินการ || (ตรรกะ OR)

var o1 =  true || true;     // t || t returns true
var o2 = false || true;     // f || t returns true
var o3 =  true || false;    // t || f returns true
var o4 = false || (3 == 4); // f || f returns false
var o5 = "Cat" || "Dog";    // t || t returns Cat
var o6 = false || "Cat";    // f || t returns Cat
var o7 = "Cat" || false;    // t || f returns Cat

โค้ดต่อไปนี้แสดงตัวอย่างการใช้ ตัวดำเนินการ ! (ตรรกะ NOT)

var n1 = !true;  // !t returns false
var n2 = !false; // !f returns true
var n3 = !"Cat"; // !t returns false

การหาค่าแบบวิธีลัด

เนื่องจากการหาค่านิพจน์แบบตรรกะ เป็นแบบซ้ายไปขวา, จึงสามารถใช้วิธีลัดเพื่อหาค่าได้ดังนี้

• false && อะไรก็ได้ , ใช้วิธีลัดจะได้ false
• true || อะไรก็ได้ , ใช้วิธีลัดจะได้ true

ด้วยกฏของตรรกะรับประกันได้ว่า การหาค่าแบบนี้ถูกต้องเสมอ และเนื่องจาก อะไรก็ได้  ในนิพจน์ด้านบนไม่ถูกดำเนินการ จีงไม่ส่งผลข้างเคียงจากการหาค่า อะไรก็ได้

ตัวดำเนินการสตริง

นอกจากตัวดำเนินการเปรียบเทียบจะใช้กับข้อมูลสตริงได้แล้ว, ตัวดำเนินการ + ก็สามารถเชื่อมต่อสตริงสองตัวเข้าด้วยกันได้ โดยคืนค่าสตริงใหม่ที่เกิดจากการรวมกันของสตริงทั้งสอง เช่น "my " + "string" ได้สตริง "my string"

ตัวดำเนินการให้ค่าแบบย่อ += สามารถใช้เชื่อมสตริงเข้าด้วยกันได้ เช่น, มีตัวแปรชื่อ mystring มีค่า "alpha", นิพจน์ mystring += "bet" จะหาค่าได้เป็น "alphabet" และให้ค่านี้กับตัวแปร mystring

ตัวดำเนินการพิเศษ

จาวาสคริปต์มีตัวดำเนินการพิเศษให้ดังนี้:

• ตัวดำเนินการเงื่อนไข
• ตัวดำเนินการคอมมา
• delete
• in
• instanceof
• new
• this
• typeof
• void

ตัวดำเนินการเงื่อนไข

ตัวดำเนินการเงื่อนไข เป็นตัวดำเนินการแบบเดียวในจาวาสคริปต์ที่รับตัวถูกดำเนินการสามค่า และคืนค่าใดค่าหนึ่งจากสองค่าตามเงื่อนไข โดยมีรูปแบบดังนี้:

เงื่อนไข ? val1 : val2

ถ้า เงื่อนไข เป็นจริง, จะคืนค่าจาก val1  นอกนั้นจะคืนค่าจาก val2 โดยคุณสามารถใช้ตัวดำเนินการนี้ได้ทุกที่เหมือนตัวดำเนินการปกติ.

ตัวอย่าง เช่น,

var status = (age >= 18) ? "adult" : "minor";

คำสั่งนี้เป็นการให้ค่า "adult" แก่ตัวแปร status ถ้า age มากกว่าเท่ากับสิบแปด, นอกนั้นจะให้ค่า "minor" แก่  status

ตัวดำเนินการคอมมา

ตัวดำเนินการคอมมา (,) ทำหน้าที่หาค่าจากตัวถูกดำเนินการสองตัว และคืนค่าตัวที่สอง โดยตัวดำเนินการนี้ใช้ในคำสั่งลูป for เป็นหลัก, เพื่อให้สามารถปรับค่าตัวแปรหลายตัวในแต่ละลูปได้

ตามตัวอย่าง, ถ้า a เป็นอาร์เรย์สองมิติมีสมาชิกจำนวน 10 ตัว, ในโค้ดจะใช้ตัวดำเนินการคอมมา เพื่อเพิ่มค่าตัวแปรทั้งสองตัวพร้อมๆกัน โดยโค้ดนี้จะพิมพ์ค่าสมาชิกในแนวแทยงมุมของอาร์เรย์ออกมา

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

delete

ตัวดำเนินการ delete ใช้เพื่อลบอ็อบเจกต์, คุณสมบัติอ็อบเจกต์, หรือสมาชิกของอาร์เรย์ในตำแหน่งที่ระบุ โดยมีรูปแบบการใช้งานดังนี้:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement

โดยที่ objectName คือชื่ออ็อบเจกต์, property คือคุณสมบัติอ็อบเจ็กต์, และ index เป็นจำนวนเต็มแทนตำแหน่งของสมาชิกในอาร์เรย์

รูปแบบที่สี่ ใช้ในคำสั่ง with เพื่อลบคุณสมบัติออกจากอ็อบเจกต์

คุณสามารถใช้ตัวดำเนินการ delete เพื่อลบตัวแปรที่ประกาศโดยไม่มีคำสั่ง var ได้

ถ้า delete ดำเนินการสำเร็จ จะกำหนดคุณสมบัติหรือสมาชิกที่ถูกลบให้มีค่าเป็น undefined โดยจะคืนค่า true ถ้าการดำเนินการเป็นไปได้ และคืนค่า false ถ้าเป็นไปไม่ได้

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)

การลบสมาชิกในอาร์เรย์

เมื่อคุณลบสมาชิกของอาร์เรย์, ความยาวของอาร์เรย์จะไม่เปลี่ยนแปลง เช่น, ถ้าลบ a[3], a[4] ก็ยังเป็น a[4] และ a[3] มีค่า undefined

เมื่อตัวดำเนินการ delete ทำการลบสมาชิกอาร์เรย์,จะทำให้ไม่มีสมาชิกนั้นอยู่ในอาร์เรย์อีก ในตัวอย่างต่อไปนี้, trees[3] ถูกลบออกด้วย delete ทำให้นิพจน์ (3 in trees) ไม่เป็นจริง นั่นคือสมาชิกตัวที่สามไม่มีอยู่ในอาร์เรย์แล้ว แต่อย่างไรก็ตามยังสามารถอ้างถึง trees[3] ได้ โดยจะได้ค่าเป็น undefined

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed
}

ถ้าคุณต้องการคงสมาชิกอาร์เรย์ไว้ แต่ไม่ต้องการให้มีค่า, ให้ใช้ undefined แทนการใช้ delete จากตัวอย่าง, tree[3] ถูกให้ค่าเป็น undefined โดยนิพจน์ (3 in trees)ยังเป็นจริงอยู่ นั่นคือสมาชิกตัวที่สามยังคงอยู่ในอาร์เรย์

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed
}

in

ตัวดำเนินการ in คืนค่า true ถ้ามีคุณสมบัติที่ระบุอยู่ในอ็อบเจกต์นั้น

propNameOrNumber in objectName

โดยที่ propNameOrNumber เป็นสตริงหรือนิพจน์ที่มีค่าเป็นตัวเลข แทนชื่อคุณสมบัติหรือตำแหน่งอาร์เรย์ และ objectName แทนชื่ออ็อบเจกต์

ตัวอย่างต่อไปนี้แสดงการใช้ตัวดำเนินการ in

// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true

instanceof

ตัวดำเนินการ instanceof คืนค่า true ถ้าอ็อบเจกต์ที่ต้องการเปรียบเทียบเป็นชนิดเดียวกันกับที่ระบุ มีรูปแบบดังนี้

objectName instanceof objectType

โดย objectName คือชื่ออ็อบเจกต์ที่ต้องการเปรียบเทียบ,และ objectType คือชนิดของอ็อบเจกต์ที่ระบุ เช่น Date หรือ Array

ใช้ instanceof เมื่อคุณจำเป็นต้องยืนยันชนิดอ็อบเจกต์ตอนโปรแกรมทำงาน เช่น, ในโค้ดตรวจสอบข้อผิดพลาด คุณสามารถกำหนดให้โปรแกรมทำงานตามชนิดข้อผิดพลาดที่เกิดขึ้นได้

ตัวอย่างโค้ดต่อไปนี้ใช้ instanceof เพื่อหาว่า theDay เป็นอ็อบเจกต์ Date หรือไม่, และเนื่องจาก theDay เป็นอ็อบเจกต์ Date คำสั่ง if จืงทำงานได้

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute
}

new

คุณใช้ตัวดำเนินการ new เพื่อสร้างอ็อบเจกต์จากรูปแบบที่กำหนดเอง หรือจากที่มีในจาวาสคริปต์แล้วคือ Array,Boolean,Date,Function,Image, Number, Object, Option, RegExp, หรือ String  โดยใน server, ยังสามารถใช้กับ DbPool, Lock, File, หรือ SendMail ได้ ซึ่งการใช้งาน new มีรูปแบบดังนี้:

var objectName = new objectType([param1, param2, ..., paramN]);

คุณยังสามารถสร้างอ็อบเจกต์ได้จากตัวสร้างออบเจกต์  จากที่ได้อธิบายใน using object initializers

ดูข้อมูลเพิ่มเติมที่หน้า new operator ใน Core JavaScript Reference

this

ใช้คำสั่ง this เพื่ออ้างถึงอ็อบเจกต์ปัจจุบัน โดยทั่วไป this ในเมธอดจะหมายถึงอ็อบเจกต์ที่กำลังทำงานอยู่ โดยมีรูปแบบการใช้งานดังนี้

this["propertyName"]

this.propertyName

ตัวอย่างที่ 1.

สมมุติว่ามีฟังก์ชันชื่อ validate ทำหน้าที่ตรวจสอบคุณสมบัติ value ของอ็อบเจกต์, โดยกำหนดให้รับค่าอ็อบเจกต์,ค่าสูง,และค่าต่ำ ดังนี้:

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Invalid Value!");
}

คุณสามารถเรียกใช้งาน validate จากเหตุการณ์ onChange ของแต่ละอ็อบเจกต์ในฟอร์มได้, โดยการส่งค่า this แทนอ็อบเจกต์นั้น ตามตัวอย่างต่อไปนี้

<B>Enter a number between 18 and 99:</B>
<INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);">

ตัวอย่างที่ 2.
this.form สามารถใช้อ้างถึงอ็อบเจกต์ฟอร์มได้ ในตัวอย่างต่อไปนี้, ฟอร์มชื่อ myForm ประกอบด้วยอ็อบเจกต์ Text และปุ่มกด เมื่อผู้ใช้กดปุ่ม, ค่าในอ็อบเจกต์จะถูกกำหนดให้เป็นชื่อของฟอร์ม จากเหตุการณ์ onClick ของปุ่มกด ซึ่งใช้คำสั่ง this.form แทนฟอร์ม myForm

<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga"/>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;"/>
</FORM>

typeof

ตัวดำเนินการ typeof ใช้ได้สองแบบดังนี้:

1. typeof operand
   

2. typeof (operand)
   

ตัวดำเนินการ typeof คืนค่าสตริงแสดงชนิดของตัวถูกดำเนินการ (ที่ยังไม่ถูกประมวลค่า) ซึ่งเป็นได้ทั้ง สตริง,ตัวแปร,คำสั่ง, หรืออ็อบเจกต์ ที่ต้องการทราบชนิด โดยจะใส่วงเล็บหรือไม่ใส่ก็ได้

สมมุติว่าคุณได้ประกาศตัวแปรต่อไปนี้:

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

ตัวดำเนินการ typeof จะคืนค่าผลลัพธ์ของแต่ละตัวแปรดังนี้:

typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"

สำหรับ true และ null, ตัวดำเนินการ typeof จะคืนค่าผลลัพธ์ดังนี้:

typeof true; // returns "boolean"
typeof null; // returns "object"

สำหรับตัวเลขและสตริง, ตัวดำเนินการ typeof จะคืนค่าผลลัพธ์ดังนี้:

typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"

สำหรับค่าคุณสมบัติ, ตัวดำเนินการ typeof จะคืนชนิดของข้อมูลในคุณสมบัตินั้น:

typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"

สำหรับเมธอดและฟังก์ชัน, ตัวดำเนินการ typeof จะคืนค่าผลลัพธ์ดังนี้:

typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"

สำหรับอ็อบเจกต์พื้นฐาน, ตัวดำเนินการ typeof จะคืนค่าผลลัพธ์ดังนี้:

typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"

void

ตัวดำเนินการ void ใช้ได้แบบใดแบบหนึ่งดังนี้:

1. void (expression)
   

2. void expression
   

ตัวดำเนินการ void ประมวลค่านิพจน์ที่กำหนดแต่ไม่คืนค่าออกมา โดยที่ expression คือนิพจน์ที่ต้องการหาค่า จะใส่หรือไม่ใส่วงเล็บก็ได้แต่รูปแบบที่ดีคือใส่ในวงเล็บ

คุณสามารถใช้ตัวดำเนินการ void กับนิพจน์ในลิงค์ไฮเปอร์เทกซ์ ซึ่งจะทำงานเมื่อมีการคลิ๊ก โดยไม่มีการโหลดหน้าเว็บใหม่

โค้ดต่อไปนี้สร้างลิงค์ไฮเปอร์เทกซ์ที่ไม่เกิดอะไรขึ้นเมื่อผู้ใช้คลิ๊ก โดยเมื่อลิ๊งค์ถูกคลิ๊ก, void(0) จะได้ค่าเป็น undefined ซึ่งไม่ทำให้เกิดอะไรขึ้นในจาวาสคริปต์

<A HREF="javascript:void(0)">Click here to do nothing</A>

โค้ดต่อไปนี้สร้างลิงค์ไฮเปอร์เทกซ์ ที่จะส่งฟอร์มเมื่อผู้ใช้คลิ๊กมัน

<A HREF="javascript:void(document.form.submit())">
Click here to submit</A>

ลำดับความสำคัญของตัวดำเนินการ

ลำดับความสำคัญของตัวดำเนินการ คือลำดับการทำงานของตัวดำเนินการเมื่อมีการประมวลค่านิพจน์ โดยคุณสามารถจัดลำดับเองได้โดยใช้วงเล็บช่วย

ตารางต่อไปนี้อธิบายลำดับความสำคัญของตัวดำเนินการ,  จากสูงที่สุดไปหาต่ำที่สุด

In accordance with relevant discussion, this table was reversed to list operators in decreasing order of priority.

รายละเอียดเพิ่มเติมของตารางนี้, พร้อมลิ๊งค์ที่มีรายละเอีนดของตัวดำเนินการแต่ละตัว หาได้จาก JavaScript Reference