เหตุใดจึงมักเห็น“ null! = variable” แทน“ variable! = null” ใน C #?

ใน c # มีความแตกต่างในความเร็วในการกำจัดสำหรับลำดับที่คุณระบุเงื่อนไขหรือไม่?

if (null != variable) ...
if (variable != null) ...

ตั้งแต่ไม่นานมานี้ฉันเห็นคนแรกค่อนข้างบ่อยและมันดึงดูดความสนใจของฉันตั้งแต่ฉันคุ้นเคยกับอันที่สอง

ถ้าไม่มีข้อแตกต่างข้อแรกมีข้อดีอย่างไร?

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

// Probably wrong
if (x = 5)

เมื่อคุณอาจจะหมายถึงจริงๆ

if (x == 5)

คุณสามารถแก้ไขสิ่งนี้ใน C โดยทำ:

if (5 == x)

การพิมพ์ผิดที่นี่จะส่งผลให้รหัสไม่ถูกต้อง

ตอนนี้ใน C # นี่คือ piffle ทั้งหมด เว้นแต่คุณจะเปรียบเทียบค่าบูลีนสองค่า (ซึ่งหายาก IME) คุณสามารถเขียนโค้ดที่อ่านได้มากขึ้นเนื่องจากคำสั่ง "if" ต้องใช้นิพจน์บูลีนในการเริ่มต้นและประเภทของ " x=5" คือInt32ไม่ใช่Booleanไม่ได้

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

มีเหตุผลที่ดีที่จะใช้ null ก่อน: if(null == myDuck)

หากคุณclass Duckแทนที่==โอเปอเรเตอร์ก็if(myDuck == null)สามารถเข้าสู่ลูปที่ไม่มีที่สิ้นสุดได้

การใช้nullครั้งแรกใช้ตัวเปรียบเทียบความเท่าเทียมเริ่มต้นและทำในสิ่งที่คุณตั้งใจ

(ฉันได้ยินว่าคุณคุ้นเคยกับการอ่านโค้ดที่เขียนแบบนั้นในที่สุด - ฉันยังไม่เคยสัมผัสกับการเปลี่ยนแปลงนั้น)

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

public class myDuck
{
    public int quacks;
    static override bool operator ==(myDuck a, myDuck b)
    {
        // these will overflow the stack - because the a==null reenters this function from the top again
        if (a == null && b == null)
            return true;
        if (a == null || b == null)
            return false;

        // these wont loop
        if (null == a && null == b)
            return true;
        if (null == a || null == b)
            return false;
        return a.quacks == b.quacks; // this goes to the integer comparison
    }
}

เช่นเดียวกับที่ทุกคนตั้งข้อสังเกตว่ามันมาจากภาษา C ไม่มากก็น้อยซึ่งคุณอาจได้รับรหัสเท็จหากคุณลืมเครื่องหมายเท่ากับที่สองโดยไม่ได้ตั้งใจ แต่ยังมีอีกเหตุผลหนึ่งที่ตรงกับ C #: ความสามารถในการอ่าน

เพียงแค่ใช้ตัวอย่างง่ายๆนี้:

if(someVariableThatShouldBeChecked != null
   && anotherOne != null
   && justAnotherCheckThatIsNeededForTestingNullity != null
   && allTheseChecksAreReallyBoring != null
   && thereSeemsToBeADesignFlawIfSoManyChecksAreNeeded != null)
{
    // ToDo: Everything is checked, do something...
}

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

if(null != someVariableThatShouldBeChecked
   && null != anotherOne
   && null != justAnotherCheckThatIsNeededForTestingNullity
   && null != allTheseChecksAreReallyBoring
   && null != thereSeemsToBeADesignFlawIfSoManyChecksAreNeeded)
{
    // ToDo: Everything is checked, do something...
}

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

if(null ...

คุณรู้ทันทีว่าจะเกิดอะไรขึ้นต่อไป

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

ฉันเดาว่านี่เป็นโปรแกรมเมอร์ C ที่เปลี่ยนภาษาแล้ว

ใน C คุณสามารถเขียนสิ่งต่อไปนี้:

int i = 0;
if (i = 1)
{
    ...
}

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

อย่างไรก็ตามใน C # ไม่สามารถทำได้ แน่นอนไม่มีความแตกต่างระหว่างทั้งสอง

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

คอมไพเลอร์สมัยใหม่ส่วนใหญ่จะแจ้งเตือนเมื่อคุณทำงานในเงื่อนไขปัจจุบันและ C # ให้ข้อผิดพลาด คนส่วนใหญ่ยึดติดกับรูปแบบ var == null เนื่องจากบางคนอ่านง่ายกว่า

ฉันไม่เห็นประโยชน์ใด ๆ ในการปฏิบัติตามอนุสัญญานี้ ใน C ซึ่งไม่มีประเภทบูลีนการเขียนจะมีประโยชน์

if( 5 == variable)

ค่อนข้างมากกว่า

if (variable == 5)

เพราะถ้าคุณลืมเครื่องหมาย eaqual อันใดอันหนึ่งคุณจะจบลงด้วย

if (variable = 5)

ซึ่งกำหนด 5 ให้กับตัวแปรและประเมินเป็นจริงเสมอ แต่ใน Java บูลีนคือบูลีน และด้วย! = ไม่มีเหตุผลเลย

แต่คำแนะนำที่ดีอย่างหนึ่งคือการเขียน

if (CONSTANT.equals(myString))

ค่อนข้างมากกว่า

if (myString.equals(CONSTANT))

เพราะช่วยหลีกเลี่ยง NullPointerExceptions

คำแนะนำของฉันคือการขอเหตุผลของกฎ ถ้าไม่มีจะติดตามทำไม มันไม่ได้ช่วยในการอ่าน

สำหรับฉันแล้วคุณมักจะชอบสไตล์ไหน

@Shy - จากนั้นอีกครั้งหากคุณสับสนกับโอเปอเรเตอร์คุณควรต้องการรับข้อผิดพลาดในการคอมไพล์หรือคุณจะรันโค้ดด้วยบั๊กซึ่งเป็นข้อผิดพลาดที่จะกลับมากัดคุณในภายหลังเนื่องจากมันสร้างพฤติกรรมที่ไม่คาดคิด

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

ภาษาโปรแกรมใหม่เช่น java go นั้นฉลาดพอที่จะจับข้อผิดพลาดในการคอมไพล์ดังกล่าว

ไม่ควรใช้ "null! = variable" เหมือนเงื่อนไขในโค้ดเนื่องจากอ่านไม่ได้มาก

อีกอย่างหนึ่ง ... หากคุณกำลังเปรียบเทียบตัวแปรกับค่าคงที่ (จำนวนเต็มหรือสตริงสำหรับอดีต) การใส่ค่าคงที่ทางซ้ายถือเป็นแนวทางปฏิบัติที่ดีเพราะคุณจะไม่มีทางเจอ NullPointerExceptions:

int i;
if(i==1){        // Exception raised: i is not initialized. (C/C++)
  doThis();
}

ในขณะที่

int i;
if(1==i){        // OK, but the condition is not met.
  doThis();
}

ตอนนี้เนื่องจากโดยค่าเริ่มต้น C # จะติดตั้งตัวแปรทั้งหมดคุณจึงไม่ควรมีปัญหาในภาษานั้น