JavaScript Core Expressions และ Operators

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

นิพจน์ที่ซับซ้อนประกอบด้วยการแสดงออกอย่างง่าย ตัวอย่างเช่นนิพจน์การเข้าถึงอาร์เรย์ประกอบด้วยนิพจน์ที่แสดงถึงอาร์เรย์วงเล็บสี่เหลี่ยมจัตุรัสและนิพจน์จำนวนเต็ม การดำเนินการนิพจน์ใหม่ที่พวกเขาฟอร์มเป็นค่าองค์ประกอบที่ตำแหน่งเฉพาะในอาร์เรย์ จดหมายฉบับเดียวกัน

นิพจน์การโทรตัวเลขประกอบด้วยนิพจน์ที่แสดงถึงวัตถุฟังก์ชันและ 0 การแสดงออกของพารามิเตอร์มากกว่า 0 วิธีที่พบบ่อยที่สุดในการรวมการแสดงออกอย่างง่ายเข้ากับนิพจน์ที่ซับซ้อนคือตัวดำเนินการ

บทนี้ (บทความนี้) จะอธิบายตัวดำเนินการ JavaScript ทั้งหมด นอกจากนี้ยังอธิบายถึงการแสดงออกที่ไม่เกี่ยวข้องกับผู้ให้บริการ (เช่นการเข้าถึงองค์ประกอบอาร์เรย์และการเรียกใช้ฟังก์ชัน) และรูปแบบไวยากรณ์และการเขียนโปรแกรมนั้นคล้ายกับภาษา C มาก

1. การแสดงออกขององค์ประกอบ

นิพจน์ที่ง่ายที่สุดคือ "นิพจน์ดั้งเดิม" ซึ่งเป็นหน่วยที่เล็กที่สุดของนิพจน์ - พวกเขาไม่มีการแสดงออกอื่น ๆ นิพจน์ต้นฉบับในจาวาสคริปต์มีค่าคงที่หรือปริมาณโดยตรง คำหลักและตัวแปร

ปริมาณโดยตรงคือค่าคงที่ที่ปรากฏโดยตรงในโปรแกรม ดูเหมือนว่า:

การคัดลอกรหัสมีดังนี้:

1.23 // ปริมาณโดยตรง

"สวัสดี" // มีปริมาณโดยตรง

/ รูปแบบ/ // ปริมาณโดยตรงนิพจน์ทั่วไป

คำบางคำที่สงวนไว้ใน JavaScript เป็นนิพจน์ดั้งเดิม

การคัดลอกรหัสมีดังนี้:

ค่าจริง // บูลีน: จริง

FALSE // FALSE

null // ส่งคืนค่า: ว่างเปล่า

// ส่งคืนวัตถุ "ปัจจุบัน"

ผ่านการเรียนรู้บทที่ 3 ซึ่งแตกต่างจากคำหลักอื่น ๆ นี่ไม่ใช่ค่าคงที่และค่าที่ส่งกลับในส่วนต่าง ๆ ของโปรแกรมก็แตกต่างกันเช่นกัน คำหลักนี้มักจะปรากฏในการเขียนโปรแกรมเชิงวัตถุ สิ่งนี้จะส่งคืนวัตถุของวิธีการสี่เหลี่ยม

ในที่สุดนิพจน์ดั้งเดิมที่สามเป็นตัวแปร

การคัดลอกรหัสมีดังนี้:

ฉัน // ส่งคืนค่าของตัวแปร i

ผลรวม // ส่งคืนค่าผลรวม

undefined // เป็นตัวแปรส่วนกลางซึ่งแตกต่างจาก null ไม่ใช่คำหลัก

2. การแสดงการเริ่มต้นของวัตถุและอาร์เรย์

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

ไวยากรณ์ของนิพจน์การเริ่มต้นของอาร์เรย์นั้นง่ายมากเริ่มต้นกันเถอะ

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

[] // อาร์เรย์ที่ว่างเปล่า; [] ว่างเปล่าไว้ในนั้นหมายความว่าอาร์เรย์ไม่มีองค์ประกอบ

[1+2,3+4] // อาร์เรย์ที่มีสององค์ประกอบส่วนแรกคือ 3 ส่วนที่สองคือ 7

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

การคัดลอกรหัสมีดังนี้:

var mat = [[1,2,3], [4,5,6], [7,8,9]];

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

การคัดลอกรหัสมีดังนี้:

var a = [1 ,,,, 5]

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

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

การคัดลอกรหัสมีดังนี้:

var p = {x: 2.1, y: -3} // วัตถุที่มีสมาชิกแอตทริบิวต์สองคน

var q = {}; // วัตถุเปล่า

qx = 2.1; qy = -3; // สมาชิกแอตทริบิวต์ของ Q นั้นเหมือนกับของ P

วัตถุสามารถซ้อนกันได้โดยตรงเช่น

การคัดลอกรหัสมีดังนี้:

var anh = {ซ้าย: {x: 2, y: 3}

ขวา: {x: 4, y: 5}}

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

การคัดลอกรหัสมีดังนี้:

ด้าน var = 1;

var square = {"ซ้าย": {x: px, y: py},

'ขวา': {x: p.x+ด้าน, y: p.y+ข้าง}}}

บทที่ 67 จะหารือเกี่ยวกับการแสดงการเริ่มต้นของวัตถุและอาร์เรย์อีกครั้ง

3. การแสดงออกของฟังก์ชั่น

นิยามนิยามฟังก์ชั่นกำหนดฟังก์ชัน JavaScript ค่าของนิพจน์คือฟังก์ชั่นที่กำหนดไว้ใหม่นี้ ในแง่หนึ่งการแสดงออกของฟังก์ชั่นนิยามสามารถกลายเป็นปริมาณฟังก์ชั่นโดยตรงและการแสดงออกของฟังก์ชั่นสามารถเรียกได้ว่า "ปริมาณฟังก์ชั่นโดยตรง" หลังจากนิพจน์การเริ่มต้นวัตถุทั้งหมดเรียกว่า "ปริมาณวัตถุโดยตรง" นิพจน์นิยามฟังก์ชั่นทั่วไปมีฟังก์ชั่นคำหลักตามด้วยคู่ของวงเล็บรายการที่คั่นด้วยเครื่องหมายจุลภาคและรายการมีตัวระบุ 0 หรือมากกว่า (ชื่อพารามิเตอร์) จากนั้นทำตามส่วนรหัส JavaScript (ฟังก์ชั่นร่างกาย) ห่อด้วยการจัดฟันแบบหยิก

var square = function (x) {return x*x};

นิยามนิยามฟังก์ชั่นสามารถมีชื่อของฟังก์ชั่น ฟังก์ชั่นสามารถกำหนดได้โดยคำสั่งฟังก์ชั่นมากกว่าการแสดงออกของฟังก์ชั่น เนื้อหาเพิ่มเติมจะอธิบายไว้ในบทที่ 8

4. นิพจน์การเข้าถึงแอตทริบิวต์

การดำเนินการนิพจน์การเข้าถึงแอตทริบิวต์ได้รับค่าของวัตถุหรือองค์ประกอบอาร์เรย์ JavaScript กำหนดสองวิธีสำหรับการเข้าถึงคุณสมบัติ

การคัดลอกรหัสมีดังนี้:

การแสดงออก . ผู้แนะนำ

นิพจน์ [นิพจน์]

วิธีแรกคือการเขียนนิพจน์ตามด้วยช่วงเวลาและตัวระบุ นิพจน์ระบุวัตถุและตัวระบุระบุแอตทริบิวต์ Mingchuan เพื่อเข้าถึง

