В чем разница между null и undefined в JavaScript?

Я хочу знать, в чем разница между null и undefined в JavaScript.

30 ответов


В JavaScript undefined означает, что переменная объявлена, но ей еще не присвоено значение, например:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

null является значением назначения. Его можно назначить переменной как представление без значения:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

из предыдущих примеров ясно, что undefined и null есть два разных типа:undefined сам тип (неопределенный) в то время как null - это объект.

null === undefined // false
null == undefined // true
null === null // true

и

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Я выбрал это из здесь

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

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

когда вы объявляете переменную через var и не даете ей значение, она будет иметь значение undefined. Само собой, если вы попытаетесь WScript.Echo() или alert () это значение, вы не будете ничего видеть. Однако, если вы добавите к нему пустую строку, то внезапно она появится:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

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

вы даже можете сравнить переменную, которая не определена в null или наоборот, и условие будет истинным:

undefined == null
null == undefined

они, однако, считаются двумя разными типами. В то время как undefined-это тип все для себя, null считается специальным значением объекта. Вы можете увидеть это, используя typeof (), который возвращает строку, представляющую общий тип переменной:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

запуск вышеуказанного скрипта приведет к следующему результату:

undefined
object

независимо от того, что они разные типы, они все равно будут действовать одинаково, если вы попытаетесь получить доступ к члену любого из них, например, то есть они будут выдавать исключение. С WSH вы увидите страшный "varname" - это null или не объект", и это, если Вам повезет (но это тема для другой статьи).

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

еще один экземпляр, где вы увидите неопределенное всплывающее окно при использовании оператора delete. Те из нас, кто из C-мира, могут неправильно интерпретировать это как уничтожение объекта, но это не так. Эта операция удаляет индекс из массива или элемент из объекта. Для массивов это не влияет на длину, а скорее на то, что индекс теперь считается не определено.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

результат выше скрипт:

0.) a
1.) undefined
2.) c

вы также получите неопределенный возврат при чтении индекса или члена, который никогда не существовал.

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


null - это специальное ключевое слово, которое указывает на отсутствие значения.

думать о ней как о ценности, как:

  • " foo " - это строка,
  • true является логическим,
  • 1234-номер,
  • null неопределено.

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

var foo;

определена пустая переменная null типов undefined


оба они представляют собой значение переменной-значение

и null не являются строка это не имеет значения-пустая строка -


как

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

теперь, если

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

но

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

так каждый из них имеет свой собственный способ использования

undefined используйте его для сравнения типа данных переменной

null используйте его, чтобы очистить значение переменной

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null: отсутствие значения для переменной;undefined: отсутствие самой переменной;

..где variable-символическое имя, связанное со значением.

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


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

в JavaScript мы можем иметь следующие типы переменных.

  1. Необъявленные Переменные
  2. объявленные, но неназначенные переменные
  3. переменные, назначенные литералом undefined
  4. переменные, назначенные с literal null
  5. переменные назначены с undefined или null

следующее объясняет каждый из этих случаев один за другим

  1. Необъявленные Переменные: для необъявленных переменных

    • можно проверить только typeof () что возвращает строку 'undefined'
    • невозможно проверить с помощью == или === или Если или условный оператор ? (выдает ошибку ссылки)
  2. объявленные, но неназначенные переменные

    • typeof на возвращает строку 'undefined'
    • == чека с null возвращает true
    • == чека с undefined возвращает true
    • === чека с null возвращает false
    • === чека с undefined возвращает true
    • Если или условный оператор ? возвращает false
  3. переменные, назначенные литералом undefined: эти переменные рассматриваются так же, как Объявленные, Но Неназначенные Переменные.

  4. переменные, назначенные литералом null

    • typeof на возвращает строку 'object'
    • == чека с null возвращает true
    • == чека с undefined возвращает true
    • === чека с null возвращает true
    • === чека с undefined возвращает false
    • Если или условный оператор ? возвращает false
  5. переменные назначены с undefined или null

    • typeof возвращает одну из следующих строк: 'string','количество', 'boolean','', 'object','символ'

