Какая причина использовать null вместо undefined в JavaScript?

у меня нет ответа, но согласно Николай С. Zakas страница 30 из его книги "профессиональный JavaScript для веб-разработчиков":

при определении переменной, которая предназначена чтобы позже удерживать объект, это рекомендуется инициализировать переменную к null в отличие от всего остального. Таким образом, вы можете явно проверить значение null определить, если переменная была заполнена объектом ссылка на более позднее время

вы можете принять конвенцию, предложенную здесь, но на самом деле нет никаких веских причин. Он не используется достаточно последовательно, чтобы быть значимым.

чтобы сделать соглашение полезным, вы сначала должны знать, что вызываемая функция следует за соглашением. Затем вы должны проверить возвращаемое значение и решить, что делать. Если вы получите неопределено, можно предположить, что какая-то ошибка чтобы вызываемая функция знала о. Но если произошла ошибка, и функция знала об этом, и полезно отправить это в более широкую среду, почему бы не использовать объект ошибки? т. е. бросить ошибку?

undefined-это то, где нет понятия вещи; он не имеет типа, и на него никогда не ссылались раньше в этой области; null-это то, где вещь, как известно, существует, но она не имеет значения.

каждый человек имеет свой собственный способ кодирования и свою собственную внутреннюю семантику, но на протяжении многих лет я обнаружил, что это самый интуитивный совет, который я даю людям, которые задают этот вопрос: когда вы сомневаетесь, делайте то, что делает JavaScript.

допустим, вы работаете со свойствами объекта, такими как параметры для плагина jQuery...спросите себя, какое значение JavaScript дает свойство, которое еще не определено - ответ undefined. Поэтому в этом контексте я бы инициализировал эти типы вещей с 'undefined' должны быть совместимы с JavaScript (для переменных вы можете сделать var myVar; вместо var myVar = undefined;).

теперь предположим, что вы делаете манипуляции DOM...какое значение JavaScript присваивает несуществующим элементам? Ответ null. Это значение я бы инициализировал, если вы создаете переменную-заполнитель, которая позже будет содержать ссылку на элемент, фрагмент документа или аналогичный, который относится к DOM.

если вы работая с JSON, необходимо сделать особый случай: для неопределенных значений свойств вы должны либо установить их в "" или null потому что значение undefined не считается правильным форматом JSON.

С этим сказано, как выразился предыдущий плакат, Если вы обнаружите, что инициализируете материал с null или undefined более одного раза в голубой луне, то, возможно, вы должны пересмотреть, как вы идете о кодировании вашего приложения.

узлы и элементы DOM не являются неопределенными, но могут быть null.

• nextSibling последнего дочернего элемента имеет значение null.

• Предыдущее значение первого дочернего элемента равно null.

• документ.ссылка getElementById имеет значение null, если элемент не существует в документе.

но ни в одном из этих случаев значение неопределено; там просто нет узла там.

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

весь смысл использования null-это просто привязка переменной или свойства с объектом,который является одноэлементным и имеет значение пустоты, а также использование 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)

Я работаю над этим точным вопросом прямо сейчас и смотрю на следующую философию:

1. любая функция, которая предназначена для возврата результата, должна возвращать null, если она не может найти результат
2. любая функция, которая не предназначена для возврата результата неявно возвращает undefined.

для меня этот вопрос важен, потому что у любого, кто вызывает функцию, которая возвращает результат, не должно быть вопроса о том, следует ли проверять undefined vs null.

этот ответ не пытаются решить:

1. значения свойств null vs undefined
2. переменные в ваших функциях null vs undefined

на мой взгляд, переменные-это ваш собственный бизнес, а не часть вашего API, и свойства в любой системе OO определены и поэтому должны быть определены со значением, отличным от того, что они будут, если не определены (null для defined, undefined - это то, что вы получаете, когда доступ к чему-то, что не находится в вашем объекте).

полезное свойство в null это неопределено не относится:

> null + 3
3
> undefined + 3
NaN

Я использую null когда я хочу "выключить" числовое значение, или инициализировать некоторые. Мое последнее использование было манипулирование CSS transform:

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

не уверен, что я должны использовать это свойство мысли...

вот почему: var undefined = 1 является законным javascript, но var null = 1 ошибка синтаксиса. Разница в том, что null - это ключевое слово языка, в то время как undefined это, по какой-то причине, нет.

если ваш код основан на сравнении с undefined как будто это ключевое слово (if (foo == undefined) -- очень простая ошибка), которая работает только потому, что никто не определил переменную с этим именем. Весь этот код уязвим для того, чтобы кто-то случайно или злонамеренно определил глобальную переменную с этим именем. Из конечно, мы все знаем, что случайное определение глобальной переменной совершенно невозможно в javascript...

в конце концов, потому что оба 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