Expressions and operators

This translation is incomplete. Please help translate this article from English.

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

นิพจน์ (Expressions)

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

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

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

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

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

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

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

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

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

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

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

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

หรือ

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

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

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

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

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

ตาราง 3.1 ตัวดำเนินการให้ค่าแบบอื่นๆ
รูปแบบย่อตัวดำเนินการ ความหมาย
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
x <<= y x = x << y
x >>= y x = x >> y
x >>>= y x = x >>> y
x &= y x = x & y
x ^= y x = x ^ y
x |= y x = x | y

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

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

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

var var1 = 3, var2 = 4;
ตาราง 3.2 ตัวดำเนินการเปรียบเทียบ
ตัวดำเนินการ คำอธิบาย ตัวอย่างที่เป็นจริง (true)
เท่ากับ (==) ได้ค่าจริง ถ้าตัวถูกดำเนินการเท่ากัน 3 == var1
"3" == var1
3 == '3'
ไม่เท่ากับ (!=) ได้ค่าจริง ถ้าตัวถูกดำเนินการไม่เท่ากัน var1 != 4
var2 != "3"
เท่ากันจริง (===)

ได้ค่าจริง ถ้าตัวถูกดำเนินการเท่ากัน และมีชนิดเดียวกัน ดูเพิ่มเติมที่ Object.is และ sameness in JS

3 === var1
ไม่เท่ากันจริง (!==) ได้ค่าจริง ถ้าตัวถูกดำเนินการไม่เท่ากัน และ/หรือ ต่างชนิดเดียวกัน var1 !== "3"
3 !== '3'
มากกว่า (>)

ได้ค่าจริง ถ้าตัวถูกดำเนินการทางซ้าย มากกว่าตัวขวา

var2 > var1
"12" > 2
มากกว่าเท่ากับ (>=) ได้ค่าจริง ถ้าตัวถูกดำเนินการทางซ้าย มากกว่าหรือเท่ากับตัวขวา var2 >= var1
var1 >= 3
น้อยกว่า (<) ได้ค่าจริง ถ้าตัวถูกดำเนินการทางซ้าย น้อยกว่าตัวขวา var1 < var2
"2" < "12"
น้อยกว่าเท่ากับ (<=) ได้ค่าจริง ถ้าตัวถูกดำเนินการทางซ้าย น้อยกว่าหรือเท่ากับตัวขวา var1 <= var2
var2 <= 5

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

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

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

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

ตาราง 3.3 ตัวดำเนินการคณิตศาสตร์
ตัวดำเนินการ คำอธิบาย ตัวอย่าง
%
(มอดูลัส)
เป็นตัวดำเนินการคู่, ให้ค่าเศษจากการหารกันเป็นจำนวนเต็ม 12 % 5 ได้ค่า 2
++
(เพิ่มค่า)

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

ถ้า x เป็น 3, แล้ว ++x จะได้ x เป็น 4 และคืนค่า 4, ในขณะที่ x++ คืนค่า 3 แล้วจึงทำให้ x เป็น 4.
--
(ลดค่า)
เป็นตัวดำเนินการเดี่ยว, ลบหนึ่งออกจากตัวถูกดำเนินการ ค่าที่คืนเป็นไปแนวเดียวกับตัวเพิ่มค่า ถ้า x เป็น 3, แล้ว --x จะได้ x เป็น 2 และคืนค่า 2, ในขณะที่ x-- คืนค่า 3 แล้วจึงทำให้ x เป็น 2
-
(ทำให้เป็นลบ)

เป็นตัวดำเนินการเดี่ยว, คืนค่าลบของตัวถูกดำเนินการ

ถ้า x เป็น 3, แล้ว -x จะได้ -3

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

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

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

ตาราง 3.4 ตัวดำเนินการบิท
ตัวดำเนินการ วิธีใช้ คำอธิบาย
AND a & b คืนค่า 1 ในแต่ละบิท ที่มีค่าเป็น 1 ทั้งคู่
OR a | b คืนค่า 1 ในแต่ละบิท ที่มีค่าตัวใดตัวหนึ่ง หรือทั้งคู่เป็น 1
XOR a ^ b คืนค่า 1 ในแค่ละบิท ที่มีค่าตัวใดตัวหนึ่ง แต่ไม่ใช่ทั้งคู่เป็น 1
NOT ~ a ทำทุกบิทให้มีค่าตรงกันข้าม
เลื่อนซ้าย a << b

เลื่อนข้อมูล a ไปทางซ้ายจำนวน b บิท และเติม 0 เข้าทางขวา

