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

https://stackoverflow.com/questions/461966

19-08-2019
|

Вопрос

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

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

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

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

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

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

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

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

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

Решение

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

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

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

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

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

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

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

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

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

Другие советы

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

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

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

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

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

Как видите, проверка obj.bar = undefined не показывает, существует ли bar, а настройка <=> фактически не удаляет <=>.

Это может быть первоначальное намерение автора JavaScript, что <=> должно представлять " небытие " ;. Однако реализация оказалась не такой.

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

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

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

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

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

Как программист на Java, я вижу огромную разницу между неопределенным и нулевым. Кодирования 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>

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

Все сводится к динамическому характеру JavaScript.

Вещи могут быть неопределенными, чтобы их можно было добавить позже. Возможно, именно поэтому 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 и сервер undefined очень понятны и имеют разные цели. поиск, который не найден в объекте filter_func_pt, который возвращает undefined , означает добавление свойства к возвращаемому объекту как есть, тогда как значение null указывает, что значение должно быть удержано и не добавляется, и наличие любого истинного значения в этом случае представляет функцию, используемую для преобразования значения перед добавлением его в объект ret .

ноль прекрасен

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

cite: в JavaScript есть два значения, которые в основном говорят: «Я не существовать '- неопределенное и нулевое.

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

" null " равно " пустой объект " так же, как " 0 < !> Quot; " пустой номер " . 0 - это ничто, но оно существует как вещь типа числа. null , конечно, тоже пусто, но " это " и это хорошо определенная вещь типа объекта .

Об этих вещах принято говорить как о & типах &, когда их нет. На самом деле они являются & Категориями &. Но теперь все кончено.

Так что придерживайтесь этого, чтобы сказать, что " null " Тип объекта без вида И & Quot; null & Quot; говорит " я очень существую [!], но у меня нет контента моего вида ".

В то время как undefined не хватает как Type, так и Kind, где undefined также является его определением Type. Неопределенный тип типа становится его отличительной типологией. Своего рода [не делает & Ничего; "&" существует и как вы определяете " ничто " ;?] вопрос.

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

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

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

В этом и заключается смысл их основного различия, как упоминалось: undefined является простым токеном, и поскольку он состоит из того же «генетического» материала, что и его дальние родственники: строки, [ + undefined] операция преобразует его в NaN, аналогично null, конечно, вместо этого превратится в правильный тип 0 \ Number, а в отличие от undefined , который превратится в строку (! не пустой!) и именно поэтому вместо этого он возвращает NaN . Где: + undefined & Gt; & Gt; & + Quot; & Не определено Quot; GT &; ГТ &; NaN. Поскольку числовой контекст ожидает явного значения.

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

Давайте разберемся сейчас ...

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

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

oElement.onclick >> null

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

oElement.innerText >> ""

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

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

Оставайся морозным и веселись.

после прочтения удивительной дискуссии о неопределенности против нуля, небольшой поиск в Google привел меня к документации по Mozilla https://developer.mozilla.org/en- США / документы / Web / JavaScript / Справка / Global_Objects / нуль это упомянуто - Нуль часто получается в месте, где можно ожидать объект, но ни один объект не является релевантным.

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

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

Документация также упоминается как typeof null // " object " (не " null " по старым причинам)

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow