ทำไมต้องใช้! boolean_variable มากกว่า boolean_variable == false

ความคิดเห็นเกี่ยวกับคำถามนี้: การตรวจสอบว่าวิธีการส่งกลับเท็จ: กำหนดผลลัพธ์ให้กับตัวแปรชั่วคราวหรือทำให้วิธีการภาวนาโดยตรงในเงื่อนไข? บอกว่าคุณควรใช้!booleanแทนboolean == falseเมื่อทดสอบเงื่อนไข ทำไม? สำหรับฉันนั้นboolean == falseเป็นธรรมชาติมากขึ้นในภาษาอังกฤษและชัดเจนยิ่งขึ้น ฉันขอโทษถ้านี่เป็นเพียงเรื่องของสไตล์ แต่ฉันสงสัยว่ามีเหตุผลอื่นอีก!booleanหรือไม่สำหรับการตั้งค่านี้

เมื่อฉันเห็นเส้นคล้าย if (!lateForMeeting())ฉันอ่านว่า"ถ้าไม่มาสายสำหรับการประชุม"ซึ่งค่อนข้างตรงไปตรงมาเพื่อทำความเข้าใจซึ่งตรงข้ามกับif (lateForMeeting() == false)ที่ฉันอ่านว่า"ถ้าข้อเท็จจริงที่ว่าฉันมาประชุมสายเป็นเท็จ " .

มันมีความหมายเหมือนกัน แต่ในอดีตนั้นใกล้เคียงกับการสร้างประโยคภาษาอังกฤษที่เทียบเท่ากัน

การเขียน== falseและ== trueซ้ำซ้อน มันสามารถนำไปสุดขั้วโดยพลการเช่นกัน ถ้าคุณเริ่มเขียน

if (condition == false) { ... }

ถ้าอย่างนั้นทำไม

if ((condition == false) == true) { ... }

หรือทำไมไม่

if ((someExp == anotherExp) == true) { ... }

คุณธรรมของเรื่องนี้ก็คือว่าถ้าconditionเป็นนิพจน์บูลีนแล้วคุณไม่จำเป็นต้องเพิ่ม== false; นั่นคือสิ่งที่ผู้ประกอบการ!มีไว้สำหรับ;)

ใน C และภาษาที่คล้ายคลึงกันการเปรียบเทียบนิพจน์บูลีนเพื่อความเท่าเทียมกันfalseหรือtrueเป็นนิสัยที่อันตราย

ใน C นิพจน์สเกลาร์ใด ๆ (ตัวเลขหรือตัวชี้) สามารถใช้ในบริบทบูลีนเช่นเป็นเงื่อนไขของifคำสั่ง กฎ C if (cond)คือเทียบเท่ากับif (cond != 0)- กล่าวคือศูนย์เป็นเท็จและค่าที่ไม่เป็นศูนย์ใด ๆเป็นจริง หากcondเป็นประเภทพอยน์เตอร์0จะถือว่าเป็นค่าคงที่ตัวชี้โมฆะ วิธีif (ptr)if (ptr != NULL)

ซึ่งหมายความว่า

if (cond)

และ

if (cond == true)

