Чому в C # часто бачимо "null! = Змінна" замість "varia!! = Null"?

У c #, чи є різниця у швидкості виплати для порядку, у якому ви заявляєте умову?

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

З недавнього часу я бачив перший досить часто, і це привернуло мою увагу, оскільки я звик до другого.

Якщо різниці немає, у чому перевага першого?

Це затримка від C. У C, якщо ви використовуєте поганий компілятор або не маєте попередження, підняті досить високо, це буде компілюватися без жодного попередження (і це дійсно юридичний код):

// Probably wrong
if (x = 5)

коли ти насправді мав на увазі

if (x == 5)

Ви можете обійти це на C, виконавши:

if (5 == x)

Опечатка тут призведе до недійсного коду.

Тепер у C # це все суворо. Якщо ви не порівнюєте два булевих значення (що рідко, IME), ви можете написати більш читабельний код, оскільки для оператора "якщо" потрібен булевий вираз, а тип " 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 #: читабельність.

Просто візьміть цей простий приклад:

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 не є l-значенням (IE йому не можна призначати).

Більшість сучасних компіляторів подають попередження, коли ви виконуєте завдання в умовному режимі, і C # насправді дає помилку. Більшість людей просто дотримуються схеми var == null, оскільки її легше читати.

Я не бачу жодної переваги в дотриманні цієї конвенції. У C, де булевих типів не існує, корисно писати

if( 5 == variable)

а не

if (variable == 5)

бо якщо ти забудеш один із еквальних знаків, то закінчишся

if (variable = 5)

який присвоює 5 змінній і завжди оцінює істину. Але на Яві булевий бул. І з! =, Зовсім немає причини.

Хоча одна хороша порада - написати

if (CONSTANT.equals(myString))

а не

if (myString.equals(CONSTANT))

оскільки це допомагає уникати NullPointerExceptions.

Моєю порадою було б попросити обґрунтування правила. Якщо його немає, навіщо його слідкувати? Це не допомагає читати

Для мене завжди було те, якому стилю ви віддаєте перевагу

@Shy - Потім, якщо ви заплутаєте операторів, тоді вам слід отримати помилку компіляції, або у вас буде запущений код із помилкою - помилкою, яка повернеться та кусає вас пізніше вниз по дорозі, оскільки це призвело до несподіваної поведінки

Як багато хто зазначав, це здебільшого у старому коді С він використовувався для виявлення помилки компіляції, оскільки компілятор прийняв її як легальну

Нова мова програмування, як 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 # за замовчуванням створює всі змінні, у вас не повинно виникнути цієї проблеми на цій мові.