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

Ответ 1

Null и undefined являются по существу двумя разными значениями, которые означают одно и то же. Единственное различие заключается в соглашениях о том, как вы их используете в своей системе. Как уже отмечалось, некоторые люди используют null для значения "no object", где вы иногда можете получить объект, а undefined означает, что объект не ожидался (или произошла ошибка). Моя проблема заключается в том, что она полностью произвольна и совершенно не нужна.

Тем не менее, существует одно существенное отличие - переменные, которые не инициализированы (включая параметры функции, в которых аргумент не передавался, между прочим) всегда undefined.

Вот почему в моем коде я никогда не использую null, если только что-то, что я не контролирую, возвращает null (например, сопоставление регулярных выражений). Красота этого заключается в том, что он очень сильно усваивает вещи. Мне никогда не нужно проверять, есть ли x === undefined || x === null. И если вы привыкли использовать == или просто такие вещи, как if (x).... Прекрати это. !x будет оценивать значение true для пустой строки, 0, null, NaN - т.е. вещи, которые вы, вероятно, не хотите. Если вы хотите написать javascript, который не является ужасным, всегда используйте triple equals === и никогда не используйте null (вместо этого используйте undefined). Это облегчит вам жизнь.

Ответ 2

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

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

Ответ 3

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

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

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

Ответ 4

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

Ответ 5

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

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

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

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

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

Ответ 6

В конце дня, поскольку как null и undefined приводят к одному и тому же значению (Boolean(undefined) === false && Boolean(null) === false), вы можете технически использовать любой из них, чтобы выполнить работу. Тем не менее, есть верный путь, ИМО.

1. Оставьте использование undefined для компилятора JavaScript.

   undefined используется для описания переменных, которые не указывают на ссылку. Это то, что компилятор JS позаботится о вас. Во время компиляции движок JS установит значение всех перемещенных переменных на undefined. Когда двигатель проходит по коду и значения становятся доступными, двигатель назначит соответствующие значения соответствующим переменным. Для тех переменных, для которых не найдено значений, переменные будут продолжать поддерживать ссылку на примитив undefined.

2. Используйте null, только если вы явно хотите обозначить значение переменной как "без значения".

   Как @com2gz заявляет: null используется для определения чего-то программно пустого. undefined означает, что ссылка не существует. null значение имеет определенную ссылку на "ничто". Если вы вызываете несуществующее свойство объекта, вы получите undefined. Если бы я сделал это свойство намеренно пустым, то оно должно быть null чтобы вы знали, что оно намеренно.

TL;DR; Не используйте undefined примитив. Это значение, которое JS-компилятор автоматически установит для вас, когда вы объявляете переменные без присваивания или пытаетесь получить доступ к свойствам объектов, на которые нет ссылок. С другой стороны, используйте null тогда и только тогда, когда вы намеренно хотите, чтобы переменная не имела значения.

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

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

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

Ответ 7

Узлы и элементы DOM не undefined, но могут быть нулевыми.

• СледующийСнижение последнего дочернего элемента элемента равно null.

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

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

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

Ответ 8

Полезное свойство в null, которое undefined не квалифицирует:

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

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

Ответ 9

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

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

Ответ 10

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

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

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)

Ответ 11

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

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

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

Этот ответ не пытается адресовать:

• Значения свойств null vs undefined
• Переменные в ваших функциях равны нулю vs undefined

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

Ответ 12

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

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

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

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

Ответ 13

Просто хочу добавить, что с использованием определенных библиотек JavaScript, null и undefined могут иметь непредвиденные последствия.

Например, функция lodash get, которая принимает значение по умолчанию в качестве третьего аргумента:

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"