Mengapa seseorang sering melihat "null! = Variable" daripada "variable! = Null" di C #?

Di c #, apakah ada perbedaan dalam kecepatan eksekusi untuk urutan yang Anda nyatakan kondisinya?

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

Sejak baru-baru ini, saya cukup sering melihat yang pertama, dan itu menarik perhatian saya karena saya terbiasa dengan yang kedua.

Jika tidak ada perbedaan, apa keuntungan dari yang pertama?

Ini adalah penahanan dari C. Dalam C, jika Anda menggunakan kompilator yang buruk atau tidak memiliki peringatan yang cukup tinggi, ini akan dikompilasi tanpa peringatan apa pun (dan memang kode legal):

// Probably wrong
if (x = 5)

padahal yang mungkin Anda maksud

if (x == 5)

Anda dapat mengatasinya di C dengan melakukan:

if (5 == x)

Salah ketik di sini akan menghasilkan kode yang tidak valid.

Sekarang, di C # ini semua piffle. Kecuali jika Anda membandingkan dua nilai Boolean (yang jarang, IME), Anda dapat menulis kode yang lebih mudah dibaca, karena pernyataan "jika" memerlukan ekspresi Boolean untuk memulai, dan jenis " x=5" adalah Int32, bukan Boolean.

Saya menyarankan jika Anda melihat ini dalam kode kolega Anda, Anda mendidik mereka dalam cara-cara bahasa modern, dan menyarankan mereka menulis bentuk yang lebih alami di masa depan.

Ada alasan bagus untuk menggunakan null dulu: if(null == myDuck)

Jika Anda class Duckmenimpa ==operator, maka if(myDuck == null)bisa masuk ke loop tak terbatas.

Menggunakan nullpertama menggunakan pembanding kesetaraan default dan benar-benar melakukan apa yang Anda inginkan.

(Saya mendengar Anda terbiasa membaca kode yang ditulis seperti itu pada akhirnya - saya hanya belum mengalami transformasi itu).

Berikut ini contohnya:

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

Seperti semua orang yang telah mencatatnya, ini kurang lebih berasal dari bahasa C di mana Anda bisa mendapatkan kode palsu jika Anda secara tidak sengaja lupa tanda sama dengan kedua. Tetapi ada alasan lain yang juga cocok dengan C #: Keterbacaan.

Ambil saja contoh sederhana ini:

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

Jika Anda hanya ingin menukar semua kata nol ke awal, Anda dapat lebih mudah melihat semua pemeriksaan:

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

Jadi contoh ini mungkin contoh yang buruk (lihat pedoman pengkodean) tetapi pikirkan tentang Anda dengan cepat menggulir file kode lengkap. Dengan hanya melihat polanya

if(null ...

Anda segera tahu apa yang akan terjadi selanjutnya.

Jika sebaliknya, Anda harus selalu memindai hingga akhir baris untuk melihat pemeriksaan nullity, hanya membiarkan Anda tersandung sesaat untuk mengetahui jenis pemeriksaan yang dilakukan di sana. Jadi mungkin penyorotan sintaks dapat membantu Anda, tetapi Anda selalu lebih lambat ketika kata kunci tersebut berada di akhir baris, bukan di depan.

Saya kira ini adalah programmer C yang telah mengganti bahasa.

Di C, Anda dapat menulis yang berikut ini:

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

Perhatikan penggunaan satu tanda sama dengan di sana, yang berarti kode akan menetapkan 1 ke variabel i, lalu mengembalikan 1 (tugas adalah ekspresi), dan gunakan 1 dalam pernyataan-if, yang akan ditangani sebagai benar. Dengan kata lain, di atas adalah bug.

Namun dalam C #, ini tidak mungkin. Memang tidak ada perbedaan diantara keduanya.

Di masa lalu, orang akan melupakan '!' (atau tambahan '=' untuk kesetaraan, yang lebih sulit dikenali) dan lakukan tugas alih-alih perbandingan. menempatkan null di depan menghilangkan kemungkinan bug, karena null bukanlah nilai-l (IE tidak dapat ditugaskan).

Kebanyakan kompiler modern memberikan peringatan saat Anda melakukan tugas dalam kondisi saat ini, dan C # sebenarnya memberikan kesalahan. Kebanyakan orang tetap menggunakan skema var == null karena lebih mudah dibaca oleh sebagian orang.

Saya tidak melihat keuntungan dalam mengikuti konvensi ini. Di C, di mana tipe boolean tidak ada, akan berguna untuk menulis

if( 5 == variable)

daripada

if (variable == 5)

karena jika Anda lupa salah satu tanda eaqual, Anda berakhir dengan

if (variable = 5)

yang memberikan 5 ke variabel dan selalu bernilai true. Tapi di Java, boolean adalah boolean. Dan dengan! =, Tidak ada alasan sama sekali.

Namun, satu nasihat yang bagus adalah menulis

if (CONSTANT.equals(myString))

daripada

if (myString.equals(CONSTANT))

karena membantu menghindari NullPointerExceptions.

Saran saya adalah meminta pembenaran aturan tersebut. Jika tidak ada, mengapa mengikutinya? Itu tidak membantu keterbacaan

Bagi saya, gaya yang Anda sukai selalu seperti itu

@Shy - Kemudian lagi jika Anda membingungkan operator maka Anda harus ingin mendapatkan kesalahan kompilasi atau Anda akan menjalankan kode dengan bug - bug yang kembali dan menggigit Anda nanti karena menghasilkan perilaku yang tidak terduga

Seperti yang ditunjukkan banyak orang, sebagian besar dalam kode C lama itu digunakan untuk mengidentifikasi kesalahan kompilasi, karena kompiler menerimanya sebagai legal.

Bahasa pemrograman baru seperti java, go cukup pintar untuk menangkap kesalahan kompilasi seperti itu

Seseorang tidak boleh menggunakan "null! = Variable" seperti kondisi dalam kode karena sangat tidak terbaca

Satu hal lagi ... Jika Anda membandingkan variabel dengan konstanta (bilangan bulat atau string untuk ex.), Meletakkan konstanta di sebelah kiri adalah praktik yang baik karena Anda tidak akan pernah mengalami NullPointerExceptions:

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

sedangkan

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

Sekarang, karena secara default C # instanciates semua variabel, Anda seharusnya tidak memiliki masalah itu dalam bahasa itu.