บทที่ 2 เขียนขึ้นโดยใช้วงเล็บเหลี่ยมซึ่งเป็นนิพจน์ (วิธีนี้เหมาะสำหรับวัตถุและอาร์เรย์) นิพจน์ที่สองระบุคุณสมบัติ Mingchuan ที่จะเข้าถึงหรือดัชนีแสดงองค์ประกอบอาร์เรย์ที่จะเข้าถึง นี่คือตัวอย่างเฉพาะ

การคัดลอกรหัสมีดังนี้:

ox // => 1x แอตทริบิวต์ของนิพจน์ o

oyz // => 3 z แอตทริบิวต์ของนิพจน์ oy

o. ["x"] // => 1 แอตทริบิวต์ x ของ Object O

A [1] // => 4 องค์ประกอบที่มีดัชนีของนิพจน์ a คือ 1

A [2] ["1"] // => 6 องค์ประกอบที่มีดัชนี 1 ในนิพจน์ A [2]

A [0] .x // => 1: x แอตทริบิวต์ของนิพจน์ a [0]

โดยไม่คำนึงถึงรูปแบบของนิพจน์การเข้าถึงแอตทริบิวต์ที่ใช้การแสดงออกก่อน "." และ "[" ได้รับการประเมินก่อนเสมอ หากผลการประเมินเป็นโมฆะหรือไม่ได้กำหนดนิพจน์จะโยนข้อผิดพลาดประเภทเนื่องจากค่าเหล่านี้ไม่สามารถมีแอตทริบิวต์ใด ๆ หากผลการดำเนินการไม่ใช่วัตถุหรืออาร์เรย์ JavaScript จะแปลงเป็นวัตถุ (บทที่ 3 ส่วนที่ 6)

แม้ว่า. identifier จะถูกเขียนขึ้นง่ายขึ้น แต่ก็ควรสังเกตว่าวิธีนี้ใช้กับชื่อแอตทริบิวต์ที่จะเข้าถึงเท่านั้นและเป็นตัวระบุทางกฎหมาย และคุณต้องรู้ชื่อของแอตทริบิวต์เพื่อเข้าถึง หากชื่อคุณสมบัติเป็นคำที่สงวนไว้หรือมีเครื่องหมายช่องว่างและเครื่องหมายวรรคตอนและเป็นตัวเลข (สำหรับอาร์เรย์) ต้องเขียนวงเล็บเหลี่ยม เมื่อชื่อแอตทริบิวต์เป็นค่าที่ได้จากตัวดำเนินการแทนที่จะเป็นค่าคงที่ต้องเขียนวงเล็บเหลี่ยม (บทที่ 6, 2, 1 บาร์)

5. การแสดงออกการขนส่ง

นิพจน์การเรียกร้องใน JavaScript เป็นการแสดงไวยากรณ์ของการเรียก (หรือการดำเนินการ) ฟังก์ชันหรือวิธีการ มันเริ่มต้นด้วยนิพจน์ฟังก์ชั่นที่อ้างถึงฟังก์ชั่นที่จะเรียก การแสดงออกของฟังก์ชั่นตามด้วยคู่ของวงเล็บพร้อมรายการพารามิเตอร์ที่คั่นด้วยเครื่องหมายจุลภาค อาจมีพารามิเตอร์ 0 หรือพารามิเตอร์หลายตัว

f (0) // f เป็นฟังก์ชันนิพจน์: 0 คือนิพจน์พารามิเตอร์

math.max (x, y, z) //math.max เป็นฟังก์ชั่น; x, y และ z เป็นพารามิเตอร์

A.Sort () //a.sort () เป็นฟังก์ชั่นที่ไม่มีพารามิเตอร์

เมื่อการแสดงออกถูกเรียกสำหรับการประเมินผลก่อนคำนวณนิพจน์ฟังก์ชันจากนั้นคำนวณนิพจน์พารามิเตอร์เพื่อให้ได้ชุดของค่าพารามิเตอร์ หากค่าของนิพจน์ฟังก์ชั่นไม่ใช่วัตถุที่เรียกได้ ค่าของพารามิเตอร์จะถูกกำหนดให้กับพารามิเตอร์ที่เป็นทางการซึ่งถูกกำหนดเมื่อกำหนดฟังก์ชัน ถัดไปเรียกใช้งานร่างกายฟังก์ชั่น หากฟังก์ชั่นใช้คำสั่ง Return เพื่อให้ค่าส่งคืนค่าผลตอบแทนนี้จะเป็นค่าของนิพจน์การโทรทั้งหมด มิฉะนั้นค่าของนิพจน์การโทรจะไม่ได้กำหนด รายละเอียดของการเรียกใช้ฟังก์ชัน - รวมถึงจำนวนการแสดงออกของพารามิเตอร์อย่างเป็นทางการและจำนวนพารามิเตอร์จริงในนิยามฟังก์ชัน - จะอธิบายรายละเอียดในบทที่ 8

นิพจน์การโทรใด ๆ มีคู่ของวงเล็บและนิพจน์ก่อนที่วงเล็บด้านซ้าย หากนิพจน์นี้เป็นนิพจน์การเข้าถึงคุณสมบัติการโทรนี้เรียกว่า "คำเชิญวิธีการ" เมื่อดำเนินการฟังก์ชั่นในการเรียกใช้วิธีการวัตถุและอาร์เรย์ที่เข้าถึงเป็นแอตทริบิวต์เป็นตัวชี้ของสิ่งนี้ในวิธีการเรียก คุณลักษณะนี้ทำให้เป็นไปได้สำหรับฟังก์ชั่น (ซึ่งชื่อ OO คือ "วิธี") เพื่อเรียกวัตถุโฮสต์ของพวกเขา (เพิ่มเติมในบทที่ 9)

6. นิพจน์การสร้างวัตถุ

นิพจน์การสร้างวัตถุสร้างวัตถุและเรียกฟังก์ชั่น (ตัวสร้าง) เพื่อเริ่มต้นคุณสมบัติของวัตถุ นิพจน์การสร้างวัตถุนั้นคล้ายกับการแสดงออกของฟังก์ชั่นยกเว้นว่ามีคำหลักใหม่เพิ่มเติมก่อนที่จะนิพจน์การสร้างวัตถุ:

วัตถุใหม่ ()

จุดใหม่ (2,3)

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

วัตถุใหม่

จุดใหม่

7. ภาพรวมของผู้ประกอบการ

ตัวดำเนินการใน JavaScript ใช้ในการคำนวณนิพจน์ตารางนิพจน์การเปรียบเทียบนิพจน์เชิงตรรกะนิพจน์การมอบหมาย ฯลฯ

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

ลำดับความสำคัญของตัวดำเนินการย่อยถูกเรียงลำดับและลำดับความสำคัญของตัวดำเนินการก่อนหน้านั้นสูงกว่าลำดับความสำคัญของตัวดำเนินการที่ตามมา ผู้ประกอบการคั่นด้วย Huafeng ในแนวนอนมีลำดับความสำคัญที่แตกต่างกัน

A แสดงถึงลักษณะที่มีผลผูกพันของผู้ประกอบการ

l จากซ้ายไปขวาหรือ R (จากขวาไปซ้าย)

รายการชื่อ N แสดงจำนวนตัวถูกดำเนินการ

ประเภทแสดงถึงประเภทของตัวถูกดำเนินการที่คาดหวังและประเภทผลลัพธ์ของตัวดำเนินการ (หลังจากสัญลักษณ์ "→")

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

