Яка причина використовувати null замість невизначеного в JavaScript?

Я пишу JavaScript вже досить давно, і мені ніколи не було підстав користуватися null. Здається, undefinedце завжди бажано і програмно виконує ту саму мету. Які існують nullзамість практичних причин undefined?

Нульове і невизначене - це по суті два різні значення, що означають одне і те ж. Єдина відмінність полягає в конвенціях про те , як використовувати їх в вашій системі. Як згадували деякі, деякі люди використовують нуль для значення "немає об'єкта", де іноді ви можете отримати об'єкт, тоді як невизначений означає, що жодного об'єкта не очікувалося (або що сталася помилка). Моя проблема з цим - це її абсолютно довільна і зовсім непотрібна.

Однак, є одна основна відмінність - змінні, які не ініціалізуються (включаючи параметри функції, де не було передано жодного аргументу, крім іншого), завжди не визначені.

Ось чому в моєму коді я ніколи не використовую null, якщо те, що я не контролюю, повертає null (наприклад, збігаються регулярні вирази). Краса цього полягає в тому, що вона багато спрощує речі. Мені ніколи не доведеться перевіряти, чи x === undefined || x === null. І якщо у вас є звичка використовувати == або просто такі речі, як if (x) .... Зупини це. !xбуде оцінено як істинне для порожнього рядка, 0, null, NaN - тобто речі, які ви, мабуть, не хочете. Якщо ви хочете написати javascript, який не жахливий, завжди використовуйте потрійні рівні === і ніколи не використовуйте null (замість цього використовуйте undefined). Це полегшить ваш життєвий шлях.

Я не маю відповіді, але за словами Ніколаса Закаса , сторінка 30 його книги " Професійний JavaScript для веб-розробників " :

Визначаючи змінну, яка призначена для подальшого утримання об'єкта, доцільно ініціалізувати змінну на nullвідміну від будь-якого іншого. Таким чином, ви можете явно перевірити значення, nullщоб визначити, чи змінна була заповнена посиланням на об'єкт пізніше

Зрештою, оскільки обидва nullі undefinedпримушують до одного і того ж значення ( Boolean(undefined) === false && Boolean(null) === false), ви можете технічно використовувати будь-який, щоб виконати роботу. Однак є правильний шлях, ІМО.

1. Залиште використання undefinedна компіляторі JavaScript.

   undefinedвикористовується для опису змінних, які не вказують на посилання. Це компілятор JS подбає про вас. Під час компіляції двигун JS встановить значення всіх піднятих змінних undefined. Коли двигун переходить код і значення стає доступним, двигун призначить відповідні значення відповідним змінним. Для тих змінних, для яких вона не знайшла значень, змінні продовжували б підтримувати посилання на примітив undefined.

2. Використовуйте null лише тоді, коли ви явно хочете позначити значення змінної як "немає значення".

   Як зазначає @ com2gz: nullвикористовується для визначення чогось програмно порожнього. undefinedозначає, що посилання не існує. nullЗначення має певну посилання на «нічого». Якщо ви називаєте неіснуючу властивість об'єкта, тоді ви отримаєте undefined. Якщо я зробив би це майно навмисно порожнім, то воно повинно бути nullтаким, щоб ви знали, що це задумано.

TLDR; Не використовуйте undefinedпримітив. Це значення, яке компілятор JS автоматично встановить для вас при оголошенні змінних без призначення або якщо ви намагаєтеся отримати доступ до властивостей об'єктів, на які немає посилання. З іншого боку, використовуйте, nullякщо і лише тоді, коли ви навмисно хочете, щоб змінна не мала значення.

Я ніколи явно нічого не встановлював для невизначеного (і я не стикався з цим у багатьох кодових базах, з якими я взаємодіяв). Також я рідко використовую null. Єдиний раз null, коли я використовую , коли я хочу позначити значення аргументу функції як такої, що не має значення, тобто:

function printArguments(a,b) {
  console.log(a,b);
}

printArguments(null, " hello") // logs: null hello

невизначеним є те, де поняття про річ не існує; він не має типу, і на нього ніколи не було посилання в цьому обсязі; null - це те, де річ, як відомо, існує, але вона не має значення.

