Верно ли что null undefined

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

В то же время, null и undefined будут считать равными, напр.:

var x = null; var y; if (x == y) < // выполнится >

Отслеживать
51.4k 86 86 золотых знаков 267 267 серебряных знаков 505 505 бронзовых знаков
ответ дан 21 янв 2011 в 19:09
622 4 4 серебряных знака 12 12 бронзовых знаков

Однако, null === undefined даст false, так что не следует думать, будто эти вещи одно и то же. К тому же, у них разные типы. null — это объект (хотя и идёт речь о его отсутствии), а undefined и имеет тип «undefined»

21 янв 2011 в 21:28

Вот так отличается их поведение:

null >= 0 -> true null == 0 -> false null true null > 0 -> false null < 0 ->false null - 0 = 0 undefined >= 0 -> false undefined == 0 -> false undefined false undefined > 0 -> false undefined < 0 ->false undefined - 0 = NaN undefined >= null -> false undefined == null -> true undefined false 

Отслеживать
51.6k 201 201 золотой знак 63 63 серебряных знака 245 245 бронзовых знаков
ответ дан 25 мар 2019 в 13:31
Another User Another User
29 2 2 бронзовых знака
тогда уж было бы не плохо написать почему такие результаты.
25 мар 2019 в 14:32
javascript.ru/ecma/part11 вот тут можно найти информацию. В частности — алгоритмы сравнения.
26 мар 2019 в 8:55
И эта информация нужна в ответе, а не просто непонятный блок кода.
26 мар 2019 в 9:07

Отличие Null и Undefined

1. Вообще появление в JS 2х типов данных обозначения отсутствия значения — это ошибка проектирования языка, и насколько я знаю ни в одном другой языке программирования нет 2х типов обозначающих отсутствие значения.
2. Undefined задается по умолчанию при объявлении переменной, когда мы еще на задали ей какое-то значение (т.е неопределенное отсутствие значения), а Null мы можем только задать (т.е является определённым значением отсутствия).
3. Null — в typeof это object , а undefined — это undefined .
4. JSON — может работать с Null но не может с Undefined .
5. А еще Null и Undefined при нестрогом сравнении равны друг другу, равны самим себе, и больше ничему. Они являются в логической интерпретации как false , но при сравнении они не равны false .
6. Использование — обычно undefined не задают, а если он приходит — а мы ожидали какое-то значение, то где-то есть баг. А Null — задают целенаправленно.

Отслеживать
ответ дан 28 ноя 2023 в 20:57
29 1 1 бронзовый знак

Только что проведенный тест в консоли Firefox дал странный результат:

var a = null; var b; alert(a+'/'+b+'/'+(typeof(a)==typeof(b))+'/'+(a==b)); // null/undefined/false/true alert(c); // ошибка, как и с "b==c" и "if (c) <>" 

Я не знаю, как это объяснить с т.з. логики. Видимо, как-то различаются «объявленный undefined»(b) и «совсем undefined»(c), при этом типы null и undefined не равны, но значения их равны(видимо, потому что пустые). Однако, вам должно быть интересно, что ошибок с необъявленной переменной не вызовет только конструкция «if (typeof(c)==’undefined’) <>«

Почему у Null и Undefined нет прототипа и почему у других типов они именно такие?

Здравствуйте
Разбираюсь с прототипами и возникают вопросы:
1. Почему у типов Null и Undefined нет прототипа? Вроде как всё создается конструкторами. Как посмотреть что у них внутри?
Вот примитивные типы JS

вот что показывает консоль для всех примитивных типов кроме Null и Udefined

те оно как бы и понятно, показывает функцию-конструктор, а вот при попытке написать Undefined или Null, говорит, что знать такого не знает.
Почему так?

• Вопрос задан более трёх лет назад
• 118 просмотров

12 комментариев

Простой 12 комментариев

G F @fomenkogregory
Потому что в этом нет смысла. Прототипы содержат общие методы, у null и undefined нет методов.

G F @fomenkogregory
Да и вообще у примитивных типов нет конструкторов. У некоторых из них есть лишь объекты-обертки.
alexalexes @alexalexes
А зачем значениям, которые выступают в роли «затычек пустоты и неопределенности» прототипы?
Ostic @Ostic Автор вопроса
alexalexes, а каким образом они создаются тогда?
Ostic @Ostic Автор вопроса

G F,
как тогда вот это объяснить?

G F @fomenkogregory
Ostic, они не создаются, это просто значения
(. hope I’m right -_-)

G F @fomenkogregory
Ostic, это wrapper objects

