ผมเองชอบแต่เพียงผู้เดียวหรือ , ^ผู้ประกอบการเมื่อมันทำให้ความรู้สึกในบริบทของการตรวจสอบแบบบูลเพราะความกระชับของตน ฉันชอบเขียนมาก
if (boolean1 ^ boolean2)
{
//do it
}
กว่า
if((boolean1 && !boolean2) || (boolean2 && !boolean1))
{
//do it
}
แต่บ่อยครั้งที่ฉันรู้สึกสับสนจากนักพัฒนา Java คนอื่น (ไม่ใช่เฉพาะมือใหม่) และบางครั้งก็แสดงความคิดเห็นว่าควรใช้สำหรับการทำงานระดับบิตได้อย่างไร
ฉันอยากรู้วิธีปฏิบัติที่ดีที่สุดเกี่ยวกับการใช้งานของ^ผู้ให้บริการ
คำตอบ:
คุณสามารถใช้!=แทน
!=ผลลัพธ์ที่ถูกต้องสำหรับbooleans (แต่ไม่ใช่Booleans ดังนั้นโปรดระวัง) มันไม่ได้สวยเสมอไปตัวอย่างเช่น (some != null) != (other != null)อ่านไม่ได้ คุณอาจจะต้องแยกส่วนต่าง ๆ ใน booleans ชัดเจนหรือแยก!=ในวิธีแยกต่างหาก
a ^ b=> "a หรือ b แต่ไม่ใช่ทั้งสอง", a != b=> "a ไม่เท่ากับ b" (@RobertGrant พูดอะไร) มนุษย์ส่วนใหญ่จะเข้าใจคนแรกได้ง่ายขึ้นถ้าพวกเขารู้ว่า xor คืออะไร (ซึ่งค่อนข้างมีประโยชน์ที่จะรู้ว่าคุณอยู่ในสาขาการคำนวณ ... )
a != b=> "a ไม่ใช่ตัวบ่งชี้ถึง b"
ฉันคิดว่าคุณตอบคำถามของคุณเอง - ถ้าคุณได้รับรูปลักษณ์ที่แปลกประหลาดจากผู้คนมันอาจจะปลอดภัยกว่าถ้ามีตัวเลือกที่ชัดเจนกว่านี้
หากคุณต้องการแสดงความคิดเห็นแสดงว่าคุณน่าจะดีกว่าที่จะแทนที่ด้วยรุ่น verbose ที่มากขึ้นและไม่ทำให้ผู้คนถามคำถามตั้งแต่แรก
(boolean1 && !boolean2) || (boolean2 && !boolean1)โค้ดแอปพลิเคชันในชีวิตจริงอย่างจริงจัง...
ฉันพบว่าฉันมีการสนทนาที่คล้ายกันมาก ในอีกด้านหนึ่งคุณมีวิธีการที่กะทัดรัดและมีประสิทธิภาพในการบรรลุเป้าหมายของคุณ ในทางกลับกันคุณมีบางอย่างที่คนอื่น ๆ ในทีมอาจไม่เข้าใจทำให้ยากที่จะดูแลในอนาคต
กฎทั่วไปของฉันคือการถามว่าเทคนิคการใช้เป็นสิ่งที่เหมาะสมที่จะคาดหวังโปรแกรมเมอร์โดยทั่วไปที่จะรู้ ในกรณีนี้ฉันคิดว่ามันสมเหตุสมผลที่จะคาดหวังว่าโปรแกรมเมอร์จะรู้วิธีใช้ตัวดำเนินการบูลีนดังนั้นการใช้ xor ในคำสั่ง if จะไม่เป็นไร
เป็นตัวอย่างของสิ่งที่ไม่เป็นไรใช้เคล็ดลับในการใช้ xor เพื่อสลับสองตัวแปรโดยไม่ต้องใช้ตัวแปรชั่วคราว นั่นเป็นกลลวงที่ฉันไม่คาดหวังให้ทุกคนคุ้นเคยดังนั้นมันจะไม่ผ่านการตรวจสอบโค้ด
// ^ == XORผมคิดว่ามันจะโอเคถ้าคุณแสดงความคิดเห็นมันเช่น
คุณสามารถห่อมันในฟังก์ชั่นเพื่อตั้งชื่อให้ละเอียด:
public static boolean XOR(boolean A, boolean B) {
return A ^ B;
}แต่สำหรับฉันแล้วดูเหมือนว่ามันจะไม่เป็นเรื่องยากสำหรับคนที่ไม่รู้ว่าตัวดำเนินการ ^ สำหรับ Google นั้นรวดเร็วเพียงใด มันจะไม่ยากที่จะจำหลังจากครั้งแรก เมื่อคุณถามถึงการใช้งานอื่น ๆ มันเป็นเรื่องปกติที่จะใช้ XOR สำหรับการปิดบังบิต
นอกจากนี้คุณยังสามารถใช้แฮคเกอร์ที่จะแลกเปลี่ยนค่าในตัวแปรทั้งสองโดยไม่ต้องใช้ตัวแปรชั่วคราวที่สาม
// Swap the values in A and B
A ^= B;
B ^= A;
A ^= B;นี่เป็นคำถาม Stackoverflow ที่เกี่ยวข้องกับการแฮคเกอร์แลกเปลี่ยน
ฉันเพิ่งใช้ xor ในโครงการ JavaScript ในที่ทำงานและจบลงด้วยการเพิ่มความคิดเห็น 7 บรรทัดเพื่ออธิบายสิ่งที่เกิดขึ้น เหตุผลสำหรับการใช้ xor ในบริบทที่เป็นหนึ่งในแง่ที่ว่า ( term1ในตัวอย่างด้านล่าง) จะใช้เวลาในการไม่ได้ แต่สองสามค่า: undefined, trueหรือfalseขณะที่อื่น ๆ ( term2) อาจจะเป็นหรือtrue falseฉันจะต้องเพิ่มการตรวจสอบเพิ่มเติมสำหรับundefinedกรณี แต่ด้วย xor ต่อไปนี้ก็เพียงพอเนื่องจาก xor บังคับให้คำแรกที่จะได้รับการประเมินครั้งแรกเป็นบูลีนให้undefinedได้รับการปฏิบัติfalseดังนี้:
if (term1 ^ term2) { ...ในที่สุดมันก็เกินความเป็นไปได้นิดหน่อย แต่ฉันก็อยากจะเก็บมันไว้ในนั้นเหมือนเป็นไข่อีสเตอร์
bool? aค่าสามารถทดสอบอย่างชัดเจนสำหรับการใช้งานจริงa == true- มีเทคนิคที่คล้ายกันใน java หรือไม่ ใน C #, รับสองbool?ค่า "null รักษาเป็นเท็จ" (a == true) ^ (b == true)จะนำไปสู่ (a == true) != (b == true)สูตรเทียบเท่า คุณสามารถทำสิ่งที่คล้ายกันใน java?
if((boolean1 && !boolean2) || (boolean2 && !boolean1))
{
//do it
} IMHO รหัสนี้สามารถลดความซับซ้อน:
if(boolean1 != boolean2)
{
//do it
} ด้วยความชัดเจนของรหัสในความคิดของฉันคือการใช้ XOR ในการตรวจสอบบูลีนไม่ใช่การใช้งานทั่วไปสำหรับผู้ดำเนินการ XOR ในระดับบิต จากประสบการณ์ของฉัน bitwise XOR ใน Java โดยทั่วไปจะใช้ในการใช้งานรูปแบบflag toggleการทำงานของหน้ากาก:
flags = flags ^ MASK;นี้บทความโดย Vipan Singla อธิบายกรณีการใช้งานมากขึ้นในรายละเอียด
หากคุณจำเป็นต้องใช้บิต XOR ในตัวอย่างของคุณแสดงความคิดเห็นว่าทำไมคุณถึงใช้เพราะอาจเป็นไปได้ที่ผู้ชมที่อ่านออกเขียนได้จะต้องหยุดอยู่ในเส้นทางของพวกเขาเพื่อทำความเข้าใจว่าทำไมคุณถึงใช้มัน
ฉันชอบการแสดงออก "boolean1 ^ boolean2" เป็นการส่วนตัวเนื่องจากความรัดกุม
ถ้าฉันอยู่ในสถานการณ์ของคุณ (ทำงานเป็นทีม) ฉันจะประนีประนอมโดยการใส่ตรรกะ "boolean1 ^ boolean2" ในฟังก์ชันที่มีชื่อที่อธิบายเช่น "isDifferent (boolean1, boolean2)"
ตัวอย่างเช่นแทนที่จะใช้ "boolean1 ^ boolean2" คุณจะเรียกว่า "isDifferent (boolean1, boolean2)" เช่น:
if (isDifferent(boolean1, boolean2))
{
//do it
}ฟังก์ชัน "isDifferent (boolean1, boolean2)" ของคุณจะมีลักษณะดังนี้:
private boolean isDifferent(boolean1, boolean2)
{
return boolean1 ^ boolean2;
}แน่นอนว่าวิธีนี้จะทำให้เกิดการใช้ฟังก์ชั่นการโทรจากภายนอกซึ่งในตัวมันเองนั้นเป็นไปตามแนวทางปฏิบัติที่ดีที่สุด แต่มันก็ช่วยหลีกเลี่ยงการแสดงออกอย่างชัดเจน (และน่าเกลียด) verbose (boolean1 &&! boolean2) "!
หากรูปแบบการใช้งานนั้นเหมาะสมทำไมถึงเป็นเช่นนั้น? ในขณะที่ทีมของคุณไม่รู้จักตัวดำเนินการทันทีด้วยเวลาเท่าที่จะทำได้ มนุษย์เรียนรู้คำศัพท์ใหม่ตลอดเวลา ทำไมไม่เขียนโปรแกรม?
ข้อควรระวังข้อเดียวที่ฉันอาจระบุได้คือ "^" ไม่มีความหมายสั้น ๆ ของการตรวจสอบบูลีนครั้งที่สองของคุณ หากคุณต้องการความหมายของไฟฟ้าลัดวงจรจริงๆแล้ววิธี static util ก็จะทำงานเช่นกัน
public static boolean xor(boolean a, boolean b) {
return (a && !b) || (b && !a);
}xorที่ไม่ตรงกับสิ่งที่ผู้ประกอบการ xor ไม่ แต่ในทางอ้อมจะนำมาซึ่งคำถามมากขึ้นในใจของฉัน (เฉพาะที่เกี่ยวกับความสามารถ) ^มากกว่าโปรแกรมเมอร์ที่ใช้เพียง
! = is OK เพื่อเปรียบเทียบสองตัวแปร แม้ว่ามันจะไม่ทำงานแม้ว่าจะมีการเปรียบเทียบหลายแบบก็ตาม
ในฐานะผู้ประกอบการระดับบิต xor นั้นเร็วกว่าวิธีอื่น ๆ ในการแทนที่ ดังนั้นสำหรับการคำนวณเชิงประสิทธิภาพและปรับขนาดได้ xor จึงมีความจำเป็น
ความคิดเห็นส่วนตัวที่เป็นส่วนตัวของฉัน: ห้ามมิให้มีการใช้ความเสมอภาค (== หรือ! =) สำหรับ booleans อย่างเด็ดขาด การใช้มันแสดงให้เห็นถึงการขาดจริยธรรมการเขียนโปรแกรมพื้นฐานและพื้นฐาน ใครก็ตามที่ทำให้คุณดูสับสน ^ ควรถูกส่งกลับไปที่พื้นฐานของพีชคณิตแบบบูล (ฉันถูกล่อลวงให้เขียน "ไปที่แม่น้ำแห่งความเชื่อ" ที่นี่ :))
str.contains("!=") ^ str.startsWith("not(")ดูดีสำหรับฉันกว่า
str.contains("!=") != str.startsWith("not(")
bool1 ^ bool2 ^ bool3ทำให้ฉันมีเหตุผลมากกว่าตรรกะbool1 != bool2 != bool3