Ниже приведен алгоритм правильной проверки типа переменной:

  1. проверить незаявленных/неназначенные/назначен с undefined используя typeof на. возврат, если строка 'undefined' возвращается.
  2. проверить null используя ===. возвращение 'null' Если true.
  3. Проверьте фактический тип с помощью typeof на. тип возврата если не равно 'object'
  4. вызов

Undefined означает, что переменная была объявлена, но не имеет значения:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null-это назначение:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

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

через JavaScript: окончательное руководство


я объясню undefined, null и Uncaught ReferenceError:

1 - Uncaught ReferenceError : переменная не было объявлено в вашем скрипте нет ссылки на этот varaible
2 - undefined: переменная объявлена, но не инициализирована
3 - null: переменная объявлена и является пустым значением


null и undefined являются двумя различными типами объектов, которые имеют следующее общее:

  • оба могут содержать только одно значение,null и undefined соответственно;
  • оба не имеют свойств или методов, и попытка прочитать любые свойства любого из них приведет к ошибке во время выполнения (для всех других объектов вы получаете значение undefined если вы пытаетесь прочитать несуществующий собственность);
  • значения null и undefined считаются равными друг другу и ничему другому == и != операторы.

сходства, однако, заканчиваются здесь. На этот раз, есть фундаментальная разница в том, как ключевые слова null и undefined есть. Это не очевидно, но рассмотрим следующий пример:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

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

теперь давайте попробуем то же самое с null:

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Упс! null, правда и false зарезервированы ключевые слова - компилятор не позволит вам использовать их как переменную или свойство имена

другое отличие в том, что undefined - это примитивный тип, а null - тип объекта (указывает на отсутствие ссылки на объект). Рассмотрим следующее:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

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

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null становится 0 при использовании в арифметических выражения или числовые сравнения-аналогично false, это в основном просто особый вид "нуля". undefined, С другой стороны, является истинным "ничто" и становится Нэн ("не число") при попытке использовать его в числовом контексте.

отметим, что null и undefined получите специальное обращение от == и != операторы, но вы можете проверить истинное числовое равенство a и b выражение (a >= b && a <= b).


tl; dr

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

использовать undefined для установки переменной, тип которой смешан.


это мое использование как 5 примитивов, так и типа объекта, и это объясняет разницу между "прецедентом"undefined или null.

строка

если вы знаете, что переменная является только строкой, а весь жизненный цикл, по соглашению, вы можете инициализировать ее, чтобы "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

если вы знаете, что переменная-это только число, в то время как весь жизненный цикл, по соглашению, вы можете инициализировать его, чтобы 0 (или NaN если 0 важное значение в эксплуатации):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

или

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Boolean

если вы знаете, что переменная является только логической, а весь жизненный цикл, по соглашению, вы можете инициализировать ее, чтобы false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

объект

если вы знаете, что переменная является только объектом, а весь жизненный цикл, по соглашению, вы можете инициализировать его, чтобы null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Примечание: интеллектуальное использование off null должно быть ложь версия объекта, потому что объект всегда true, а потому typeof null возвращение object. Это значит typeof myVarObject возвращает согласованное значение для объекта и null тип.

все

если вы знаете, что переменная имеет смешанный тип (любой тип в течение всего жизненного цикла), по соглашению вы можете инициализировать ее, чтобы undefined.


null - ключевое слово языка, которое вычисляет специальное значение, обычно используемое для указывает на отсутствие значения. Использование оператора typeof в null возвращает строку "объект", указывающий, что null можно рассматривать как специальное значение объекта, которое указывает "ни один объект." На практике, однако, null обычно рассматривается как единственный член собственный тип, и его можно использовать для указания "нет значения" для чисел и строк, а также объекты. Большинство языков программирования иметь эквивалент null JavaScript: вы можете будьте знакомы с ним как null или nil.

