Почему в JavaScript есть значение '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 не говорит ли вам , а параметр obj.bar = undefined на самом деле не удалить bar.

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

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

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

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

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

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

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

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

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

In 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 различных типов здесь.

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

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

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

null красиво

как и все другие типы живых сценарий.

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

почему вы хотите сказать неправильные вещи?!

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

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

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

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

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

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

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

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

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

идем сейчас...

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

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

oElement.onclick >> null

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

oElement.innerText >> ""

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

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

оставайтесь Мороз и получайте удовольствие.

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

Isn't похож на шаблон нулевого объекта https://en.wikipedia.org/wiki/Null_object_pattern

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

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

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