ไม่ได้หมายถึงสิ่งเดียวกัน ข้อแรกเป็นจริงถ้าcondไม่ใช่ศูนย์ ที่สองเป็นความจริง แต่ถ้ามันเท่ากันtrueซึ่งใน C (ถ้าคุณมี#include <stdbool.h>) 1เป็นเพียง

ตัวอย่างเช่นisdigit()ฟังก์ชั่นที่ประกาศในการ<ctype.h>คืนintค่า0ถ้าอาร์กิวเมนต์เป็นตัวเลขที่ไม่ใช่ศูนย์ถ้ามันไม่ได้ สามารถย้อนกลับ42เพื่อระบุว่าเงื่อนไขเป็นจริง การเปรียบเทียบ42 == trueจะล้มเหลว

มันเกิดขึ้นที่0เป็นค่าเดียวที่ถือว่าเป็นเท็จดังนั้นการเปรียบเทียบสำหรับความเสมอภาคที่falseจะทำงาน; if (!cond)และif (cond == false)ทำสิ่งเดียวกัน แต่ถ้าคุณจะใช้ประโยชน์จากสิ่งนั้นคุณต้องจำไว้ว่าการเปรียบเทียบกับfalseมันโอเคและการเปรียบเทียบtrueไม่ใช่ เลวยังเทียบกับtrueจะทำงานมากที่สุดของเวลา (เช่นความเสมอภาคและความสัมพันธ์ผู้ประกอบการมักจะให้ผลอย่างใดอย่างหนึ่ง0หรือ1) ซึ่งหมายความว่าข้อบกพร่องใด ๆ ที่คุณแนะนำโดยใช้สิ่งนี้ยังคงเป็นเรื่องยากที่จะติดตาม (ไม่ต้องกังวลพวกเขาจะปรากฏขึ้นทันทีที่คุณสาธิตรหัสไปยังลูกค้าคนสำคัญ)

C ++ มีกฎแตกต่างกันเล็กน้อย ตัวอย่างของboolประเภทเป็นบิตที่ผสานรวมมากยิ่งขึ้นในภาษาและif (cond)แปลงที่จะพิมพ์cond boolแต่ผลที่ได้คือ (ส่วนใหญ่) เหมือนกัน

ภาษาอื่นบางภาษามีสิ่งที่เราเรียกว่าบูลีนที่มีพฤติกรรมดีกว่าเช่นนั้นcond == trueและcond == false(หรือสิ่งที่จะเกิดขึ้นกับไวยากรณ์) นั้นปลอดภัย แม้กระนั้นทุกภาษาที่ฉันเห็นมีnotหรือ!ผู้ปฏิบัติ มันอยู่ที่นั่นดังนั้นคุณอาจใช้มันเช่นกัน ในความคิดของฉันใช้cond == falseมากกว่า!condหรือnot condไม่ปรับปรุงการอ่าน (มันเป็นความจริงที่ว่า!ตัวละครอาจมองเห็นได้ยากบางครั้งฉันก็เพิ่มช่องว่างหลังจาก!เพื่อหลีกเลี่ยงสิ่งนี้)

และบ่อยครั้งที่คุณสามารถหลีกเลี่ยงปัญหาและปรับปรุงความชัดเจนโดยจัดเรียงรหัสใหม่เล็กน้อย ตัวอย่างเช่น:

if (!cond) {
    do_this();
}
else {
    do_that();
}

คุณอาจจะเขียน:

if (cond) {
     do_that();
}
else {
    do_this();
}

มันไม่ได้ดีกว่าเสมอไป แต่ก็ไม่เจ็บที่จะมองหาโอกาสในที่ที่มันอยู่

สรุป:ใน C และ C ++ ความเท่าเทียมกันเมื่อเปรียบเทียบกับtrueและfalseเป็นอันตราย verbose มากเกินไปและสไตล์ที่ไม่ดี ในภาษาอื่น ๆ การเปรียบเทียบเช่นนี้อาจไม่เป็นอันตราย แต่ยังคงมีความละเอียดและสไตล์ที่ไม่ดี

หากคุณcondition == false“ มีความเป็นธรรมชาติมากขึ้นในภาษาอังกฤษ” สำหรับคุณฉันต้องสมมติว่าคุณไม่ใช่เจ้าของภาษา ไม่เช่นนั้นฉันไม่สามารถอธิบายได้เพราะไม่มีใครพูดเช่นนี้:

ถ้าดวงอาทิตย์ส่องแสงเป็นเท็จฉันจะอยู่บ้าน

เปรียบเทียบกับ

ถ้าดวงอาทิตย์ไม่ส่องแสงฉันอยู่บ้าน

ที่กล่าวว่าฉันยอมรับว่า!ตัวละครตัวเดียวเรียวมองข้ามได้ง่ายในรหัส ด้วยเหตุนี้ฉันจึงต้องการคำหลักnotเมื่อภาษานั้นรองรับ อินสแตนซ์ C ++ อนุญาตให้ทำได้แม้ว่าโปรแกรมเมอร์จำนวนมากจะไม่ทราบ

สำหรับภาษาที่ต้องการ!ฉันจะเว้นช่องว่างระหว่างโอเปอเรเตอร์และโอเปอแรนด์ สิ่งนี้ทำให้การปฏิเสธเป็นเรื่องยากมากที่จะมองข้าม:

if (! condition) { … }

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

ทั้งสองมีหน้าที่เหมือนกันดังนั้นสิ่งที่ใช้เป็นเรื่องของรสนิยม

เหตุผลสำคัญที่ฉันใช้== falseคือฉันพบว่า!มองข้ามง่ายเกินไปเมื่อดูรหัส

ด้วยการถูกกัดอย่างรุนแรงจากสิ่งนี้ฉันได้สร้างนิสัยให้ชัดเจนเมื่อทดสอบการปลอม

หากผู้ประกอบการได้รับการตั้งชื่อnotในปาสคาลฉันไม่คิดว่านี่จะเป็นปัญหา

เมื่อฉันเห็นvar == falseฉันมักจะสงสัยว่าvarบูลีนหรือประเภทตรรกะที่มีค่ามากกว่าสองค่า (เช่นยกตัวอย่างเช่น a maybeและa undefinedรวมถึงtrueและfalseหรือบางอย่างเช่นค่าเก้าค่าของ IEEE 1164 )

เพราะบางครั้งคุณอาจเขียนboolean = false(ด้วยข้อผิดพลาดที่เห็นได้ชัด) และfalse == booleanดูไม่เป็นธรรมชาติ (ไม่ว่ามันจะดีแค่ไหนในการฝึกฝน)

if (!boolean_variable)if the condition is not trueแปลว่า

if (boolean == false)if the condition not false is trueแปลว่า เพราะนั่นเป็นตรรกะที่ผกผันมันยากที่จะเข้าใจ

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

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

ที่ทำงานฉันมักจะติดต่อกับบูลีนซึ่งอาจเป็นโมฆะดังนั้นฉันมักจะเขียนโค้ดกรณีนี้เป็น

if (value != null && value == true){
    //do something
}

เพราะฉันรู้สึกว่าสมมาตรทำให้อ่านง่ายขึ้น โดยเฉพาะอย่างยิ่งหากมีการทดสอบ Booleans อื่น ๆ เช่นกัน

ฉันไม่สนใจวิธีใดเลย

เมื่อคุณกำลังทดสอบเงื่อนไขจริงมันสมเหตุสมผลที่จะต้องทำif (condition)โดยเฉพาะเมื่อคุณใช้หลักการของการตั้งชื่อตัวแปรบูลีนที่ขึ้นต้นด้วย 'is': if (isOpen)มีความชัดเจนอย่างสมบูรณ์และการใช้!= falseจะซ้ำซ้อน

สำหรับ C / C ++ / Java / etc โปรแกรมเมอร์ความหมายของ '!' ผู้ประกอบการหลอมรวมอย่างสมบูรณ์จนถึงจุดที่เรามี 'ไม่' ในใจของเราโดยอัตโนมัติเมื่อเราเห็นมัน ดังนั้นการมีif (!isOpen)ความชัดเจนพอ ๆif (_NOT_ isOpen)กับฉัน แต่คุณยังไม่คุ้นเคยใน C / C ++ คุณสามารถสร้างแมโคร#define _NOT_ !ได้ แต่เชื่อฉันหลังจากไม่กี่ปีนี้ไม่จำเป็นอย่างสมบูรณ์

นอกเหนือจากนั้นการทดสอบค่าบูลีนจะดีกว่าเสมอโดยไม่ต้องเปรียบเทียบกับตัวอักษร ยกตัวอย่างเช่นมันอันตรายที่จะทดสอบif (x == true)เพราะค่าบูลีนถือว่าเป็นจริงถ้ามันไม่เป็นศูนย์และตัวอักษรที่แท้จริงมีค่าเพียงค่าเดียวดังนั้น x อาจเป็น 'จริง' (เช่นไม่ใช่ศูนย์) และยังเปรียบเทียบการประเมินเป็นเท็จ (เพราะมัน มี 2 ​​และตัวอักษรที่แท้จริงคือ, พูด, 1) แน่นอนว่าไม่ได้ใช้กับการเปรียบเทียบกับเท็จ แต่ถ้าคุณไม่ใช้มันเมื่อทำการทดสอบจริงทำไมใช้เมื่อทดสอบเท็จ?

เรื่องขนาด;)