JavaScript также имеет второе значение, что указывает на отсутствие значения. The undefined значение представляет собой более глубокий вид отсутствия. Это значение переменных, которые не были инициализировано и значение, которое вы получаете при запросе значения свойства объекта или массива элемент, который не существует. Неопределенное значение также возвращается функциями, которые имеют нет возвращаемого значения, и значение параметров функции, для которых аргумент не указан. undefined-это предопределенная глобальная переменная (а не ключевое слово языка, например null), которая инициализируется неопределенным значением. В ECMAScript 3 undefined является переменной чтения / записи, и его можно установить на любое значение. Эта ошибка исправлена в ECMAScript 5 и undefined доступен только для чтения в этой версии языка. Если вы применяете оператор typeof к неопределенному значению он возвращает "undefined", указывая, что это значение является единственным член особого типа.

несмотря на эти различия, null и undefined указывают на отсутствие значения и часто может использоваться взаимозаменяемо. Оператор равенства == считает их равными. (Используйте оператор строгого равенства ===, чтобы различать их.) Оба являются ложными ценностями-они ведут себя как false, когда требуется логическое значение. Ни null, ни undefined не имеют любые свойства или методы. На самом деле, используя . или [] для доступа к свойству или методу этих значения вызывает Ошибку TypeError.

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


null - специальное значение, означающее "нет значения". null является специальным объектом, потому что typeof null возвращает 'object'.

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


в JavasSript есть 5 примитивных типов данных String, Number, Boolean, null и undefined. Я попытаюсь объяснить на простом примере

допустим, у нас есть простая функция

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

также В приведенной выше функции, если (a == null) такое же, как если бы(!а)

теперь, когда мы вызываем эту функцию без передачи параметра

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

и

var a;
alert(typeof a); 

это даст undefined; мы объявили переменную, но мы не присоединена любое значение этой переменной; но если мы напишем

var a = null;
alert(typeof a); will give alert as object

таким образом, null является объектом. в некотором смысле мы присвоили значение null 'a'


Как Null, так и undefined в JavaScript указывают на отсутствие значения.

var a = null; //variable assigned null value
var b;  // undefined

несмотря на то, что оба существуют для отсутствия значения, но: Undefined фактически означает, что переменная не инициализирована. Функции, которые возвращают nothing и параметры функции, для которых не задано значение, возвращается неопределенное значение. Используйте оператор строгого равенства === to различать null и undefined.

ссылка: http://www.thesstech.com/javascript/null-and-undefined


хорошо, мы можем запутаться, когда услышим о null и undefined, но давайте начнем с простого, они оба фальшивые и похожи во многом, но странная часть JavaScript, делает их пару существенных различий, например, typeof null и 'object' в то время как typeof undefined is 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

но если вы проверите их с == как показано ниже, вы видите, что они оба фальшивы:

null==undefined; //true

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

Я создаю быстрое изображение, чтобы показать различия для вас с первого взгляда.

Null and Undefined


поскольку typeof возвращает undefined, undefined-это тип, где as null-инициализатор указывает, что переменная указывает на отсутствие объекта (практически все в Javascript является объектом).


null и undefined оба используются для представления отсутствия какого-либо значения.

var a = null;

a инициализируется и определенными.

typeof(a)
//object

null является объектом в JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b не определено и неинициализировано

неопределенные свойства объекта также не определены. Например, " x " не определен на объекте c, и если вы пытаетесь получить доступ к c.x, он вернется неопределенным.

обычно мы присваиваем null переменным не не определено.


на undefined type, есть одно и только одно значение:undefined.

на null типа, есть одно и только одно значение: null.

так для них обоих, метка - это как ее тип, так и ее значение.

разница между ними. Например:

  • null является пустым значением
  • undefined отсутствует значение

или:

  • undefined еще не имеет значения
  • null имел значение и больше не

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

однако, undefined это идентификатор. В обоих non-strict режим и strict режим, однако, вы можете создать локальную переменную с именем не определено. Но это одна ужасная идея!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

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

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

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


лучший способ понять разницу - сначала очистить свой ум от внутренней работы JavaScript и просто понять различия в значении между:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

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