เลื่อนขวาเก็บเครื่องหมาย a >> b เลื่อนข้อมูล a ไปทางขวาจำนวน b บิท ทิ้งบิทที่ถูกเลื่อนออกไป และเติม 0 เข้าทางซ้าย ถ้า a เป็นบวก, เติม 1 ถ้าเป็นลบ
เลื่อนขวาเติมศูนย์ a >>> b เลื่อนข้อมูล a ไปทางขวาจำนวน b บิท ทิ้งบิทที่ถูกเลื่อนออกไป และเติม 0 เข้าทางซ้าย

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

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

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

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

ตาราง 3.5 ตัวอย่างการใช้ตัวดำเนินการบิท
นิพจน์ ผลลัพธ์ รูปแบบฐานสอง
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

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

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

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

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

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

ตาราง 3.6 ตัวดำเนินการบิทแบบเลื่อน
ตัวดำเนินการ คำอธิบาย ตัวอย่าง
<<
(เลื่อนซ้าย)

ตัวดำเนินการนี้ เลื่อนข้อมูลตัวแรกไปทางซ้ายด้วยจำนวนบิทจากข้อมูลตัวหลัง ตัดบิทที่เกินออกทางซ้ายทิ้งไป และเติมบิท 0 เข้าทางขวา

9<<2 ได้ 36, เพราะ 1001 เลื่อนไป 2 บิททางซ้ายได้ 100100, ซึ่งเท่ากับ 36

>>
(เลื่อนขวาเก็บเครื่องหมาย)

ตัวดำเนินการนี้ เลื่อนข้อมูลตัวแรกไปทางขวาด้วยจำนวนบิทจากข้อมูลตัวหลัง ตัดบิทที่เกินออกทางขวาทิ้งไป และเติมสำเนาบิทซ้ายสุดเข้าทางซ้าย

9>>2 ได้ 2, เพราะ 1001 เลื่อนไป 2 บิททางขวาได้ 10, ซึ่งเท่ากับ 2

ทำนองเดียวกัน, -9>>2 ได้ -3, เพราะ -9 เท่ากับ 111...110111 เลื่อนไป 2 บิททางขวาและเติม 1 ทางซ้ายได้ 111...111101,ซึ่งเท่ากับ -3

>>>
(เลื่อนขวาเติมศูนย์)

ตัวดำเนินการนี้ เลื่อนข้อมูลตัวแรกไปทางขวาด้วยจำนวนบิทจากข้อมูลตัวหลัง ตัดบิทที่เกินออกทางขวาทิ้งไป และเติมบิท 0 เข้าทางซ้าย

19>>>2 ได้ 4, เพราะ 10011 เลื่อนไป 2 บิททางขวาได้ 100, ซึ่งเท่ากับ 4

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

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

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

ตาราง 3.6 ตัวดำเนินการตรรกะ
Operator Usage Description
&& expr1 && expr2 (ตรรกะ AND) คืนค่า expr1 ถ้าแปลงเป็น false ได้ นอกนั้นคืนค่า expr2 โดยถ้านำไปใช้กับข้อมูลตรรกะ, && จะคืน true ถ้าทั้งสองค่าเป็นจริง, นอกนั้นคืน false
|| expr1 || expr2 (ตรรกะ OR) คืนค่า expr1 ถ้าแปลงเป็น true ได้ นอกนั้นคืนค่า expr2 โดยถ้านำไปใช้กับข้อมูลตรรกะ, || จะคืน true ถ้าค่าใดค่าหนึ่งเป็นจริง ถ้าทั้งคู่เป็นเท็จ, คืนค่า false
! !expr (ตรรกะ NOT) คืนค่า false ถ้าสามารถแปลงค่า expr เป็น true ได้,นอกนั้นคืนค่า true

โดยนิพจน์ที่สามารถแปลงเป็น 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

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

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

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

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

เงื่อนไข ? 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.

ตาราง 3.7 ลำดับความสำคัญของตัวดำเนินการ
ชนิดตัวดำเนินการ ตัวดำเนินการแต่ละตัว
member . []
call / create instance () new
negation/increment ! ~ - + ++ -- typeof void delete
multiply/divide * / %
addition/subtraction + -
bitwise shift << >> >>>
relational < <= > >= in instanceof
equality == != === !==
bitwise-and &
bitwise-xor ^
bitwise-or |
logical-and &&
logical-or ||
conditional ?:
assignment = += -= *= /= %= <<= >>= >>>= &= ^= |=
comma ,

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

Document Tags and Contributors

 Contributors to this page: Zarazi
 Last updated by: Zarazi,