ผู้ประกอบการสามารถจำแนกได้ตามจำนวนตัวถูกดำเนินการ

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

JavaScript ยังรองรับตัวดำเนินการที่ไม่ได้เป็น unary ที่แปลงนิพจน์หนึ่งเป็นนิพจน์ที่ซับซ้อนกว่าเล็กน้อย ตัวดำเนินการ " -" ในนิพจน์ -x เป็นตัวดำเนินการแบบ Unary มันคือการหาค่าลบสำหรับ x

JavaScript รองรับผู้ประกอบการ Ternary: ผู้ดำเนินการตัดสินแบบมีเงื่อนไข "?:" ซึ่งรวมสามนิพจน์เข้ากับนิพจน์เดียว

ii. ประเภทตัวถูกดำเนินการและประเภทผลลัพธ์

ผู้ให้บริการบางรายสามารถใช้สำหรับประเภทข้อมูลใด ๆ แต่พวกเขายังต้องการให้พวกเขาทำงานกับข้อมูลประเภทที่ระบุ

iii.lvalue

ผู้ให้บริการที่ได้รับมอบหมายและผู้ให้บริการรายอื่นในตารางคาดว่าจะมีการทำงานประเภท lval ของพวกเขา Lvalue เป็นคำโบราณ หมายความว่า "การแสดงออกสามารถปรากฏขึ้นที่ด้านซ้ายของผู้ดำเนินการที่ได้รับมอบหมาย" ในจาวาสคริปต์ตัวแปรคุณสมบัติวัตถุและองค์ประกอบอาร์เรย์ล้วนเป็น lvalues ​​ทั้งหมด ข้อมูลจำเพาะ ECMASCRIPT อนุญาตให้ฟังก์ชันในตัวในตัวเพื่อส่งคืน LVALUE แต่ฟังก์ชั่นที่กำหนดไว้ไม่สามารถส่งคืน LVALUE ได้

iiii. ลำดับความสำคัญของผู้ประกอบการ

ในตารางด้านบนตัวดำเนินการที่แสดงจะถูกจัดเรียงจากสูงถึงต่ำตามลำดับความสำคัญโดยมีชุดของตัวดำเนินการภายในแต่ละตัวคั่นแนวนอนที่มีลำดับความสำคัญเท่ากัน ลำดับความสำคัญของผู้ประกอบการควบคุมลำดับที่ผู้ให้บริการดำเนินการ ผู้ประกอบการที่มีสูง (ด้านบนของตาราง) จะถูกดำเนินการสูงกว่าผู้ประกอบการที่มีลำดับความสำคัญต่ำ (ด้านล่างของตาราง)

ดูนิพจน์ต่อไปนี้

w = x+y*z;

ตัวดำเนินการคูณ "*" มีลำดับความสำคัญสูงกว่าการเพิ่ม "+" ดังนั้นการคูณจะถูกดำเนินการก่อน จากนั้นเนื่องจากตัวดำเนินการที่ได้รับมอบหมาย "=" มีลำดับความสำคัญต่ำสุด ดังนั้นการดำเนินการที่ได้รับมอบหมายจะดำเนินการหลังจากนิพจน์ทางด้านขวาคำนวณผลลัพธ์

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

w = (x + y) * z;

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

typeof my.function [x] (y)

แม้ว่า typeof เป็นหนึ่งในตัวดำเนินการที่มีลำดับความสำคัญสูงสุด แต่ TypeoF ก็จะดำเนินการหลังจากการเข้าถึงคุณสมบัติสองรายการและการเรียกใช้ฟังก์ชัน

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

iiiiiii.operationality

ในส่วนนี้คอลัมน์ชื่อ A แสดงให้เห็นถึงความเป็นก้อนของผู้ประกอบการ l หมายถึงการรวมกันจากซ้ายไปขวาและ R หมายถึงการรวมกันจากขวาไปซ้าย วัณโรคระบุลำดับการดำเนินงานในการแสดงออกของผู้ประกอบการหลายรายการที่มีลำดับความสำคัญเท่ากัน

ตัวอย่างเช่นการดำเนินการลบจะดำเนินการในชุดค่าผสมจากซ้ายไปขวา

การคัดลอกรหัสมีดังนี้:

w = x - y - z

เช่นรหัสนี้:

การคัดลอกรหัสมีดังนี้:

w = ((x - y) - z)

ในทางกลับกันนิพจน์ต่อไปนี้:

การคัดลอกรหัสมีดังนี้:

x = ~ -y;

w = x = y = z;

Q = A? B: C? D: E? f: G;

เหมือนกับรหัสนี้

การคัดลอกรหัสมีดังนี้:

x = ~ (-y);

w = (x = (y = z));

Q = A? B: (C? d: (e? f: g))

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

iiiiiiiii. คำสั่งซื้อ

ลำดับความสำคัญและการผูกมัดของผู้ประกอบการกำหนดลำดับของการดำเนินการในสมการการกำหนด แต่ไม่ได้ระบุลำดับของการดำเนินการในกระบวนการคำนวณของการแสดงออกของคำ JavaScript คำนวณนิพจน์เสมออย่างเคร่งครัดในลำดับจากซ้ายไปขวาตัวอย่างเช่น:

ในนิพจน์ w = x+y*z นิพจน์ W จะถูกคำนวณก่อนจากนั้น x, y และ z จะถูกคำนวณและจากนั้นค่าของ y จะถูกคูณด้วย z เพิ่มค่าของ x ในที่สุดตัวแปรหรือแอตทริบิวต์ที่อ้างถึงโดยนิพจน์ W ของมันจะถูกอ้างถึง การเพิ่มวงเล็บวงกลมไปยังนิพจน์จะเปลี่ยนความสัมพันธ์ระหว่างการคูณการเพิ่มและการดำเนินการที่ได้รับมอบหมาย แต่คำสั่งซื้อจากซ้ายไปขวาจะไม่เปลี่ยนแปลง

8. การแสดงออกทางคณิตศาสตร์

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

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

ตัวดำเนินการ "/" หารตัวถูกดำเนินการครั้งที่สองโดยตัวถูกดำเนินการครั้งแรกหากคุณใช้ภาษาการเขียนโปรแกรมที่แยกแยะจำนวนเต็มและจุดลอยตัว จากนั้นเมื่อคุณแบ่งจำนวนเต็มด้วยจำนวนเต็มผลลัพธ์ที่ต้องการก็เป็นจำนวนเต็ม ใน JavaScript ตัวเลขทั้งหมดเป็นหมายเลขจุดลอยตัวและผลลัพธ์ของการดำเนินการหารก็เป็นประเภทลอย ตัวอย่างเช่นผลลัพธ์ของ 5/2 คือ 2.5 ไม่ใช่ 2 ผลลัพธ์ของการดำเนินการกับตัวหาร 0 คืออินฟินิตี้บวกหรืออินฟินิตี้เชิงลบ และผลลัพธ์ของ 0/0 คือ NAN การดำเนินการทั้งหมดเหล่านี้จะไม่รายงานข้อผิดพลาด

ผู้ประกอบการ "%" คำนวณโมดูลัสของตัวถูกดำเนินการครั้งแรกไปยังตัวถูกดำเนินการที่สองกล่าวอีกนัยหนึ่งตัวถูกดำเนินการแรกจะถูกหารด้วยส่วนที่เหลือของตัวถูกดำเนินการที่สอง สัญลักษณ์ผลลัพธ์สอดคล้องกับสัญลักษณ์การดำเนินการเมาส์ (หาร) ครั้งแรก ตัวอย่างเช่นผลลัพธ์ของ 5%2 คือ 1 และ -5%2 คือ -1

