Почему в JavaScript есть значение null?

В JavaScript есть два значения, которые в основном говорят: «Меня не существует» - undefinedи null.

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

Однажды я подумал, что нужна примитивная ценность и объект, nullпотому что это необходимо . Это не так, даже если приведет к получению : на самом деле, оба являются примитивными значениями - что означает, что ни одно из них не может быть возвращено из функции-конструктора, поскольку оба будут преобразованы в пустой объект (необходимо выдать ошибку, чтобы объявить сбой в конструкторах).undefinednulltypeof null'object'undefinednull

Они оба вычисляют значение falseв логических контекстах. Единственная реальная разница, о которой я могу думать, это то, что один оценивает NaN, а другой - 0в числовом контексте.

Итак, почему есть и то, undefinedи другое, и nullесли это просто сбивает с толку программистов, которые неправильно проверяют, nullпытаясь выяснить, установлено ли свойство или нет?

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

Таким образом, общее мнение, по-видимому, сводится к тому, что undefined«такого свойства нет», а nullзначит «свойство существует, но не имеет ценности».

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

На самом деле я использую, undefinedкогда хочу сбросить значения свойств, которые больше не используются, но которых я не хочу delete. Должен ли я использовать nullвместо этого?

На самом деле вопрос не в том, «почему в JS есть нулевое значение» - в большинстве языков есть какое-то нулевое значение, и оно обычно считается очень полезным.

Вопрос в том, «почему в JS есть неопределенное значение». Основные места, где он используется:

1. когда вы объявляете, var x;но не назначаете его, xсодержит undefined;
2. когда ваша функция получает меньше аргументов, чем объявляет;
3. когда вы обращаетесь к несуществующему свойству объекта.

nullнаверняка сработало бы так же хорошо для (1) и (2) *. (3) действительно должен сразу генерировать исключение, и тот факт, что он этого не делает, вместо того, чтобы возвращать этот странный undefinedсбой позже, является большим источником трудностей отладки.

*: вы также можете утверждать, что (2) должен вызывать исключение, но тогда вам придется предоставить лучший, более явный механизм для аргументов по умолчанию / переменных.

Однако в JavaScript изначально не было исключений или какого-либо способа спросить объект, есть ли у него член под определенным именем - единственный способ был (и иногда остается) получить доступ к члену и посмотреть, что вы получите. Учитывая, что у этого nullуже была цель, и вы вполне могли захотеть установить для нее член, требовалось другое внеполосное значение. Итак, у нас есть undefined, как вы указываете, это проблематично, и это еще одна замечательная «функция» JavaScript, от которой мы никогда не сможем избавиться.

На самом деле я использую undefined, когда хочу сбросить значения свойств, которые больше не используются, но которые я не хочу удалять. Должен ли я вместо этого использовать null?

Да. Сохранить undefinedкак специальное значение для сигнализации, когда другие языки могут вместо этого генерировать исключение.

nullобычно лучше, за исключением некоторых интерфейсов IE DOM, где установка чего-либо nullможет вызвать ошибку. Часто в этом случае работает пустая строка.

Лучше всего описано здесь , но вкратце:

undefined - это отсутствие типа и значения, а null - отсутствие значения.

Более того, если вы делаете простые сравнения «==», вы правы, они выходят одинаково. Но попробуйте ===, который сравнивает тип и значение, и вы заметите разницу.

Я не думаю, что есть какая-то причина иметь и то nullи другое undefined, потому что единственная причина, по которой многие люди предлагали (« undefinedозначает, что такой переменной / свойства нет»), недействительна, по крайней мере, в JavaScript. undefinedне могу сказать вам, существует ли переменная / свойство или нет.

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

Как видите, проверка foo === undefinedне говорит вам, fooсуществует ли , и настройка на obj.bar = undefinedсамом деле не удаляет bar.

Это может быть изначальное намерение автора JavaScript, которое undefinedдолжно представлять «небытие». Однако реализация оказалась не такой.

И то и другое вполне возможно. Например, если вы запрашиваете WMI, вполне возможно, чтобы свойства класса возвращали нулевое значение. Они определены, просто в то время они имеют значение null.

Я думаю, что ваш вывод о том, что JavaScript определяет undefinedкак «такого свойства нет» и nullкак «свойство не имеет значения», является совершенно правильным. И для такого динамичного языка, как JavaScript, это очень важное различие. Использование утки означает, что нам нужно различать свойство, которое не существует, и свойство, не имеющее значения. Это наш основной способ получения информации о типе. в статически типизированном языке существует явное различие между пустым полем и несуществующим полем. В JavaScript это ничем не отличается. Однако он проверяется во время выполнения и может быть изменен до этого времени.

Я должен согласиться с тем, что реализация странная, поскольку большую часть времени различия стираются. Однако я думаю, что в JavaScript различие важно. И уметь назначать undefinedочень важно.

Я помню, как недавно читал в блоге об онлайн-ролевой игре, написанной на JavaScript. В нем использовались примеры, в которых объекты создавались как копии существующих экземпляров, а не как прототипы (классы, функции и т. Д.), А затем были изменены. Это действительно помогло мне понять, насколько мощным это undefinedможет быть при изменении существующих объектов, но я не могу вспомнить, кто это написал.

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

Как программист на Java, я вижу огромную разницу между undefined и null. Кодирование JavaScript не так много, потому что JavaScript не является строго типизированным, а различия между undefined и null стираются из-за автоматических преобразований, которые часто выполняются во время выполнения. Кстати, я часто пользуюсь этими преобразованиями; они делают мой JS-код более компактным и читаемым.