У кожного свій спосіб кодування та власна внутрішня семантика, але з роками я вважаю це найбільш інтуїтивно зрозумілою порадою, яку я даю людям, які задають це питання: коли сумніваєтесь, робіть те, що робить JavaScript .

Скажімо, ви працюєте з властивостями об’єктів, як-от параметри для плагіна jQuery ... запитайте себе, яке значення JavaScript надає властивості, яку ще потрібно визначити - відповідь undefined. Тож у цьому контексті я б ініціалізував такі типи речей із ‘undefined’, щоб вони відповідали JavaScript (для змінних ви можете це зробити var myVar;замість var myVar = undefined;).

Тепер скажімо, що ви робите маніпуляції з DOM ... яке значення надає JavaScript неіснуючим елементам? Відповідь така null. Це значення, яке я би ініціалізував, якщо ви створюєте змінну заповнення заповнення, яка пізніше містить посилання на елемент, фрагмент документа або подібне, що стосується DOM.

Якщо ви працюєте з JSON, потрібно створити особливий випадок: для невизначених значень властивостей слід встановити їх ""або nullтому, що значення undefinedне вважається належним форматом JSON.

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

Ви можете прийняти запропоновану тут конвенцію, але насправді немає вагомих підстав для цього. Він не використовується досить послідовно, щоб бути значущим.

Для того, щоб зробити конвенцію корисною, спочатку потрібно знати, що викликана функція слідує умові. Тоді ви повинні явно перевірити повернене значення і вирішити, що робити. Якщо ви отримуєте не визначене , то можна припустити , що якась -небудь помилка , що викликається, знає про . Але якщо сталася помилка, і функція знала про це, і корисно відправити її в більш широке середовище, чому б не використати об’єкт помилки? тобто кинути помилку?

Тож наприкінці дня конвенція практично не потрібна ні в чому, крім дуже малих програм у простих середовищах.

Корисна властивість у null, що не визначено , не відповідає:

> null + 3
3
> undefined + 3
NaN

Я використовую, nullколи хочу "вимкнути" числове значення або ініціалізувати якесь. Моє останнє використання - маніпулювання перетворенням css:

const transforms = { perspective : null, rotateX : null };
// if already set, increase, if not, set to x
runTimeFunction((x) => { trasforms.perspective += x; });
// still useful, as setting perspective to 0 is different than turning it off
runTimeFunction2((x) => { transforms.perspective = null; });

// toCss will check for 'null' values and not set then at all
runTimeFunction3(() => { el.style.transform = toCss(transforms); });

Не впевнений, чи повинен я використовувати цю думку про властивості ...

Вузли та елементи DOM не визначені, але можуть бути нульовими.

• NextSibling останнього дочірнього елемента елемента є нульовим.

• Попередня зміна першої дитини недійсна.

• Посилання document.getElementById є нульовою, якщо елемент не існує в документі.

Але в жодному з цих випадків значення не визначене ; просто там немає вузла.

Кілька з них сказали, що нормально ініціалізувати об'єкти до null. Я просто хотів зазначити, що параметри деструктуризації за замовчуванням не працюють null. Наприклад:

const test = ({ name } = {}) => {
  console.log(name)
}

test() // logs undefined
test(null) // throws error

Це вимагає проведення nullперевірок перед викликом функції, що може траплятися часто.

Я зараз працюю над цим точним питанням і переглядаю таку філософію:

1. Будь-яка функція, яка призначена для повернення результату, повинна повернути нуль, якщо не вдалося знайти результат
2. Будь-яка функція, НЕ призначена для повернення результату, неявно повертається невизначеною.

Для мене це питання є важливим, оскільки у кожного, хто викликає функцію, яка повертає результат, не повинно виникати питань щодо тестування на невизначений vs null.

Ця відповідь не намагається вирішити:

1. Значення властивостей null vs undefined
2. Змінні в межах ваших функцій - нульові та невизначені

На мою думку, змінні - це ваш власний бізнес, а не частина вашого API, а властивості в будь-якій системі ОО визначаються, і тому їх слід визначати зі значенням, відмінним від того, яке було б, якби не було визначено (нульовим для визначеного, невизначеного є те, що ви отримуйте, коли отримуєте доступ до чогось, що немає у вашого об’єкта).

