Tại sao người ta thường thấy “null! = Biến” thay vì “biến! = Null” trong C #?

Trong c #, có sự khác biệt nào về tốc độ xử lý đối với thứ tự mà bạn nêu điều kiện không?

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

Kể từ gần đây, tôi nhìn thấy cái đầu tiên khá thường xuyên, và nó khiến tôi chú ý vì tôi đã quen với cái thứ hai.

Nếu không có sự khác biệt, lợi thế của cái đầu tiên là gì?

Đó là sự cố giữ lại từ C. Trong C, nếu bạn sử dụng một trình biên dịch kém hoặc không có cảnh báo đủ cao, điều này sẽ biên dịch mà không có bất kỳ cảnh báo nào (và thực sự là mã hợp pháp):

// Probably wrong
if (x = 5)

khi bạn thực sự có thể có ý nghĩa

if (x == 5)

Bạn có thể giải quyết vấn đề này trong C bằng cách:

if (5 == x)

Một lỗi đánh máy ở đây sẽ dẫn đến mã không hợp lệ.

Bây giờ, trong C #, đây là tất cả những gì phức tạp. Trừ khi bạn đang so sánh hai giá trị Boolean (hiếm gặp, IME), bạn có thể viết mã dễ đọc hơn, vì câu lệnh "if" yêu cầu bắt đầu bằng biểu thức Boolean và loại " x=5" Int32thì không Boolean.

Tôi đề nghị rằng nếu bạn thấy điều này trong mã của đồng nghiệp của mình, bạn nên giáo dục họ theo cách của các ngôn ngữ hiện đại và đề nghị họ viết dạng tự nhiên hơn trong tương lai.

Có một lý do chính đáng để sử dụng null trước: if(null == myDuck)

Nếu bạn class Duckghi đè ==toán tử, thì if(myDuck == null)có thể đi vào một vòng lặp vô hạn.

Sử dụng nulllần đầu tiên sử dụng một bộ so sánh bình đẳng mặc định và thực sự làm những gì bạn đang có ý định.

(Tôi nghe nói rằng cuối cùng bạn đã quen với việc đọc mã được viết theo cách đó - tôi chỉ là chưa trải nghiệm sự chuyển đổi đó).

Đây là một ví dụ:

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
    }
}

Giống như mọi người đã lưu ý, nó ít nhiều đến từ ngôn ngữ C, nơi bạn có thể nhận được mã sai nếu bạn vô tình quên dấu bằng thứ hai. Nhưng có một lý do khác cũng phù hợp với C #: Khả năng đọc.

Chỉ cần lấy ví dụ đơn giản sau:

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

Nếu bạn chỉ cần hoán đổi tất cả các từ rỗng sang đầu, bạn có thể dễ dàng hơn nhiều trong việc kiểm tra tất cả:

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

Vì vậy, ví dụ này có thể là một ví dụ tồi (tham khảo hướng dẫn mã hóa) nhưng hãy nghĩ về việc bạn cuộn nhanh qua một tệp mã hoàn chỉnh. Chỉ bằng cách nhìn thấy mẫu

if(null ...

bạn ngay lập tức biết điều gì sẽ xảy ra tiếp theo.

Nếu ngược lại, bạn luôn phải quét đến cuối dòng để xem kiểm tra tính vô hiệu, chỉ để bạn vấp một giây để tìm ra loại kiểm tra được thực hiện ở đó. Vì vậy, có thể tô sáng cú pháp có thể giúp ích cho bạn, nhưng bạn luôn chậm hơn khi những từ khóa đó ở cuối dòng thay vì ở phía trước.

Tôi đoán đây là một lập trình viên C đã chuyển đổi ngôn ngữ.

Trong C, bạn có thể viết như sau:

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

Lưu ý việc sử dụng một dấu bằng duy nhất ở đó, có nghĩa là mã sẽ gán 1 cho biến i, sau đó trả về 1 (một phép gán là một biểu thức) và sử dụng 1 trong câu lệnh if, sẽ được xử lý là true. Nói cách khác, ở trên là một lỗi.

Tuy nhiên, trong C #, điều này là không thể. Thực sự không có sự khác biệt giữa hai.

Trong thời gian trước đó, mọi người sẽ quên dấu '!' (hoặc dấu '=' bổ sung cho bằng nhau, khó phát hiện hơn) và thực hiện một bài tập thay vì so sánh. đặt null ở phía trước loại bỏ khả năng xảy ra lỗi, vì null không phải là giá trị l (IE không thể gán nó cho).

Hầu hết các trình biên dịch hiện đại đều đưa ra cảnh báo khi bạn thực hiện một nhiệm vụ trong điều kiện ngày nay và C # thực sự đưa ra lỗi. Hầu hết mọi người chỉ gắn bó với lược đồ var == null vì nó dễ đọc hơn đối với một số người.

Tôi không thấy bất kỳ lợi ích nào khi tuân theo quy ước này. Trong C, nơi các kiểu boolean không tồn tại, rất hữu ích khi viết

if( 5 == variable)

hơn là

if (variable == 5)

bởi vì nếu bạn quên một trong các dấu hiệu, bạn sẽ kết thúc với

if (variable = 5)

chỉ định 5 cho biến và luôn đánh giá là true. Nhưng trong Java, một boolean là một boolean. Và với! =, Không có lý do gì cả.

Tuy nhiên, một lời khuyên tốt là hãy viết

if (CONSTANT.equals(myString))

hơn là

if (myString.equals(CONSTANT))

vì nó giúp tránh NullPointerExceptions.

Lời khuyên của tôi là yêu cầu một sự biện minh của quy tắc. Nếu không có, tại sao theo dõi nó? Nó không giúp dễ đọc

Đối với tôi, đó luôn là phong cách bạn thích

@Shy - Sau đó, nếu bạn nhầm lẫn giữa các toán tử thì bạn nên nhận lỗi biên dịch hoặc bạn sẽ chạy mã với một lỗi - một lỗi sẽ quay lại và cắn bạn sau đó vì nó tạo ra hành vi không mong muốn

Như nhiều người đã chỉ ra, nó chủ yếu nằm trong mã C cũ, nó được sử dụng để xác định lỗi biên dịch, vì trình biên dịch chấp nhận nó là hợp pháp

Ngôn ngữ lập trình mới như java, go đủ thông minh để nắm bắt các lỗi biên dịch như vậy

Người ta không nên sử dụng "null! = Biến" như các điều kiện trong mã vì nó rất khó đọc

Một điều nữa ... Nếu bạn đang so sánh một biến với một hằng số (số nguyên hoặc chuỗi cho ví dụ:), đặt hằng số ở bên trái là một phương pháp hay vì bạn sẽ không bao giờ gặp phải NullPointerExceptions:

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

trong khi

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

Bây giờ, vì theo mặc định C # cài đặt tất cả các biến, bạn sẽ không gặp vấn đề đó trong ngôn ngữ đó.