Итак, каковы некоторые из специфичных для JavaScript вопросы, которые возникают из-за этой философской основы?

  1. объявленная переменная без инициализатора получает значение undefined потому что вы никогда ничего не говорили о том, что предполагаемое значение было.

    let supervisor;
    assert(supervisor === undefined);
    
  2. свойство объекта, который никогда не был установлен, оценивается в undefined потому что никто никогда ничего не говорил об этом свойстве.

    const dog = { name: 'Sparky', age: 2 };
    assert(dog.breed === undefined);
    
  3. null и undefined "похожи" друг на друга потому что так сказал Брендан Эйч. Но они явно не равны друг другу.

    assert(null == undefined);
    assert(null !== undefined);
    
  4. null и undefined к счастью, есть разные типы. null относится к типу Null и undefined типа Undefined. Это в спецификации, но вы никогда не узнаете об этом из-за typeof странности, которые я не буду повторять здесь.

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

кстати, в JavaScript есть и другие формы "небытия" (хорошо, что изучали философию....)

  • NaN
  • использование переменной, которая никогда не была объявлена и получения ReferenceError
  • С помощью let или const определенная локальная переменная в ее временной мертвой зоне и получение ReferenceError
  • пустой ячейки в разреженных массивах. Да это даже не undefined хотя они сравнивают === в undefined.

    $ node
    > const a = [1, undefined, 2]
    > const b = [1, , 2]
    > a
    [ 1, undefined, 2 ]
    > b
    [ 1, <1 empty item>, 2 ]
    

null - это значение присваивания. Который используется с переменной для представления значения no. (его объект)

undefined - это переменная, которой не присвоено какое-либо значение. Таким образом, javascript назначит ему неопределенное. (его тип данных)

незаявленных - если переменная вообще не создана, она называется необъявленной.


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


в тщательной статье Райана Морра на эту тему...

" Как правило, если вам нужно назначить не-значение переменной или свойству, передать его функции или вернуть его из функции, null почти всегда является лучшим вариантом. Проще говоря, JavaScript использует undefined и программисты должны использовать null."

посмотреть исследование вечной Бездны Null и Undefined


С JavaScript null для объектов, undefined для переменных, свойств и методов.

чтобы быть null, объект должен быть определен, иначе он будет неопределенным.

Если вы хотите проверить, существует ли объект, это вызовет ошибку, если объект не определен:

неправильно:

if (myObj !== null && typeof myObj !== "undefined") 

из-за этого вы должны сначала протестировать typeof ():

правильно:

if (typeof myObj !== "undefined" && myObj !== null) 

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

 var myVariable = ''; 

переменная myVariable пуста, но она не является нулевой.

Undefined это состояние, иногда используется как значение, для представления переменной, которая еще не содержала значение. такие как var abcd; . Это состояние отличается от null, хотя null и undefined могут вычисляться одинаково.


  • undefined означает, что переменная была объявлена, но ей еще не присвоено значение.
  • null - это присвоение значения. Он может быть назначен переменной как представление без значения.
  • undefined и null есть два разных типа:

undefined-это сам тип (неопределено) в то время как null является объектом.

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

по сути, неопределено - глобальная переменная, которую javascript создает во время выполнения, означает ли null, что переменная не имеет значения (на самом деле null сам является объектом).

рассмотрим пример:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

неопределено вот что вы получите на выходе.

теперь

        x=5;
        y=null;
        z=x+y;

и вы получите 5 как выходной. Это главное различие между неопределено и null


в javascript все переменные хранятся как пары ключевых значений. Каждая переменная хранится как variable_name: variable_value/reference.

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

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

оба похожи, но использование и значение различны.


Если переменная не инициализирована, то она не определена. undefined не является объектом. Пример: var MyName; приставка.log (typeof MyName);

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

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

пример: var MyName = null; приставка.log (typeof MyName); Проверьте инструмент разработки журнала csole, это будет объект.


просто чтобы добавить мои взгляды -

переменная, которая объявлена только и никогда нигде не используется, удаляется оптимизирующим компилятором в случае скомпилированных языков, таких как C++[или предупреждение помечено в IDE]. В конечном счете это означает, что переменная не существует, потому что ее память никогда не выделяется.

в случае интерпретатора javascript [я думаю] переменная рассматривается как существующая только с той точки, где ей задано значение. До этого момента, это тип "undefined", и для него не выделяется память. И, таким образом, его тип не определен.

a null в javascript is значение, представляющее адрес, но этот адрес не указывает ни на что еще[несуществующая ссылка]. Тем не менее, это ценность.