Ось причина: var undefined = 1 це юридичний JavaScript, але var null = 1це синтаксична помилка. Різниця полягає в тому, що nullце мовне ключове слово, тоді undefinedяк, чомусь, це не так.

Якщо ваш код покладається на порівняння undefinedтак, ніби це ключове слово ( if (foo == undefined)- дуже легка помилка), яке працює лише тому, що ніхто не визначив змінну з цим іменем. Весь цей код вразливий для того, щоб хтось випадково чи зловмисно визначив глобальну змінну з цим іменем. Звичайно, ми всі знаємо, що випадково визначити глобальну змінну абсолютно неможливо в JavaScript ...

Просто хочу додати, що при використанні певних бібліотек JavaScript, null та undefined може мати непередбачувані наслідки.

Наприклад, getфункція lodash , яка приймає значення за замовчуванням як третій аргумент:

const user = {
  address: {
    block: null,
    unit: undefined,
  }
}
console.log(_.get(user, 'address.block', 'Default Value')) // prints null
console.log(_.get(user, 'address.unit', 'Default Value')) // prints 'Default Value'
console.log(_.get(user, 'address.postalCode', 'Default Value')) // prints 'Default Value'

Інший приклад: Якщо ви використовуєте defaultProps в React, якщо властивість передано null, реквізити за замовчуванням не використовуються, оскільки null інтерпретується як визначене значення . напр

class MyComponent extends React.Component {
   static defaultProps = {
      callback: () => {console.log('COMPONENT MOUNTED')},
   }
   componentDidMount() {
      this.props.callback();
   }
}
//in some other component
<MyComponent />   // Console WILL print "COMPONENT MOUNTED"
<MyComponent callback={null}/>   // Console will NOT print "COMPONENT MOUNTED"
<MyComponent callback={undefined}/>   // Console WILL print "COMPONENT MOUNTED"

Я повністю не погоджуюся з тим, що використання null або undefined використання не потрібне. undefined - річ, яка підтримує весь процес ланцюга прототипу. Тож компілятор лише з null не може перевірити, чи це властивість просто дорівнює null, чи його не визначено в прототипі кінцевої точки. В інших динамічних набраних мовах (fe Python) він видає виняток, якщо ви хочете отримати доступ до не визначеного властивості, але для компілятора мов, що базуються на прототипі, слід також перевірити батьківські прототипи, і тут є місце, коли невизначені потребують найбільше.

Ціле значення використання null - це просто прив'язування змінної або властивості до об'єкта, який є однотонним і має значення порожнечі, а також використання нуля має цільові результати. Цей 2 код має різницю в часі виконання.

var p1 = function(){this.value = 1};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p1();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p;
});
big_array.reduce((sum, p)=> sum + p.value, 0)

var p2 = function(){this.value = 1, p.x = null};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p2();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p; 
});
big_array.reduce((sum, p)=> sum + p.value, 0)

Невідомий змінна undefined.

Відомі змінна ще немає значення: null.

1. Ви отримуєте об'єкт з сервера, server_object.
2. Ви посилаєтесь server_object.errj. Це говорить вам, що це undefined. Це означає, що він не знає, що це таке.
3. Тепер ви посилаєтесь server_object.err. Це говорить вам, що це null. Це означає, що ви посилаєтесь на правильну змінну, але вона порожня; тому помилок немає.

Проблема полягає в тому, що ви оголошуєте ім'я змінної без значення ( var hello) js заявляє, що undefined: ця змінна не існує; тоді як програмісти переважно означають: "Я ще не визначив це значення", визначення null.

Таким чином, поведінка програміста за замовчуванням - декларуючи змінну без значення як нічого - не відповідає js - оголошує її як неіснуючу. Крім того, !undefinedі !nullобидва, trueтому більшість програмістів трактують їх як рівнозначні.

Звичайно, ви можете переконатися, що ви завжди робите, var hello = nullале більшість не засмічує свій код як такий, щоб забезпечити розумність типу навмисно вільно набраною мовою, коли вони та !оператор ставляться до обох undefinedі nullяк до еквівалентів.