Чтобы ответить на ваш вопрос, undefined означает, что значение никогда не устанавливалось. На практике это обычно указывает на ошибку. Если yourObject.property не определен, это означает, что вы по какой-то причине не установили свойство, или я ищу то, чего вообще не существует. Это настоящая проблема при работе над проектом с более чем одним кодировщиком.

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

В Java попытки доступа к неопределенному полю всегда приводят к исключению. Фактически, компилятор может предупреждать вас об этом в вашем коде.

Попробуйте этот пример:

<html>
<head>
    <script type="text/javascript">
        function ShowObjProperties(obj) {
            var property, propCollection = "";

            for(property in obj) {
                propCollection += (property + ": " + obj[property] + "\n");
            }

            alert(propCollection);
        }

        var obj = {
            userid: 3,
            name: 'me!',
            speak: function() { alert('Hi! My name is ' + this.name + ' and my ID is ' + this.userid + '.'); }
        }

        //Shows all properties
        ShowObjProperties(obj);

        //The Speak function is no longer in the list!
        delete obj.speak;
        alert(typeof obj.speak);
        ShowObjProperties(obj);

        //The UserID is still listed, it just has no value!
        obj.userid = null;
        ShowObjProperties(obj);
    </script>
</head>
<body>

</body>
</html>

Я думаю, что здесь есть реальное применение двум различным типам.

Все сводится к динамической природе javascripts.

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

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

// a key exists as a placeholder for something
if(obj[name] === null) 
// no key exists int eh hashtable that is in this object
if(obj[name] === undefined)

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

filter_func_pt = {
  date:function(d){ return Math.round(d.getTime()/1000);},
  user: null,
}

function transform(obj){
    var ret = {};
    for( var prop in obj){
       var f = filter_func_pt[prop];
       if(f)
          ret[prop] = f(obj);
       else if(filter_func_pt[prop] === null)
         continue;
       else
         ret[prop] == obj;
    }
  return ret;
}

var a = {
   date: new Date(),
   user: 'sam'
   votes: [23, 41, 55] 
};

var b = transform(a);

/* b = {
 *    date: 1298582417
 *    votes: [23, 41, 55]
 * }
 */

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

null прекрасен

как и все другие типы Live Script.

cite: В JavaScript есть два значения, которые в основном говорят «Я не существую» - undefined и null.

Почему вы хотите говорить неправильные вещи ?!

«null» - это «пустой объект», так же как «0» - «пустое число» . 0 - это ничто, но существует как Тип числа. null, конечно, тоже пуст, но «он есть», и это четко определенная вещь объектного типа .

Об этих вещах принято говорить как о «типах», хотя это не так. Фактически это «категории». Но теперь все кончено.

Так что буду придерживаться его, чтобы сказать, что «null» - это тип объекта без вида. А «null» говорит: «Я очень много существую [!], Но у меня нет контента моего типа».

В то время как undefined не хватает как типа, так и вида, где undefined также является его определением типа. Неопределенный тип типа становится его отличительной типологией. Что-то вроде вопроса [существует ли «ничего» и как вы определяете «ничего»?].

cite: undefined и null не могут быть возвращены из функции-конструктора, так как оба будут преобразованы в пустой объект

Вы умудрились в очередной раз сказать неверную вещь. Конечно, нет, «undefined» - это не объект, это простой токен, который мы, люди, понимаем; но вопреки этому null - и он говорит вам, что: его Тип правильный, но Тип, который вы ищете, не содержится в нем или, по крайней мере, в настоящее время. Приходите к нам позже, когда мы поставим \ присвоим ему какой-нибудь объект \.

cite: Единственная реальная разница, о которой я могу думать, заключается в том, что один оценивает NaN, а другой - 0 в числовом контексте.

В этом вся суть их основного различия, как уже упоминалось: undefined - это простой токен, и поскольку он состоит из того же «генетического» материала, что и его дальние родственники: строки, операция [+ undefined] преобразует его в NaN, аналогично null, конечно, вместо этого превратится в правильный тип 0 \ Number, и в отличие от undefined , который превратится в строку (! Которая не пуста!), И именно поэтому вместо этого она дает NaN . Где: + undefined >> + "undefined" >> NaN. Поскольку числовой контекст ожидает явного значения.

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

Давай прорежем сейчас ...

cite: Итак, еще раз: каково практическое использование отдельных значений для undefined и null?

Я постараюсь привести только два эмпирических примера и надеюсь, что их хватит.

oElement.onclick >> null

// означает - свойство существует; его ожидаемое значение имеет тип: Object , и этот oElement поддерживает событие «onclick»!

oElement.innerText >> ""

// означает - свойство существует; его ожидаемое значение имеет тип: String , что означает, что oElement поддерживает свойство «innerText».

в обоих случаях - если вы получили «undefined», это означает, что свойство не существует; не поддерживается или имеет неправильную реализацию (поставщик ua).

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

после прочтения удивительного обсуждения undefined и null, небольшой поиск в Google привел меня к Mozilla Documentations https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null, это упоминается - null часто извлекается в месте, где можно ожидать объект, но ни один объект не имеет значения.

Не похож на шаблон объекта Null https://en.wikipedia.org/wiki/Null_object_pattern

Итак, я думаю, имеет смысл иметь тип данных Null.

Документация также упоминается как typeof null // "объект" (не "null" по устаревшим причинам)

Не уверен, какие унаследованные причины