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

ผู้มีส่วนร่วมกับหน้านี้: Zarazi
อัปเดตล่าสุดโดย: Zarazi,