ในนิพจน์ผสมมันง่ายต่อการอ่าน:

boolean1 = false
boolean2 = true

p ! boolean1 and ! boolean2
p boolean1 == false and boolean2 == false

และโดยเฉพาะอย่างยิ่งสำหรับทับทิมตัวอย่างที่มันแตกต่างกันมาก:

boolean = nil
p ! boolean         #-> true
p boolean == false  #-> false

ไม่มีเป็นเท็จ แต่ก็ไม่เป็นความจริง

จากประสบการณ์ของฉันและคำตอบจากคำถามของฉันที่คุณเชื่อมโยง

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

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

สำหรับบางคนความหมายที่แสดงออกก็จะดีขึ้น

สำหรับคนที่มี "if! ... " เปรียบเทียบเร็วกว่า "if ... " จากนั้นต้องอ่านเงื่อนไขทั้งหมด (ซึ่งอาจจะค่อนข้างยาวเช่น (thisThing = thatThing หรือบางอย่าง = สิ่งอื่น ๆ ) หรือ ( thinga = thingb และ thinga = thingd) และอื่น ๆ ) เพื่อหา == false ในตอนท้าย

มี! (จริง ๆ แล้วฉันไม่ชอบเมื่อภาษาอนุญาต) ด้านหน้าได้รับภาษาอังกฤษ 'ไม่' สำหรับเงื่อนไขนี้ในที่นั่นเร็ว

ปัญหานี้ยังนำไปสู่การพิจารณาuntilในการใช้ภาษาที่รองรับเช่นทำ 'สิ่งทั่วไป' จนกว่าจะเสร็จสิ้น อย่างที่คนอื่นพูดการใช้ภาษาธรรมชาติเป็นเป้าหมาย ฉันชอบตัวอย่าง "ดวงอาทิตย์กำลังส่องแสง" ด้านบน

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

ฉันไม่สามารถคิดได้ทุกที่if (!variable)(หรือเทียบเท่าเช่นif not variableขึ้นอยู่กับภาษาของคุณ) ไม่ปลอดภัยในขณะที่เช่นif self.is_ready() == False: ...ไม่ปลอดภัยในหลามถ้าself.is_ready()กลับNoneมาตอนนี้หรือในอนาคตซึ่งจะเป็นสิ่งที่สมเหตุสมผลโดยสิ้นเชิงสำหรับการทำเพื่อ แสดงว่ายังไม่พร้อมเนื่องจากNoneเป็นเพียง falsey Falseเป็น