ตัวถูกดำเนินการของตัวดำเนินการที่เหลืออยู่มักจะเป็นจำนวนเต็ม แต่ก็เหมาะสำหรับตัวเลขลอยตัว 6.5%2.1 ผลลัพธ์คือ 0.2 (0.1999999999999999973)

ฉัน. ผู้ประกอบการ "+"

ตัวดำเนินการไบนารีเพิ่ม "+" สามารถเพิ่มตัวเลขสองตัวหรือการดำเนินการ concatenate สตริง:

การคัดลอกรหัสมีดังนี้:

1+2 // => 3

"สวัสดี" + "" + "มี" // => "สวัสดีที่นั่น"

"1"+"2" // => "12"

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

หากตัวถูกดำเนินการเป็นวัตถุวัตถุจะเป็นไปตามกฎการแปลงของวัตถุเป็นค่าดั้งเดิมเป็นค่าคลาสดั้งเดิม (ดูบทที่ 3 ส่วนที่ 8, 3) วันที่ดำเนินการแปลงบนวิธีการ ToString () ของวัตถุในขณะที่วัตถุอื่น ๆ ทำการแปลงผ่านวิธีการ ValueOF () (ถ้าวิธีการ ValueOF () ส่งคืนค่าดั้งเดิม) เนื่องจากวัตถุส่วนใหญ่ไม่มีวิธีการที่มีอยู่ของ () พวกเขาจะใช้วิธี ToString () เพื่อทำการรวบรวมข้อมูล

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

มิฉะนั้นตัวถูกดำเนินการทั้งสองจะถูกแปลงเป็นตัวเลข (หรือ NAN) จากนั้นเพิ่ม

นี่คือตัวอย่างบางส่วน

การคัดลอกรหัสมีดังนี้:

1 + 2 // => 3 เพิ่มเติม

การเชื่อมต่อสตริง "1" + "2" // => "12"

ตัวเลข "1" + 2 // => "12" จะถูกแปลงเป็นสตริงและต่อกัน

1 + {} // => "1 [วัตถุวัตถุ]": วัตถุจะถูกแปลงเป็นสตริงแล้วทำการต่อสตริง

true + true // => 2 ค่าบูลีนถูกแปลงเป็นตัวเลขและเพิ่ม

2 + null // => 2 null แปลงเป็น 0 และทำเพิ่มเติม

2 + undefined // => nan ที่ไม่ได้กำหนดเปลี่ยนเป็น NAN สำหรับการเพิ่ม

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

การคัดลอกรหัสมีดังนี้:

1 + 2 + "bmice" // => "3 bmice"

1 + (2 + "bmice") => "12bmice"

ii. ผู้ดำเนินการ Unary

ผู้ประกอบการ Unary ทำหน้าที่แยกตัวถูกแยก และสร้างค่าใหม่ ใน JavaScript ผู้ประกอบการ Unary มีลำดับความสำคัญสูงและมีการรวมกันอย่างถูกต้อง ส่วนนี้อธิบายตัวดำเนินการ Unary (+,-, ++ และ-) และเมื่อจำเป็นพวกเขาจะแปลงการดำเนินการเป็นตัวเลข ควรสังเกตว่า + - เป็นตัวดำเนินการที่ไม่ได้รับและยังเป็นผู้ให้บริการไบนารี

เพิ่มหนึ่ง yuan+

ตัวดำเนินการเพิ่มเติม Unary จะแปลงหมายเลขตัวถูกดำเนินการเป็นตัวเลข (หรือ NAN) และส่งคืนหมายเลขที่แปลง หากตัวถูกดำเนินการเองเป็นตัวเลขตัวเลขจะถูกส่งกลับโดยตรง

การลบหนึ่งหยวน-

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

เพิ่มขึ้น ++

เพิ่มตัวดำเนินการ "++" เพื่อเพิ่ม (+1) ตัวถูกดำเนินการและตัวถูกดำเนินการเป็น lvalue (ตัวแปรองค์ประกอบอาร์เรย์หรือแอตทริบิวต์วัตถุ) ผู้ประกอบการแปลงตัวถูกดำเนินการเป็นตัวเลข จากนั้นเพิ่ม 1 ไปยังหมายเลขและกำหนดค่าใหม่หลังจากเพิ่ม 1 ลงในตัวแปรองค์ประกอบอาร์เรย์หรือแอตทริบิวต์วัตถุ

การดำเนินการเพิ่มขึ้น ++ ส่งคืนค่าขึ้นอยู่กับตำแหน่งของมันในตัวถูกดำเนินการ

เมื่อผู้ประกอบการอยู่ก่อนหมายเลขตัวถูกดำเนินการจะเรียกว่าตัวดำเนินการ "pre-increment" ซึ่งจะคำนวณตัวถูกดำเนินการเพิ่มขึ้นและส่งคืนค่าที่คำนวณได้

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

var i = 1, j = ++ i // ค่าของ i และ j คือทั้งสอง 2

var i = 1, j = i ++; // ฉันคือ 2, j คือ 1

ควรสังเกตว่าผลรวมของ ++ x = x+1 นั้นเหมือนกันทุกประการ ตัวดำเนินการ "++" ไม่เคยดำเนินการต่อการเชื่อมต่อสตริง มันจะแปลงตัวถูกดำเนินการเป็นตัวเลขและเพิ่มขึ้นโดย 1 ถ้า x เป็นสตริง "1" ผลลัพธ์ของ ++ x คือหมายเลข 2 และ x+1 คือสตริง "11"

การดำเนินการที่ลดลงและเพิ่มขึ้นจะเหมือนกันซึ่งแปลงตัวถูกดำเนินการเป็นอาร์เรย์แล้วลบด้วย 1

iii. บิตโอเปอเรเตอร์

ตัวดำเนินการบิตสามารถดำเนินการบิตระดับต่ำกว่าบนข้อมูลไบนารีที่แสดงด้วยตัวเลข แม้ว่าพวกเขาจะไม่ใช่การดำเนินการทางคณิตศาสตร์ที่บริสุทธิ์แบบดั้งเดิม ผู้ประกอบการเหล่านี้ไม่ได้พบได้ทั่วไปใน JavaScript (ไม่ได้อธิบายไว้ที่นี่โปรดใช้ Baidu สำหรับรายละเอียด ~-~)

9. การแสดงออกเชิงสัมพันธ์

ส่วนนี้อธิบายถึงตัวดำเนินการความสัมพันธ์ของ JavaScript ตัวดำเนินการเชิงสัมพันธ์ใช้เพื่อทดสอบความสัมพันธ์ระหว่างสองค่า (ความเท่าเทียมกันน้อยกว่าหรือ "แอตทริบิวต์") และส่งคืนจริงและเท็จตามความสัมพันธ์ที่มีอยู่ นิพจน์เชิงสัมพันธ์จะส่งคืนค่าบูลีนเสมอและมักจะใช้นิพจน์เชิงสัมพันธ์ใน IF ในขณะที่หรือสำหรับคำสั่ง (บทที่ 5) เพื่อควบคุมกระบวนการดำเนินการของโปรแกรม

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

ฉันเท่าเทียมกันและไม่เท่าเทียมกัน

