แนะนำ, 2022

ตัวเลือกของบรรณาธิการ

ความแตกต่างระหว่าง & และ &&

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

แผนภูมิเปรียบเทียบ

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

คำจำกัดความของ & (Bitwise AND)

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

ให้เราเข้าใจสิ่งนี้ด้วยตัวอย่าง

 int a = 4, b = 5; system.out.println ((a == 6) & (b ++ == 6)); system.out.println ("b =" + b); // output false b = 5 

ที่นี่ในการประเมินด้านซ้ายของนิพจน์ (a == 6) จะส่งผลให้เป็นเท็จจากนั้นผู้ประกอบการ & ประเมินด้านขวาของการแสดงออก (b ++ == 6) เป็นผลให้ค่าของการเพิ่มขึ้นข

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

ให้เราเห็นการทำงานระดับบิตของ & โอเปอเรเตอร์

 int a; a = 3 & 4; // 011 & 100 = 000 system.out.println ("a =" + a); // เอาท์พุท a = 0 

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

คำจำกัดความของ && (ลัดวงจรและ)

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

ให้เราเข้าใจการทำงานของผู้ประกอบการ && ด้วยตัวอย่าง

 int a = 4, b = 5; system.out.println ((a == 6) && (b ++ == 6)); system.out.println ("b =" + b); // output false b = 4 

นี่คือเงื่อนไข (a == 6) เป็นเท็จผู้ประกอบการ && ไม่ได้ประเมินการแสดงออก (b ++ == 6) ดังนั้นผลลัพธ์ของค่า b จะไม่เพิ่มขึ้น

ความแตกต่างที่สำคัญระหว่าง & และ &&

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

บันทึก:

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

สรุป:

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

Top