Aetae @Aetae Куратор тега JavaScript

Ostic, при попытке вызова метода(/получении свойства) у примитива, примитив неявно оборачивается в соответствующий объект. ‘string’.charAt(0) -> new String(‘string’).charAt(0)
Нет соответствующего объекта — получи ошибку.

Естесно это всё на уровне самого языка и максимально оптимизировано. Явно этого делать не надо.

G F @fomenkogregory
У null и undefined их нет потому что в этом нет смысла
Ostic @Ostic Автор вопроса

G F, примитивы, они как бы и не примитивы

G F @fomenkogregory
Ostic, ок, 3 раз напишу — погугли wrapper objects. Впрочем Аетае написал уже
dmitry-toster @dmitry-toster

Почему у Null и Undefined нет прототипа

дык потому что прототип есть только у объектов
Решения вопроса 1

Дмитрий Беляев @bingo347 Куратор тега JavaScript
Crazy on performance.

Потому что прототипы есть только у объектов, то есть у сущностей (entity) для которых верно typeof entity === ‘object’ Правда тут есть одно исключение — в спеке нет типа function, а во всех реализациях он есть по историческим причинам. То есть с точки зрения спеки: typeof function()<> === ‘object’ а на деле: typeof function()<> === ‘function’ Поэтому правильное тождество будет такое:

typeof entity === 'object' || typeof entity === 'function'

У остальных типов прототипа нет, в чем можно легко убедится

1 instanceof Number 1 instanceof Object 'a' instanceof String 'a' instanceof Object true instanceof Boolean true instanceof Object 1n instanceof BigInt 1n instanceof Object Symbol() instanceof Symbol Symbol() instanceof Object null instanceof Object undefined instanceof Object

все эти выражения ложны, а как известно instanceof проверяет именно прототипы.

А для того чтоб работали методы для большинства этих типов есть объектные обертки, к которым присутствует неявное приведение при обращении к свойствам через точку или квадратные скобки. Эти обертки не сложно получить передав данные примитивы в Object как функцию, а не как конструктор:

Object(1) instanceof Number Object(1) instanceof Object Object('a') instanceof String Object('a') instanceof Object Object(true) instanceof Boolean Object(true) instanceof Object Object(1n) instanceof BigInt Object(1n) instanceof Object Object(Symbol()) instanceof Symbol Object(Symbol()) instanceof Object

все эти выражения истинны.
Однако надо понимать, что обертка — это уже не примитив:

typeof Object(1) === 'object' typeof Object('a') === 'object' typeof Object(true) === 'object' typeof Object(1n) === 'object' typeof Object(Symbol()) === 'object'

это все так же истинно.

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

null.property // TypeError: Cannot read property 'property' of null undefined.property // TypeError: Cannot read property 'property' of undefined

Null, ноль и Undefined: разбираемся в сортах пустоты

Может показаться, что null — это название переменной, но на самом деле это специальное значение, которое означает, что переменная есть, но в переменной ничего нет. Кроме этого, есть ещё одно интересное состояние переменной — undefined , которое означает, что переменная не определена. Давайте разберёмся, в чём разница и для чего это всё нужно.

Минутка информатики. Если копать совсем глубоко, то в переменной не всегда лежат именно те данные, которые мы туда отправили.

Чаще всего при объявлении переменной компьютер выделяет сколько-то байтов в памяти, в которые можно записать любое помещающееся значение. Но это работает только для простых переменных — чисел и символов (которые внутри тоже числа). Если нам нужна строка, которая состоит из множества символов, или массив, то в переменной хранится не значение, а только ссылка на область памяти, в которой лежат наши данные. В этих случаях переменная — это карта, которая объяснит компьютеру, где найти всё остальное.

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

Что такое undefined

Когда мы только создаём переменную без явного указания типа и ничего в неё не кладём, то компьютер многого не знает:

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

Чтобы пометить себе, что пока ничего не ясно, компьютер помечает эту переменную как undefined , что означает «неопределённость»:

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

Представьте, что вы занимаетесь уборкой и вам говорят: «Возьми мешок». Что это значит? Пока неясно: это мешок для мусора или вещей; какого объёма; полный или пустой. Просто «мешок». Если представить, что мешок — это переменная, то undefined мешок — это как раз «просто некий мешок, без уточнения».

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

Зачем нужен undefined

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

Что такое null

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

Допустим, мы хотим обратиться к элементу на странице по его id. Для этого мы сначала заводим переменную element, и на старте она будет определяться как undefined. После этого мы присваиваем этой переменной ссылку на нужный элемент, но если этого элемента на странице нет, то произойдёт такое:

1. Скрипт попытается найти элемент на странице.
2. После того как он убедится, что элемента нет, он вернёт null — это значит, что на странице ничего такого нет.
3. Это значение null отправится в переменную element, и у неё появится определённое значение null.

Если вспомнить наш мешок во время уборки:

— undefined — это когда вы ничего не знаете про мешок — даже то, есть ли этот мешок в принципе или его нужно пойти и где-то купить;

— null — это когда вы знаете, что мешок есть, он определённого размера и формы, но он точно пустой и даже ещё не раскрытый;

В некоторых языках, например Python, вместо null используют None — это тоже значение переменной, которое означает, что в переменной ничего нет, но сама переменная определена верно.

Undefined и null — это одно и то же?

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

А что такое ноль?

А ноль — это самая «жирная» пустота из всех вышеперечисленных. Ноль — это полноценное значение численной переменной (например, integer, то есть целого числа).

Представьте, что вы пишете программу, которая обрабатывает прогнозы погоды. Эти данные она получает с погодного сервера. И с этого сервера прилетала переменная temperature. Сравните:

Если temperature === undefined, то, похоже, с сервера не прилетело никакой переменной с температурой. Программа завела переменную для приёма данных, но дальше ничего не произошло. Мы даже не знаем, какого типа данные нам прилетят. А то и вовсе нет никакой переменной.

Если temperature === null, то мы знаем, в каком формате прилетит температура, но сами данные ещё не прилетели.

Если temperature === 0, то температура — ноль градусов (предположим, по Цельсию). Ноль градусов — это вполне себе значение, с которым можно работать — например нарисовать снежинку.

Возвращаясь к метафоре с мешком: ноль — это когда нам объяснили, какой именно нужен мешок, мы его взяли и запихнули в него ноль, который занял всё место. Зачем? Видимо, так надо.

Преобразование типов для примитивов

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

Более новая информация по этой теме находится на странице https://learn.javascript.ru/type-conversions.

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

Всего есть три преобразования:

1. Строковое преобразование.
2. Численное преобразование.
3. Преобразование к логическому значению.

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

Строковое преобразование

Строковое преобразование происходит, когда требуется представление чего-либо в виде строки. Например, его производит функция alert .

var a = true; alert( a ); // "true"

Можно также осуществить преобразование явным вызовом String(val) :

alert( String(null) === "null" ); // true

Как видно из примеров выше, преобразование происходит наиболее очевидным способом, «как есть»: false становится «false» , null – «null» , undefined – «undefined» и т.п.

Также для явного преобразования применяется оператор «+» , у которого один из аргументов строка. В этом случае он приводит к строке и другой аргумент, например:

alert( true + "test" ); // "truetest" alert( "123" + undefined ); // "123undefined"

Численное преобразование

Численное преобразование происходит в математических функциях и выражениях, а также при сравнении данных различных типов (кроме сравнений === , !== ).

Для преобразования к числу в явном виде можно вызвать Number(val) , либо, что короче, поставить перед выражением унарный плюс «+» :

var a = +"123"; // 123 var a = Number("123"); // 123, тот же эффект

// после обрезания пробельных символов останется "123" alert( +" \n 123 \n \n" ); // 123

alert( +true ); // 1 alert( +false ); // 0

alert( "\n0 " == 0 ); // true

alert( "\n" == false ); alert( "1" == true );

Специальные значения

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

Интуитивно, значения null/undefined ассоциируются с нулём, но при преобразованиях ведут себя иначе.

Специальные значения преобразуются к числу так:

Это ведёт к забавным последствиям.

Например, null не подчиняется законам математики – он «больше либо равен нулю»: null>=0 , но не больше и не равен:

alert( null >= 0 ); // true, т.к. null преобразуется к 0 alert( null > 0 ); // false (не больше), т.к. null преобразуется к 0 alert( null == 0 ); // false (и не равен!), т.к. == рассматривает null особо.

Значение undefined вообще «несравнимо»:

alert( undefined > 0 ); // false, т.к. undefined -> NaN alert( undefined == 0 ); // false, т.к. это undefined (без преобразования) alert( undefined < 0 ); // false, т.к. undefined ->NaN

Для более очевидной работы кода и во избежание ошибок лучше не давать специальным значениям участвовать в сравнениях > >= <

alert( !!"0" ); // true alert( !!" " ); // любые непустые строки, даже из пробелов - true!

alert( 0 == "\n0\n" ); // true

if ("\n0\n")