ตัวดำเนินการ "==" และ "===" ใช้เพื่อเปรียบเทียบว่าค่าสองค่าเท่ากันและตัวดำเนินการทั้งสองอนุญาตให้ผู้ประกอบการทุกประเภท ส่งคืนจริงถ้าเท่ากันมิฉะนั้นจะกลับเท็จ "===" เรียกอีกอย่างว่าผู้ให้บริการความเท่าเทียมกันอย่างเข้มงวด (บางครั้งเรียกว่าผู้ดำเนินการตัวตน) ซึ่งใช้ในการตรวจสอบว่าตัวถูกดำเนินการสองตัวมีค่าเท่ากันอย่างเคร่งครัดหรือไม่ ตัวดำเนินการ "==" เรียกว่าตัวดำเนินการที่เท่าเทียมกัน มันถูกใช้เพื่อตรวจสอบว่าตัวถูกดำเนินการสองตัวเท่ากันหรือไม่ คำจำกัดความความเท่าเทียมกันที่นี่หลวมและอนุญาตให้แปลงประเภท

JavaScript รองรับผู้ประกอบการ "=", "==", "===" คุณควรเข้าใจความแตกต่างระหว่าง (การมอบหมายความเท่าเทียมกันตัวตน) ผู้ประกอบการ และระวังเมื่อเขียนโปรแกรม เพื่อลดความสับสน "=" "ควรเรียกว่า" รับหรือมอบหมาย "," == "" ควรเรียกว่า "เท่ากับ" และ "===" ควรเรียกว่า "เท่ากับอย่างเคร่งครัด"

กฎของ "! =" และ "! ==" ตัวดำเนินการคือ "==" ผกผันของ "===" ตัวดำเนินการและ "!" เป็นบูลีนที่ไม่ใช่ผู้ดำเนินการ เราเรียกว่า "! =", "! ==" ไม่เท่ากันและไม่เท่ากันอย่างเคร่งครัด

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

ตัวดำเนินการความเท่าเทียมกันอย่างเข้มงวด "===" แรกคำนวณค่าของตัวถูกดำเนินการจากนั้นเปรียบเทียบค่าทั้งสองนี้ ไม่มีการแปลงในกระบวนการเปรียบเทียบ

หากประเภทค่าทั้งสองไม่ต้องการเหมือนกันพวกเขาจะไม่เท่ากัน

หากค่าทั้งสองเป็นโมฆะหรือไม่ได้กำหนดจะไม่เท่ากัน

หากค่าทั้งสองเป็นบูลีนจริงหรือเท็จพวกเขาจะเท่ากัน

หากหนึ่งในค่าคือ NAN หรือทั้งสองอย่างเป็นน่านพวกเขาจะไม่เท่ากันและ NAN และค่าอื่น ๆ ไม่เท่ากันรวมถึงตัวมันเอง

หากสองค่าเป็นตัวเลขและเท่ากันพวกเขาจะเท่ากัน หากค่าคือ 0 และค่าคือ -0 พวกเขาก็เท่ากัน

หากค่าทั้งสองเป็นสตริงและตัวเลข 16 หลัก (ดูบทที่ 3, 2) ที่มีอยู่ในบิตที่สอดคล้องกันนั้นเท่ากันพวกเขาจะเท่ากัน หากความยาวหรือเนื้อหาแตกต่างกันพวกเขาจะไม่เท่ากัน สองสายอาจมีฟังก์ชั่นเดียวกันและอักขระที่แสดงนั้นเหมือนกัน แต่มีค่า 16 บิตที่ไม่ได้เข้ารหัส JavaScript ไม่ได้ทำการแปลงมาตรฐานบน Unicode ดังนั้นสตริงดังกล่าวจึงไม่เท่ากันเมื่อเปรียบเทียบกับตัวดำเนินการ "===" และ "==" string.localeCompare () ในส่วนที่สามให้อีกวิธีหนึ่งในการเปรียบเทียบสตริง

หากค่าอ้างอิงสองค่าชี้ไปที่วัตถุเดียวกันอาร์เรย์หรือฟังก์ชันจะเท่ากัน หากชี้ไปที่วัตถุที่แตกต่างกันพวกมันมีความไม่เท่าเทียมกันแม้ว่าวัตถุทั้งสองจะมีคุณสมบัติเหมือนกันทุกประการ

ตัวดำเนินการความเท่าเทียม "==" นั้นคล้ายกับตัวดำเนินการประจำตัว แต่ตัวดำเนินการความเท่าเทียมกันไม่ได้เปรียบเทียบอย่างเคร่งครัด หากตัวเลขสองตัวไม่ได้เป็นประเภทเดียวกันผู้ประกอบการความเท่าเทียมจะพยายามแปลงประเภทบางอย่างแล้วเปรียบเทียบ

หากการดำเนินการทั้งสองนั้นเหมือนกันกฎการเปรียบเทียบสำหรับตัวดำเนินการความเท่าเทียมด้านบนจะเหมือนกัน หากเท่ากันอย่างเคร่งครัดผลการเปรียบเทียบจะเท่ากัน หากพวกเขาไม่เท่ากันอย่างเคร่งครัดผลการเปรียบเทียบจะไม่เท่ากัน

หากการดำเนินการทั้งสองประเภทแตกต่างกันตัวดำเนินการ "==" ที่เท่าเทียมกันจะพิจารณาพวกเขาเท่ากัน การตรวจจับความเท่าเทียมจะเป็นไปตามกฎและการแปลงประเภทต่อไปนี้:

หากประเภทเป็นโมฆะและปล่อยให้คนอื่นไม่ได้กำหนดพวกเขาจะเท่ากัน

หากค่าหนึ่งเป็นตัวเลขและอีกค่าคือสตริงให้แปลงสตริงเป็นตัวเลขก่อนจากนั้นใช้ค่าที่แปลงสำหรับการเปรียบเทียบ

หากค่าเป็นจริงมันจะถูกแปลงเป็น 1 แล้วเปรียบเทียบ หากค่าเป็นเท็จมันจะถูกแปลงเป็น 0 และเปรียบเทียบ

หากค่าหนึ่งเป็นวัตถุและอีกค่าคือตัวเลขหรือสตริงให้ใช้กฎการแปลงของวิธีการในบทที่ 3 ส่วนที่ 8, 3 เพื่อแปลงวัตถุเป็นค่าดั้งเดิมแล้วเปรียบเทียบ วัตถุจะถูกแปลงเป็นค่าดั้งเดิมผ่านวิธี ToString () หรือวิธีการ valueof () คลาสในตัวในแกนกลางของภาษา JavaScript ก่อนพยายามใช้ ValueOf () จากนั้นลองใช้ TOSTRING () นอกเหนือจากคลาสวันที่แล้วคลาสวันที่สามารถแปลงผ่าน ToString () เท่านั้น วัตถุที่ไม่ได้อยู่ในแกนกลางของภาษาจาวาสคริปต์จะถูกแปลงเป็นค่าดั้งเดิมผ่านวิธีการที่กำหนดไว้ในการใช้งาน

การเปรียบเทียบระหว่างประเภทอื่นไม่เท่ากัน

นี่คือตัวอย่างเล็ก ๆ ของการตัดสินที่เท่าเทียมกัน

"1" == จริง

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

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

น้อยกว่า (<)

หากตัวถูกดำเนินการแรกมีขนาดเล็กกว่าตัวถูกดำเนินการที่สองผลการดำเนินการ "<" เป็นจริงมิฉะนั้นจะเป็นเท็จ

น้อยกว่าหรือเท่ากับ (<=)

มากกว่า (>)

มากกว่าหรือเท่ากับ (> =)

