ตัวดำเนินการ JavaScript:การเปรียบเทียบและความเท่าเทียมกัน

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

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

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

1. ใน – ใช้ ใน โอเปอเรเตอร์เพื่อดูว่ามีคุณสมบัติในวัตถุของคุณหรือไม่:

const cityData =  {
     city: "San Jose",
     state: "California",
     area: 181.36,
     land: 178.24,
     water: 3.12,
     urban: 342.27,
     metro: 2694.61,
     elevation: 82,
     population: 1021795,
     timezone: "Los_Angeles/Pacific",
     website: "www.sanjoseca.gov"
}
console.log("metro" in cityData); //true
console.log("country" in cityData); //false

1. ตัวอย่าง – ใช้ อินสแตนซ์ของ โอเปอเรเตอร์เพื่อถามว่าอ็อบเจกต์เป็นอินสแตนซ์ของคลาสหรือฟังก์ชันคอนสตรัคเตอร์หรือไม่

  function Class(subject, teacher, numStudents) {
     this.subject = subject;
     this.teacher = teacher;
     this.numStudents = numStudents;
   }
   const classroom = new Class('Academic Geometry', 'Jane Doe', 24);
 
   console.log(classroom instanceof Class);
   // expected output: true
 
   console.log(classroom instanceof Object);
   // expected output: true

1. น้อยกว่า ( <), น้อยกว่าหรือเท่ากับ ( <=) – ตัวดำเนินการเปรียบเทียบที่คืนค่าจริงในคำสั่งแบบมีเงื่อนไขหากตัวถูกดำเนินการ A น้อยกว่าตัวถูกดำเนินการ B เราเห็นได้บ่อยที่สุดเมื่อเราสร้าง for ลูป:

 	for(let i = 1; i <= n; i++) {
        // code here
    	}
	for(let i = 0; i < arr.length; i++) {
        // code here
   	}

1. มากกว่า (> ), มากกว่าหรือเท่ากับ (>=) – ตัวดำเนินการเปรียบเทียบที่คืนค่า true ในคำสั่งแบบมีเงื่อนไขหากตัวถูกดำเนินการ A มากกว่าตัวถูกดำเนินการ B ซึ่งมักใช้เมื่อเราพยายามค้นหาจำนวนสูงสุดในอาร์เรย์:

let maximum = -Infinity;
   	for(let i = 0; i < arr.length; i++) {
     	  if(arr[i] >= maximum) {
          maximum = arr[i];
        }
      }

หมายเหตุ: >=ไม่เหมือน => ส่วนหลังใช้สำหรับฟังก์ชันลูกศรขนาดใหญ่ในไวยากรณ์ ES6 JavaScript

ตัวดำเนินการความเท่าเทียม

เช่นเดียวกับตัวดำเนินการเปรียบเทียบ ตัวดำเนินการความเท่าเทียมกันยังประเมินเป็นค่าบูลีนที่ประกาศว่านิพจน์เป็นจริงหรือไม่

ความเท่าเทียมกัน ( ==) เทียบกับ เอกลักษณ์ ( ===) – เมื่อเราเห็นเครื่องหมายเท่ากับ ( =) ใน JavaScript เครื่องหมายเท่ากับหนึ่งตัวเป็นตัวดำเนินการมอบหมาย ไม่ใช่สิ่งที่เราคุ้นเคยเมื่อเราอยู่ในชั้นเรียนคณิตศาสตร์

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

console.log(8 == '8'); //true

ในทำนองเดียวกัน หากเราเห็นปัง/เครื่องหมายอัศเจรีย์พร้อมกับเครื่องหมายเท่ากับหนึ่ง ( !=) เรียกว่าตัวดำเนินการอสมการจะเปรียบเทียบค่าสองค่าเพื่อดูว่าตัวถูกดำเนินการมีจำนวนไม่เท่ากันหรือไม่ ไม่ตรวจสอบประเภท

console.log(8 != '4'); //true

ในทางกลับกัน ตัวดำเนินการเอกลักษณ์สามเครื่องหมายเท่ากับ ( ===) , ตรวจสอบประเภทและตัวเลขเมื่อเปรียบเทียบทั้งสองค่า

81% ของผู้เข้าร่วมกล่าวว่าพวกเขารู้สึกมั่นใจมากขึ้นเกี่ยวกับโอกาสในการทำงานด้านเทคโนโลยีหลังจากเข้าร่วม bootcamp จับคู่กับ Bootcamp วันนี้

ผู้สำเร็จการศึกษาจากหลักสูตร bootcamp โดยเฉลี่ยใช้เวลาน้อยกว่าหกเดือนในการเปลี่ยนอาชีพ ตั้งแต่เริ่มต้น bootcamp ไปจนถึงหางานแรก

console.log(8 === '8'); //false
console.log(8 === 8); //true

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

console.log(8 !== '8'); //true
console.log(8 !== 8); //false

ความคิดสุดท้าย

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

พร้อมสำหรับบทช่วยสอนเพิ่มเติมเกี่ยวกับ JavaScript หรือไม่

ตรวจสอบสิ่งเหล่านี้!

JavaScript Ternary Operator:คำแนะนำทีละขั้นตอน

JavaScript Switch Case:คำแนะนำทีละขั้นตอน

JavaScript Syntax:A Guide for Beginners