.... (ไม่มีการแนะนำรายละเอียดเกี่ยวกับความหมาย)

ตัวถูกดำเนินการของตัวดำเนินการเปรียบเทียบอาจเป็นประเภทใดก็ได้ อย่างไรก็ตามมีเพียงตัวเลขและสตริงเท่านั้นที่สามารถดำเนินการเปรียบเทียบตัวดำเนินการได้ดังนั้นตัวถูกดำเนินการที่ไม่ใช่ตัวเลขและสตริงจะถูกแปลงประเภท กฎการแปลงประเภทมีดังนี้:

หากตัวถูกดำเนินการเป็นวัตถุมันจะถูกแปลงเป็นค่าดั้งเดิมตามกฎการแปลงที่อธิบายไว้ในส่วนที่ 3 ส่วนที่ 8, 3: ถ้าค่า () ส่งคืนค่าดั้งเดิมให้ใช้ค่าดั้งเดิมนี้โดยตรง มิฉะนั้นให้ใช้ผลลัพธ์การแปลงของ toString () สำหรับการเปรียบเทียบ

หลังจากแปลงเป็นค่าดั้งเดิมหากตัวถูกดำเนินการทั้งสองเป็นสตริงแล้วทั้งสองสตริงจะถูกนำมาเปรียบเทียบตามลำดับของตัวอักษร "ลำดับตัวอักษร" ที่กล่าวถึงที่นี่คือลำดับดัชนีของอักขระ Unicode 16 บิตที่ประกอบขึ้นเป็นสองสาย

หลังจากวัตถุถูกแปลงเป็นค่าดั้งเดิมถ้าอย่างน้อยหนึ่งตัวถูกดำเนินการไม่ใช่สตริงตัวถูกดำเนินการทั้งสองจะเปรียบเทียบค่าของตัวเลข 0 และ -0 เท่ากัน จำนวนอื่น ๆ ในผนังไม่อินมีขนาดใหญ่ (ยกเว้น Infinty เอง) -infinty มีขนาดเล็กกว่าจำนวนใด ๆ (ยกเว้นตัวเอง) หากตัวถูกดำเนินการ (หรือแปลง) เป็น NAN อักขระการเปรียบเทียบจะส่งกลับเท็จเสมอ

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

การคัดลอกรหัสมีดังนี้:

1 + 2 // => 3 นอกจากนี้ผลลัพธ์คือ 3

"1" + "2" // เชื่อมต่อสตริงผลลัพธ์คือ "12"

"1" + 2 // เชื่อมต่อสตริง 2 ถูกแปลงเป็น "2" ผลลัพธ์คือ "12"

11 <3 // การเปรียบเทียบตัวเลขผลลัพธ์เป็นจริง

"11" <"3" // การเปรียบเทียบยืนผลลัพธ์เป็นจริง

"11" <3 // การเปรียบเทียบตัวเลข "11" ถูกแปลงเป็น 11 และผลลัพธ์เป็นจริง

"One" <3 // การเปรียบเทียบหมายเลข "หนึ่ง" ถูกแปลงเป็น NAN และผลลัพธ์เป็นเท็จ

ในที่สุดก็ควรสังเกตว่าเมื่อตัดสินความเท่าเทียมกันตัวดำเนินการ "<=" และ "> =" ผู้ดำเนินการไม่พึ่งพาตัวดำเนินการความเท่าเทียมและกฎการเปรียบเทียบความเท่าเทียมกันอย่างเข้มงวด ในทางตรงกันข้ามผู้ประกอบการจีที่น้อยกว่าหรือเท่ากับเป็นเพียง "ไม่เกิน" ในขณะที่การดำเนินการที่มากกว่าหรือเท่ากับเป็นเพียง "ไม่น้อยกว่า" ด้วยข้อยกเว้นเพียงข้อเดียวเมื่อตัวถูกดำเนินการ (หลังจากแปลง) เป็น NAN ผู้ให้บริการเปรียบเทียบทั้ง 4 ตัวจะส่งคืน Fasle

III.in ผู้ประกอบการ

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

การคัดลอกรหัสมีดังนี้:

var point = {

x: 1,

y: 1

} // กำหนดวัตถุ

"x" ในจุด // => จริงวัตถุมีคุณสมบัติชื่อ x

"z" ในจุด // => เท็จวัตถุไม่มีแอตทริบิวต์ z ชื่อ

"ToString" ในจุด // => วัตถุที่แท้จริงสืบทอดวิธีการ toString

var data = [7, 8, 8]

"0" ในข้อมูล // => จริงอาร์เรย์มี 0

1 ในข้อมูล // => หมายเลขแปลงจริงเป็นสตริง

3 ใน data // => fase ไม่มีองค์ประกอบที่มีดัชนี 3

iiii.instanceof ผู้ประกอบการ

ผู้ประกอบการอินสแตนซ์ต้องการให้ตัวดำเนินการด้านซ้ายเป็นวัตถุและตัวถูกดำเนินการด้านขวาระบุคลาสของวัตถุ หากวัตถุทางด้านซ้ายเป็นอินสแตนซ์ของคลาสทางด้านขวานิพจน์จะกลับมาเป็นจริง มันรับผิดชอบในการคืนค่าเท็จ บทที่ 9 จะพูดถึงเรื่องนี้ คลาสของวัตถุ JavaScript ถูกกำหนดโดยการเริ่มต้นตัวสร้าง ด้วยวิธีนี้ตัวถูกดำเนินการที่ถูกต้องของอินสแตนซ์ของอินสแตนซ์ควรเป็นฟังก์ชั่น ตัวอย่างเช่น:

การคัดลอกรหัสมีดังนี้:

var d = วันที่ใหม่ (); // สร้างวัตถุใหม่

d อินสแตนซ์ของวันที่; // ผลลัพธ์ของการคำนวณเป็นจริง d ถูกสร้างขึ้นตามวันที่ ()

d instanceof Object //计算结果为true ,所有的对象都是Object的实例

d instanceof Number //计算结果为false，d不是一个Number对象

var a = [1,2,3] //数组直接量创建数组

a instanceof Array //计算结果true a为数组

a instanceof Object //true 所有的数组都是对象

a instanceof RegExp //fasle 数组不是正则表达式

需要注意的是，所有对象都是Object的实例。当通过instanceof盘对一个对象是否为一个类的实例的时候，这个判断也叫“父类”(superclass)的检测，如果instanceof的左侧操作对象不是对象的话，instanceof返回false。如果右侧操作不是函数，则抛出类型错误的异常。

为了理解instanceof运算符是如何工作的，必须首先理解“原型类”（prototype chain），原型链作为javascript的继承机制，将在6章2节2小节详细描述。

为了计算表达式o instanceof f ,javascript笔仙首先计算f.prototyoe,然后在原型链中查询o,如果找到，那么o是f（或者f的父类）的一个实例，那么返回true。反之false

10.逻辑表达式

逻辑运算符"&&"、“||”、“!”是对操作进行布尔算术运算，经常和关系运算符一起配合使用，逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。

ฉัน. Logic and

"&&"运算符可以从三个不同的层次进行理解。最简单一层理解是，当操作数都是布尔值是，“&&”对两个布尔值执行布尔与（AND）操作，只有在第一个操作数和第二个操作数都是true的时候，它才返回true.如果其中有一个操作数为false.则它返回false.

"&&"长用来连接两个关系表达式

x == 0 && y == 0; //只有在x和y都是0时，才返回true

关系表达式总是返回true或false,因此当这样使用的时候，“&&”本身也返回true或false。关系运算符的优先级要比"&&"（和“||”）要高，因此类似这种表达式可以放心地书写，而不用补充园括号。

"&&"操作数并不一定是布尔值，回想一下，有些值是可以当做“真值”和“假值”的。（如3章3节，假值是:false null undefined 0 -0 NaN和""，所有和其它的值包括所有的对象都是真值）。对“&&”第二层理解是，“&&”是可以对真值和假值进行布尔与（AND）操作。如果两个操作数都是真值的，则那么返回一个真值；否则，至少一个操作数是假值的。javascript中在任何使用布尔值的地方的时候，表达式语句都会将其当做真值或假值来对待，因此实际上“&&”并不总是返回true和false.但也并无大碍。

需要注意的是，上文提到了运算符返回“真值”和“假值”，但并没说说明这个“真值”或者“假值”到底是什么值，为此我们深入讨论对“&&”第三层的理解。运算符首先计算左操作数的值，即首先计算“&&”左侧的表达式，如果计算结果是假值，那么整个表达式的结果一定是假值，因此“&&”这时简单的返回左操作的值，而并不会对右边的操作数进行计算。

การคัดลอกรหัสมีดังนี้:

var o = {

x: 1

-

var p = null;

o && ox; //=>1 : 1:0是真值，因此返回值是ox

p && px //= null :p是假值，因此将其返回，而并不计算px

这对于理解“&&”可能不计算右操作数的情况至关重要，在上述代码中，变量P的值是null，而如果计算px的话则会抛出一个异常错误，因此，只有p为真值（不能是null或undefined）的情况下才计算px

"&&"的行为有时候被称为“短路”（short circuiting）,我们经常能看到很多代码利用了这一也行来有条件的执行代码。例如下面的两条代码是等价的

การคัดลอกรหัสมีดังนี้:

if (a == b) stop(); //只有a==b时才能调运stop()

(a == b) && stop(); //同上

一般来讲，当“&&”右侧的表达式具有副作用的时候（赋值，递增，递减和函数调用表达式）要格外小心。因为这些带有副作用的表达式的执行时候，依赖于左操作鼠的计算结果。

尽管“&&”可以按照第二层和第三层的理解进行一些复杂的表达式运算，但大多数的情况下，“&&”仅用来对真值和假值的做布尔计算。

ii. Logical or (||)

"||"运算符对两个操作数做布尔或（OR）运算。如果其中一个为真值，则返回真值，两个操作数都为假值，返回假值。

尽管“||”运算符大多情况下只是做简单的布尔或（OR）运算，和“&&”一样，也具备一些更复杂的行为，它首先计算第一个操作数的值，也就是说回首先计算左侧的表达式，如果计算结果为真，则返回真值，否则，再计算第二个值。

和“&&”一样，用于应该避免右操作数包含一些具有副作用的表达式，除非你目地明确在右侧使用带副作用的表达式，而有可能不会计算右侧的表达式。

这个运算符最常用的方式是用来从一组备选的表达中选取第一个真值的表达式。

การคัดลอกรหัสมีดังนี้:

//如果max_width已经定义了，则直接使用它。赋值在preferences对象中查找max_width

//如果没有定义它，则使用一个写死的常量。

var max =max_width || preferences.max_windth || 500;

这种贯用法通常在函数体内，用来给参数提供默认值。

การคัดลอกรหัสมีดังนี้:

//将o成功的属性复制到p中，并返回p

function copy(o, p) {

p = p || - //If no object is passed into the parameter p, a newly created object is used.

//函数体内的主逻辑

iii.逻辑非(!)

"!"运算符是一元运算符，它放置在一个单独操作数之前。它的目的是将操作数的布尔值求反。

和"&&"、"||"运算符不同，“!”运算符首先将其操作数转换为布尔值（参考第三章的讲诉规则），然后再对布尔值求反。也就是"!"总是返回true和false。并且，可以通过使用两次逻辑非运算来得到一个值的布尔值：(!!x,参照第三章第八节第2小节)

- has a high priority and is closely tied to the operand. If you want to use p && q, you need to bracket! (p && q). The following code:

การคัดลอกรหัสมีดังนี้:

!(p && q) === !p || !q

!(p || q) === !p && !q

对于p和q取任何值，这两个表达式永远成立。

11.赋值表达式

javascript使用"="运算符给变量或者属性来赋值，例如：

การคัดลอกรหัสมีดังนี้:

i = 0 //将变量i设置为0

ox = 1 //将对象o的属性x 设置为1

“=”运算符希望它的左操作数为一个左值：一个变量或者对象属性（或数组元素），它的右操作鼠可以是任意的类型的任意值。赋值表达式的值就是右操作数的值。赋值表达式的副作用是，右操作数的值赋值给左侧的变量或对象属性。这样的话，后续对这个变量和对象的属性的引用都将得到这个值。

尽管赋值表达式的值非常简单，但有时候会看到一些复杂表达式包含赋值表达式的情况。例如：将赋值和检测操作放在一个表达式中：

การคัดลอกรหัสมีดังนี้:

(a = b) == 0

如果这样的话，应该清楚地知道"="和"=="区别！，需要注意的是，“=”有非常低的优先级，通常在一个较长的表达式中用到一条赋值语句时，需要补充园括号以保障正确的运算顺序。

赋值操作符的结合性是从右至左，也就是说，一个表达式中出现了多个赋值运算符，运算顺序也从右至左，因此，可以通过以下方式对多个变量赋值。

การคัดลอกรหัสมีดังนี้:

i=j=k=0; //把三个变量初始化为0

带操作的赋值运算：

除了常规的赋值运算外，javascript还支持需要其他的赋值运算符，这些运算符将赋值运算符合其他的运算符连接起来。提供一种更为快捷的运算方式。例如+=运算符执行的是加法运算符和赋值操作，下面的表达式：

total += salaes_tax;

和下面的表达式等价的

total = total + salaes_tax

运算符“+=”可以作用于数字或字符串，如果其操作是数字，它将执行加法运算和赋值操作；如果是字符串，他就执行字符串的连接和赋值操作。

此类型的运算符还包括，"-=","*=","&="等，如下表赋值运算符

运算符示例等价于

+=a+=ba=a+b

-=a-=ba=ab

*=a*=ba=a*b

/=a/=ba=a/b

%=a%=ba=a%b

<<=a<<=ba=a<<b

>>=a>>=ba=a>>b

>>>=a>>>=ba=a>>>b

&=a&=ba=a&b

|=a|=ba=a|b

^=a^=ba=a^b

大多数情况下，表达式为

a op =b

这里的op代表一个运算符，这个表达式等价于

a =a op b

在第一行中，表达式a计算了一次，在第二行中，表达式a计算了两次。

只有a包含具有副作用的表达式（比如函数调用和赋值操作）的时候，两者才不等价。如下两个表达式不等价

การคัดลอกรหัสมีดังนี้:

data[i++] *= 2;

data[i++] = data[i++] * 2

12.表达式计算

和很多解释性语言一样，javascript同样可以解释运行由javascript源代码组成的字符串，并产生一个值。javascript通过全局函数eval()来完成这个工作。

eval("3+2") //=>5

动态判断源代码中的字符串是一种强大语言的特性，几乎没有必要在实际中应用。如果你使用了eval()，你应该仔细考虑真的需要它。

下面降价eval()基础用法，并介绍两种严格使用它的方法，从代码优化的角度来讲，这两种方法对原有的代码影响是最小的。

i.eval （eval()是一个函数，但由于它已经被当做运算符来对待了。）

eval()只有一个参数，如果传入的参数不是字符串，它直接返回这个参数。如果参数是字符串，它会把字符串当成javascript进行编译(parse)，如果编译失败则抛出一个语法错误(SyntaxError)。如果编译成功，则开始执行这段代码，并返回字符串中最后一个表达式或语句的值，如果最后一个表达式没有语句或者值，则最终返回undefined。如果字符串抛出一个异常，这个异常把该调用的传给eval()

关于eveal()最重要的是，它使用了调用它的变量作用域环境，也就是说，它查找变量的值和定义新变量和函数的操作和局部的代码作用域中的代码一样。如果一个函数定义了一个局部变量x,然后调用了eval("x"),它会返回局部变量的值。如果它调用eval("x=1"),它会改变局部变量的值。如果函数调用了eval("var y=3;")它声明一个新的局部变量y。同样的，一个函数可以通过如下代码声明一个局部函数：

eval("function f(){return x+1;}");

如果最顶层的代码中调用了eval()。当然它会作用于全局变量和全局函数。

ii. Global eval()

eval()具有改变局部变量的能力，这对javascript优化器来说，是一个很大的问题，然而作为一种权宜之计，javascript征对那行调用了eval()函数所做的优化并不多。但当脚本定义了一个别名，并且用令一个名称来调用它，javascript解释器又如何工作呢，为了javascript解释器更加简化。ECMAScipt3标准规定了任何解释器都不允许对eval()赋予别名。如果eval()使用别的别名来调用的话，则会抛出EvalError异常。

实际上，大多数的实现并不是这样做的。当通过别名调用时，eval()会将其字符串当成顶层的全局代码来执行。执行代码可能会定义新的全局变量和全局函数。执行的代码可能会定义新的全局变量和全局函数，或者给全局变量赋值。但却不能修改或修改主调函数中的局部变量，因此这不会影响到函数内的代码优化。

ECMAScript5是反对使用EvalError的，并且规范了eval()的行为。“直接的eval”，当直接使用非限定的“eval”名称，来调用eval()函数时，它总共是在它的上下文作用域内支线。其它间接调用则使用全局函数为其上下文作用域。并且无法读、写、定义局部变量和函数。下面有一段代码实例：

การคัดลอกรหัสมีดังนี้:

var geval = eval; //使用别名调用eval将是全局eval

var x = "global",

y = "global"; //两个全局变量

function f() { //函数内执行的局部eval

var x = "local" //定于局部变量

eval("x += 'changed';"); //直接eval更改了局部变量的

return x; //返回更改后的局部变量

-

function g() { //这个函数执行了全局eval

var y = "local" //定义了局部变量

geval("y += 'changed';"); //间接改变了局部变量的值

return y; //返回未更改的局部变量

-

console.log(f(), x); //更改了局部变量，输出local changed global

console.log(g(), y); //更改了全局变量，输出local globalchanged

13.其它运算符。

javascript支持很多其它各种各样的运算符。

ฉัน. Conditional operator (?:)

The conditional operator is the only ternary operator in javascript. Usually this operator is written as "?:". This operator has the third operand, the first operand is before "?", and the second operand is between "?" และ ":". The third operand is long after ":", e.g.

x > 0 ? x : -x; //求x的绝对值

条件运算符的操作数可以是任意类型。第一个操作数当成布尔值，如果它是真值，那么将计算第二个操作数，并返回计算结果。赋值如果第一个值操作数是假值，那么将计算第三个操作数。并返回计算结果。第二个和第三个操作数总会计算其中之一。不可能两者同时进行。其实使用if语句也达到同样的效果(5.4.1),“?:”运算符只是提供了一种简写形式。这里是一个"?:"的典型使用场景，判断一个变量是否有定义，如果有定义则使用它，如果无定义，则使用一个默认值。

การคัดลอกรหัสมีดังนี้:

grett = "hello" + (username ? username : "three");

和以下的代码是等价的，但上面的更加简洁

การคัดลอกรหัสมีดังนี้:

grett = "hello";

if (username)

grett += username;

อื่น

grett + "three"

ii.typeof()运算符

typeof是一元运算符，放在单个操作数前面，操作数可以是任何类型，返回值表示操作类型的一个字符串。

การคัดลอกรหัสมีดังนี้:

x __ typeof x

undefined __ "undefined"

null __ "object"

ture或false __"boolean"

任意数字或NaN __ "Number"

任意字符串__ "String"

任意函数__ "function"

任意内容对象（非函数）__ "object"

任意宿主对象__ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"

typeof最常用的用法写在表达式中们就像这样

(typeof value == "string") ? "" + value + "":value;

typeof运算符同样在swith语句中（5.4.3）非常有用，需要注意的是，typeof运算可以带上园括号。这样让typeof看起来像一个函数名，而非关键字

typeof(i)

iii.delete运算符

delete是一元操作符，它用来删除对象的属性或者数组的元素。就像赋值、递增、递减运算符一样。delete也是具有副作用的。它是用来做删除操作的。不是用来返回一个值的。

การคัดลอกรหัสมีดังนี้:

var o = {

x: 1,

y: 2

-

delete ox;

"x" in o; //=>false

var a = [1, 2, 3];

delete a[2]; // 删除数组中最后一个元素

2 in a; //=> false 元素2已经在数组中不存在了

a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3

需要注意的是，删除属性或删除数组元素不仅仅设置了一个undefined值，当删除一个属性时，这个属性不复存在。读取一个不存在的值将会返回undefined.关于delete删除还有严格模式下的一些情况，需要学习的人自己试验，这里给一些例子。

การคัดลอกรหัสมีดังนี้:

var o = {x: 1,y: 2};

delete ox; //删除一个对象属性，返回true

typeof ox; //属性不存在，返回"undefined"

delete ox; //删除不存在的属性，返回true;

delete o; //不能删除通过var关键字声明的变量，返回false

delete 1; //参数不是一个左值。

this.x = 1;// 给全局定义一个属性，这里没有使用var

delete x ; //试图删除它，在非严格模式下返回true

//在严格模式下回抛出异常，这时使用"delete this.x"来代替

x; //运行时出错，没有定义x

6章第三节还有关于delete的讨论。

iii.void运算符。

void是一元运算符，在出现操作数之前，操作数可以是任何类型。这个运算符并不是经常使用：操作数会照常计算，但会忽略计算结果并返回undefined。由于void会忽略操作数的值，因此在操作数具有副作用时使用void来程序更有意义。

这个最常用的带客户端url.在url写带有副作用的表达式，而void则让浏览器不显示在这个表达式的运算结果。

การคัดลอกรหัสมีดังนี้:

<a href="javascript:void window.open();">new</a>

iiii.comma operator. -

逗号运算符是二元运算符，它的操作数可以是任意类型。它首先计算左操作数，然后计算右操作数。

การคัดลอกรหัสมีดังนี้:

i = 0, j = 1, k = 2;

它和下面的代码基本上等价的

i = 0; j = 1; k = 2;

总是会计算左侧的表达式，但计算结果忽略掉，也就是说，只有左侧表达式具有副作用，才会使用逗号运算让代码变得更通畅。逗号运算符最常用的场景是for循环中，这个for循环通常有多个循环变量。

การคัดลอกรหัสมีดังนี้:

//for循环中的第一个逗号是var语句的一部分

//第二个逗号是逗号运算符

//它将两个表达式(i++和j++)放在一条(for循环中)语句中

for (var i = 0, j = 10; i < j; i++, j--);

console.log(i + j);