Обнаружение неопределенного свойства объекта
1107318 просмотра
30 ответа
Как лучше всего проверить, не задано ли свойство объекта в JavaScript?
Автор: Matt Sheppard Источник Размещён: 22.10.2019 01:41Ответы (30)
2585 плюса
Использование:
if (typeof something === "undefined") {
alert("something is undefined");
}
Если переменная объекта имеет некоторые свойства, вы можете использовать то же самое, как это:
if (typeof my_obj.someproperties === "undefined"){
console.log('the property is not available...'); // print into console
}
Автор: Erwin
Размещён: 06.01.2009 12:27
873 плюса
Я считаю, что есть ряд неправильных ответов на эту тему. Вопреки распространенному мнению, «undefined» не является ключевым словом в JavaScript и может фактически иметь присвоенное ему значение.
Правильный код
Самый надежный способ выполнить этот тест:
if (typeof myVar === "undefined")
Это всегда будет возвращать правильный результат, и даже обрабатывает ситуацию, когда myVar
не объявлено.
Вырожденный код. НЕ ИСПОЛЬЗУЙ.
var undefined = false; // Shockingly, this is completely legal!
if (myVar === undefined) {
alert("You have been misled. Run away!");
}
Кроме того, myVar === undefined
возникнет ошибка в ситуации, когда myVar не объявлен.
200 плюса
Несмотря на то, что здесь яростно рекомендуют многие другие ответы, typeof
это плохой выбор . Он никогда не должен использоваться для проверки, имеют ли переменные значение undefined
, потому что он действует как комбинированная проверка значения undefined
и наличия переменной. В подавляющем большинстве случаев вы знаете, когда существует переменная, и typeof
просто представите возможность молчаливого сбоя, если вы сделаете опечатку в имени переменной или в строковом литерале 'undefined'
.
var snapshot = …;
if (typeof snaposhot === 'undefined') {
// ^
// misspelled¹ – this will never run, but it won’t throw an error!
}
var foo = …;
if (typeof foo === 'undefned') {
// ^
// misspelled – this will never run, but it won’t throw an error!
}
Так что, если вы не делаете обнаружение функций², где есть неопределенность, будет ли данное имя находиться в области видимости (например, проверка typeof module !== 'undefined'
в качестве шага в коде, специфичном для среды CommonJS), typeof
это вредный выбор при использовании с переменной, и правильный вариант - сравнить значение напрямую:
var foo = …;
if (foo === undefined) {
⋮
}
Некоторые распространенные заблуждения по этому поводу включают в себя:
что чтение «неинициализированной» переменной (
var foo
) или параметра (function bar(foo) { … }
называемого какbar()
) не удастся. Это просто неверно - переменные без явной инициализации и параметры, которым не были заданы значения, всегда становятсяundefined
и всегда находятся в области видимости.это
undefined
может быть перезаписано. Это намного больше.undefined
не является ключевым словом в JavaScript. Вместо этого это свойство глобального объекта с неопределенным значением. Однако, начиная с ES5, это свойство доступно только для чтения и не настраивается . Ни один современный браузер не позволитundefined
изменить свойство, и с 2017 года это имело место в течение длительного времени. Отсутствие строгого режима также не влияетundefined
на поведение - он просто делает заявления типаundefined = 5
ничего не делать вместо броска. Поскольку это не ключевое слово, вы можете объявлять переменные с именемundefined
, и эти переменные можно изменить, создав такой некогда общий шаблон:(function (undefined) { // … })()
более опасно, чем использование глобального
undefined
. Если вам нужно быть совместимымundefined
с ES3, замените наvoid 0
- не прибегайте кtypeof
. (void
всегда был унарным оператором, который оценивается как неопределенное значение для любого операнда.)
С тем, как переменные работают вне пути, пришло время обратиться к фактическому вопросу: свойствам объекта. Нет причин когда-либо использовать typeof
свойства объекта. Предыдущее исключение, касающееся обнаружения признаков, здесь не применимо - оно typeof
имеет специальное поведение для переменных, а выражения, которые ссылаются на свойства объекта, не являются переменными.
Этот:
if (typeof foo.bar === 'undefined') {
⋮
}
это всегда точно эквивалент в this³:
if (foo.bar === undefined) {
⋮
}
и принимая во внимание приведенный выше совет, чтобы не вводить читателей в заблуждение относительно того, почему вы используете typeof
, потому что это имеет смысл использовать ===
для проверки на равенство, потому что это может быть реорганизовано для проверки значения переменной позже, и потому что это просто выглядит лучше, вы всегда должны использовать === undefined
³ и здесь .
Когда дело доходит до свойств объекта, нужно еще кое-что рассмотреть, действительно ли вы вообще хотите проверять undefined
. Заданное имя свойства может отсутствовать в объекте (создавая значение undefined
при чтении), присутствовать в самом объекте со значением undefined
, присутствовать в прототипе объекта со значением undefined
или присутствовать в любом из undefined
значений, не имеющих значения. 'key' in obj
скажет вам, находится ли ключ где-нибудь в цепочке прототипов объекта, и Object.prototype.hasOwnProperty.call(obj, 'key')
скажет, находится ли он непосредственно в объекте. В этом ответе я не буду вдаваться в подробности о прототипах и использовании объектов в качестве карт со строковыми ключами, потому что он в основном предназначен для противодействия всем плохим советам в других ответах, независимо от возможных интерпретаций исходного вопроса. Следить за публикациямиОбъектные прототипы на MDN больше!
¹ необычный выбор примера имени переменной? это настоящий мертвый код из расширения NoScript для Firefox.
² не думайте, что не зная, что находится в области видимости, в целом все же хорошо. бонусная уязвимость, вызванная злоупотреблением динамической областью действия: Project Zero 1225
³ снова предполагает среду ES5 +, которая undefined
относится к undefined
свойству глобального объекта. подставь void 0
иначе.
151 плюса
В JavaScript есть ноль и есть неопределенный . У них разные значения.
- undefined означает, что значение переменной не было определено; неизвестно, какова стоимость.
- NULL означает, что значение переменной определено и имеет значение NULL (не имеет значения).
Марин Хавербеке в своей бесплатной онлайн-книге « Красноречивый JavaScript » (выделено мной) утверждает :
Существует также аналогичное значение, нулевое, значение которого «это значение определено, но оно не имеет значения». Разница в значении между неопределенным и нулевым является в основном академической и обычно не очень интересной. В практических программах часто необходимо проверить, имеет ли что-то значение. В этих случаях может быть использовано выражение что-то == undefined, поскольку, даже если они не совпадают по значению, null == undefined приведет к значению true.
Итак, я думаю, что лучший способ проверить, было ли что-то неопределенным, было бы:
if (something == undefined)
Надеюсь это поможет!
Редактировать: в ответ на ваше редактирование свойства объекта должны работать так же.
var person = {
name: "John",
age: 28,
sex: "male"
};
alert(person.name); // "John"
alert(person.fakeVariable); // undefined
Автор: Pandincus
Размещён: 26.08.2008 07:36
120 плюса
Что это значит: «неопределенное свойство объекта» ?
На самом деле это может означать две совершенно разные вещи! Во-первых, это может означать свойство, которое никогда не было определено в объекте, и, во-вторых, это может означать свойство, которое имеет неопределенное значение . Давайте посмотрим на этот код:
var o = { a: undefined }
Не o.a
определено? Да! Его значение не определено. Не o.b
определено? Конечно! Нет свойства 'b' вообще! Хорошо, теперь посмотрим, как разные подходы ведут себя в обеих ситуациях:
typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false
Мы можем ясно видеть это typeof obj.prop == 'undefined'
и obj.prop === undefined
эквивалентны, и они не различают эти разные ситуации. И 'prop' in obj
может обнаружить ситуацию, когда свойство вообще не было определено и не обращает внимания на значение свойства, которое может быть неопределенным.
Так что делать?
1) Вы хотите знать, является ли свойство неопределенным по первому или второму значению (наиболее типичная ситуация).
obj.prop === undefined // IMHO, see "final fight" below
2) Вы хотите просто знать, имеет ли объект какое-либо свойство и не заботиться о его значении.
'prop' in obj
Примечания:
- Вы не можете проверить объект и его свойства одновременно. Например, это
x.a === undefined
или этоtypeof x.a == 'undefined'
повышается,ReferenceError: x is not defined
если x не определен. - Переменная
undefined
является глобальной переменной (так на самом деле этоwindow.undefined
в браузерах). Он поддерживается с ECMAScript 1st Edition, а с ECMAScript 5 - только для чтения . Так что в современных браузерах это нельзя переопределить как истинное, поскольку многие авторы любят пугать нас, но это все еще верно для старых браузеров.
Финальный бой: obj.prop === undefined
противtypeof obj.prop == 'undefined'
Плюсы obj.prop === undefined
:
- Это немного короче и выглядит немного красивее
- Движок JavaScript выдаст вам ошибку, если вы ошиблись
undefined
Минусы obj.prop === undefined
:
undefined
может быть переопределено в старых браузерах
Плюсы typeof obj.prop == 'undefined'
:
- Это действительно универсально! Работает в новых и старых браузерах.
Минусы typeof obj.prop == 'undefined'
:
'undefned'
( опечатка ) это просто строковая константа, поэтому движок JavaScript не сможет вам помочь, если вы ошиблись, как я только что сделал.
Обновление (для серверного JavaScript):
Node.js поддерживает глобальную переменную undefined
как global.undefined
(ее также можно использовать без префикса 'global'). Я не знаю о других реализациях серверного JavaScript.
66 плюса
Проблема сводится к трем случаям:
- Объект имеет свойство, а его значение - нет
undefined
. - Объект имеет свойство и его значение равно
undefined
. - У объекта нет свойства.
Это говорит нам кое-что, что я считаю важным:
Существует разница между неопределенным членом и определенным членом с неопределенным значением.
Но, к сожалению typeof obj.foo
, не говорит нам, какой из трех случаев у нас есть. Однако мы можем комбинировать это с тем, "foo" in obj
чтобы различать случаи.
| typeof obj.x === 'undefined' | !("x" in obj)
1. { x:1 } | false | false
2. { x : (function(){})() } | true | false
3. {} | true | true
Стоит отметить, что эти тесты одинаковы для null
записей тоже
| typeof obj.x === 'undefined' | !("x" in obj)
{ x:null } | false | false
Я бы сказал, что в некоторых случаях имеет смысл (и понятнее) проверить, присутствует ли свойство, а не проверить, является ли оно неопределенным, и единственный случай, когда эта проверка будет отличаться, - это случай 2, редкий случай фактическая запись в объекте с неопределенным значением.
Например: я только что провела рефакторинг группы кода, которая провела несколько проверок, имеет ли объект заданное свойство.
if( typeof blob.x != 'undefined' ) { fn(blob.x); }
Что было понятнее, когда написано без проверки неопределенности.
if( "x" in blob ) { fn(blob.x); }
Но, как уже упоминалось, это не совсем то же самое (но более чем достаточно для моих нужд).
Автор: Michael Anderson Размещён: 08.06.2011 04:0443 плюса
if ( typeof( something ) == "undefined")
Это сработало для меня, а другие нет.
Автор: Kevin Размещён: 27.07.2010 04:0339 плюса
Я не уверен, откуда исходит происхождение использования ===
with typeof
, и как соглашение я вижу, что он используется во многих библиотеках, но оператор typeof возвращает строковый литерал, и мы знаем это заранее, так почему вы также хотите ввести проверить это тоже?
typeof x; // some string literal "string", "object", "undefined"
if (typeof x === "string") { // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") { // sufficient
Автор: Eric
Размещён: 22.09.2010 02:20
24 плюса
Перекрестный ответ на мой ответ по связанному вопросу Как проверить наличие «неопределенного» в JavaScript?
Специфично для этого вопроса, см. Контрольные примеры с someObject.<whatever>
.
Некоторые сценарии, иллюстрирующие результаты различных ответов: http://jsfiddle.net/drzaus/UVjM4/
(Обратите внимание, что использование var
для in
тестов имеет значение, когда используется оболочка с ограничением объема)
Код для справки:
(function(undefined) {
var definedButNotInitialized;
definedAndInitialized = 3;
someObject = {
firstProp: "1"
, secondProp: false
// , undefinedProp not defined
}
// var notDefined;
var tests = [
'definedButNotInitialized in window',
'definedAndInitialized in window',
'someObject.firstProp in window',
'someObject.secondProp in window',
'someObject.undefinedProp in window',
'notDefined in window',
'"definedButNotInitialized" in window',
'"definedAndInitialized" in window',
'"someObject.firstProp" in window',
'"someObject.secondProp" in window',
'"someObject.undefinedProp" in window',
'"notDefined" in window',
'typeof definedButNotInitialized == "undefined"',
'typeof definedButNotInitialized === typeof undefined',
'definedButNotInitialized === undefined',
'! definedButNotInitialized',
'!! definedButNotInitialized',
'typeof definedAndInitialized == "undefined"',
'typeof definedAndInitialized === typeof undefined',
'definedAndInitialized === undefined',
'! definedAndInitialized',
'!! definedAndInitialized',
'typeof someObject.firstProp == "undefined"',
'typeof someObject.firstProp === typeof undefined',
'someObject.firstProp === undefined',
'! someObject.firstProp',
'!! someObject.firstProp',
'typeof someObject.secondProp == "undefined"',
'typeof someObject.secondProp === typeof undefined',
'someObject.secondProp === undefined',
'! someObject.secondProp',
'!! someObject.secondProp',
'typeof someObject.undefinedProp == "undefined"',
'typeof someObject.undefinedProp === typeof undefined',
'someObject.undefinedProp === undefined',
'! someObject.undefinedProp',
'!! someObject.undefinedProp',
'typeof notDefined == "undefined"',
'typeof notDefined === typeof undefined',
'notDefined === undefined',
'! notDefined',
'!! notDefined'
];
var output = document.getElementById('results');
var result = '';
for(var t in tests) {
if( !tests.hasOwnProperty(t) ) continue; // bleh
try {
result = eval(tests[t]);
} catch(ex) {
result = 'Exception--' + ex;
}
console.log(tests[t], result);
output.innerHTML += "\n" + tests[t] + ": " + result;
}
})();
И результаты:
definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined
Автор: drzaus
Размещён: 13.01.2013 05:43
18 плюса
Я не видел (надеюсь, что не пропустил) никого, кто проверял объект перед собственностью. Итак, это самый короткий и самый эффективный (хотя и не обязательно самый понятный):
if (obj && obj.prop) {
// Do something;
}
Если obj или obj.prop не определены, имеют значение null или «ложь», оператор if не выполнит блок кода. Это обычно желаемое поведение в большинстве операторов блока кода (в JavaScript).
Автор: Joe Johnson Размещён: 25.09.2012 06:4118 плюса
Если вы делаете
if (myvar == undefined )
{
alert('var does not exists or is not initialized');
}
произойдет сбой, когда переменная myvar
не существует, потому что myvar не определен, поэтому скрипт не работает и тест не имеет никакого эффекта.
Поскольку объект окна имеет глобальную область видимости (объект по умолчанию) вне функции, объявление будет «прикреплено» к объекту окна.
Например:
var myvar = 'test';
Глобальная переменная myvar такая же, как window.myvar или window ['myvar']
Чтобы избежать ошибок для проверки, когда существует глобальная переменная, лучше использовать:
if(window.myvar == undefined )
{
alert('var does not exists or is not initialized');
}
Вопрос, действительно ли переменная существует, не имеет значения, ее значение неверно. В противном случае глупо инициализировать переменные с неопределенным значением, и лучше использовать значение false для инициализации. Когда вы знаете, что все переменные, которые вы объявляете, инициализируются с помощью false, вы можете просто проверить их тип или положиться, !window.myvar
чтобы проверить, имеет ли оно правильное / правильное значение. Таким образом, даже если переменная не определена, то !window.myvar
то же самое для myvar = undefined
или myvar = false
или myvar = 0
.
Когда вы ожидаете определенного типа, проверьте тип переменной. Чтобы ускорить тестирование состояния, вам лучше сделать:
if( !window.myvar || typeof window.myvar != 'string' )
{
alert('var does not exists or is not type of string');
}
Когда первое и простое условие выполняется, интерпретатор пропускает следующие тесты.
Всегда лучше использовать экземпляр / объект переменной, чтобы проверить, получило ли оно допустимое значение. Это более стабильный и лучший способ программирования.
(У)
Автор: Codebeat Размещён: 12.08.2011 02:4014 плюса
В статье « Изучение бездны нуля и неопределенности в JavaScript» я прочитал, что фреймворки, такие как Underscore.js, используют эту функцию:
function isUndefined(obj){
return obj === void 0;
}
Автор: Marthijn
Размещён: 19.12.2013 10:44
13 плюса
Просто что-то не определено в JavaScript, не определено , не имеет значения, является ли оно свойством внутри Object / Array или просто как переменная ...
JavaScript имеет typeof
очень простое обнаружение неопределенной переменной.
Просто проверьте typeof whatever === 'undefined'
, вернется ли логическое значение.
Вот как isUndefined()
пишется знаменитая функция в AngularJs v.1x:
function isUndefined(value) {return typeof value === 'undefined';}
Таким образом, как вы видите, функция получает значение, если это значение определено, оно вернется false
, в противном случае для неопределенных значений вернется true
.
Итак, давайте посмотрим, какими будут результаты, когда мы передаем значения, включая свойства объекта, как показано ниже, это список переменных, которые у нас есть:
var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;
и мы проверим их, как показано ниже, вы можете увидеть результаты перед ними в качестве комментария:
isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true
Как вы видите, мы можем проверить что угодно, используя что-то подобное в нашем коде, как уже упоминалось, вы можете просто использовать его typeof
в своем коде, но если вы используете это снова и снова, создайте функцию, подобную угловому образцу, которую я разделяю, и продолжаю использовать ее как следующий шаблон кода СУХОЙ.
Также еще одна вещь, для проверки свойства объекта в реальном приложении, в котором вы не уверены, существует ли этот объект или нет, сначала проверьте, существует ли объект.
Если вы проверите свойство объекта и объект не существует, вы получите ошибку и остановите работу всего приложения.
isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)
Настолько просто, что вы можете заключить в оператор if, как показано ниже:
if(typeof x !== 'undefined') {
//do something
}
Что также равно isDefined в Angular 1.x ...
function isDefined(value) {return typeof value !== 'undefined';}
Также другие фреймворки javascript, такие как подчеркивание, имеют аналогичную проверочную проверку, но я рекомендую использовать, typeof
если вы уже не используете фреймворки.
Я также добавляю этот раздел из MDN, в котором есть полезная информация о typeof, undefined и void (0).
Строгое равенство и неопределенность
Вы можете использовать неопределенные операторы и операторы строгого равенства и неравенства, чтобы определить, имеет ли переменная значение. В следующем коде переменная x не определена, а оператор if оценивается как true.
var x;
if (x === undefined) {
// these statements execute
}
else {
// these statements do not execute
}
Примечание: здесь должен использоваться оператор строгого равенства, а не стандартный оператор равенства, потому что x == undefined также проверяет, является ли x нулевым, а строгое равенство - нет. ноль не эквивалентно неопределенному. Смотрите операторы сравнения для деталей.
Оператор Typeof и неопределенный В
качестве альтернативы можно использовать typeof:
var x;
if (typeof x === 'undefined') {
// these statements execute
}
Одной из причин использования typeof является то, что он не выдает ошибку, если переменная не была объявлена.
// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
// these statements execute
}
if (x === undefined) { // throws a ReferenceError
}
Тем не менее, этот вид техники следует избегать. JavaScript является статически ограниченным языком, поэтому, зная, объявлена ли переменная, можно прочитать, проверив, объявлена ли она в окружающем контексте. Единственное исключение - глобальная область, но глобальная область привязана к глобальному объекту, поэтому проверка существования переменной в глобальном контексте может быть выполнена путем проверки наличия свойства в глобальном объекте (используя оператор in, например).
Пустой оператор и неопределенный
Оператор void является третьей альтернативой.
var x;
if (x === void 0) {
// these statements execute
}
// y has not been declared before
if (y === void 0) {
// throws a ReferenceError (in contrast to `typeof`)
}
больше> здесь
Автор: Alireza Размещён: 24.05.2017 02:1512 плюса
' if (window.x) {} ' безопасен от ошибок
Скорее всего, вы хотите if (window.x)
. Эта проверка безопасна, даже если x не был объявлен ( var x;
) - браузер не выдает ошибку.
Пример: я хочу знать, поддерживает ли мой браузер History API
if (window.history) {
history.call_some_function();
}
Как это работает:
window - это объект, который содержит все глобальные переменные в качестве своих членов, и разрешено пытаться получить доступ к несуществующему члену. Если x не был объявлен или не был установлен, то window.x
возвращает undefined . undefined приводит к ложному, когда if () оценивает его.
11 плюса
11 плюса
Прочитав это, я поражен, что не видел этого. Я нашел несколько алгоритмов, которые будут работать для этого.
Никогда не определен
Если значение объекта никогда не было определено, это предотвратит возврат, true
если оно определено как null
или undefined
. Это полезно, если вы хотите, чтобы true возвращалось для значений, установленных какundefined
if(obj.prop === void 0) console.log("The value has never been defined");
Определено как неопределенное или никогда не определено
Если вы хотите, чтобы это приводило true
к значениям, определенным значением undefined
или никогда не определенным, вы можете просто использовать=== undefined
if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");
Определяется как ложное значение, неопределенное, нулевое или никогда не определяется.
Обычно люди просят у меня алгоритм, чтобы выяснить, является ли значение ложным undefined
, или null
. Следующие работы.
if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
console.log("The value is falsy, null, or undefined");
}
Автор: Travis
Размещён: 15.02.2015 03:10
10 плюса
Сравните с void 0
, для краткости.
if (foo !== void 0)
Это не так многословно, как if (typeof foo !== 'undefined')
10 плюса
Вы можете получить массив с неопределенным путем, используя следующий код.
function getAllUndefined(object) {
function convertPath(arr, key) {
var path = "";
for (var i = 1; i < arr.length; i++) {
path += arr[i] + "->";
}
path += key;
return path;
}
var stack = [];
var saveUndefined= [];
function getUndefiend(obj, key) {
var t = typeof obj;
switch (t) {
case "object":
if (t === null) {
return false;
}
break;
case "string":
case "number":
case "boolean":
case "null":
return false;
default:
return true;
}
stack.push(key);
for (k in obj) {
if (obj.hasOwnProperty(k)) {
v = getUndefiend(obj[k], k);
if (v) {
saveUndefined.push(convertPath(stack, k));
}
}
}
stack.pop();
}
getUndefiend({
"": object
}, "");
return saveUndefined;
}
ссылка jsFiddle
Автор: Anoop Размещён: 17.10.2011 11:229 плюса
Решение неверное. В JavaScript
null == undefined
вернет true, потому что они оба «приведены к логическому значению» и являются ложными. Правильный способ будет проверить
if (something === undefined)
который является оператором идентичности ...
Автор: Ricky Размещён: 26.08.2008 12:388 плюса
Вот моя ситуация:
Я использую результат вызова REST. Результат должен быть проанализирован из JSON в объект JavaScript.
There is one error I need to defend. If the args to the rest call were incorrect as far as the user specifying the args wrong, the rest call comes back basically empty.
While using this post to help me defend against this, I tried this.
if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; }
For my situation, if restResult.data[0] === "object", then I can safely start inspecting the rest of the members. If undefined then throw the error as above.
What I am saying is that for my situation, all the suggestions above in this post did not work. I'm not saying I'm right and everyone is wrong. I am not a JavaScript master at all, but hopefully this will help someone.
Автор: wayneseymour Размещён: 15.08.2013 01:568 плюса
There is a nice & elegant way to assign a defined property to a new variable if it is defined or assign a default value to it as a fallback if it´s undefined.
var a = obj.prop || defaultValue;
Это подходит, если у вас есть функция, которая получает дополнительное свойство конфигурации:
var yourFunction = function(config){
this.config = config || {};
this.yourConfigValue = config.yourConfigValue || 1;
console.log(this.yourConfigValue);
}
Сейчас исполняю
yourFunction({yourConfigValue:2});
//=> 2
yourFunction();
//=> 1
yourFunction({otherProperty:5});
//=> 1
Автор: Marian Klühspies
Размещён: 03.03.2016 10:05
7 плюса
Все ответы неполные. Это правильный способ узнать, что существует свойство, определенное как неопределенное:
var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;
Пример:
var a = { b : 1, e : null } ;
a.c = a.d ;
hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null
// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined
Жаль, что это был правильный ответ, похоронен в неправильных ответах> _ <
Так что, для тех, кто проходит мимо, я дам вам неопределенные бесплатно !!
var undefined ; undefined ; // undefined
({}).a ; // undefined
[].a ; // undefined
''.a ; // undefined
(function(){}()) ; // undefined
void(0) ; // undefined
eval() ; // undefined
1..a ; // undefined
/a/.a ; // undefined
(true).a ; // undefined
Автор: Juan Garcia
Размещён: 18.06.2014 05:21
7 плюса
Проходя по комментариям, для тех, кто хочет проверить, является ли он неопределенным или его значение равно нулю:
//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
alert('either it is undefined or value is null')
}
Если вы используете библиотеку jQuery, то jQuery.isEmptyObject()
будет достаточно для обоих случаев,
var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;
s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;
//Usage
if (jQuery.isEmptyObject(s)) {
alert('Either variable:s is undefined or its value is null');
} else {
alert('variable:s has value ' + s);
}
s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;
Автор: Angelin Nadar
Размещён: 08.07.2014 08:19
7 плюса
Если вы используете Angular:
angular.isUndefined(obj)
angular.isUndefined(obj.prop)
Underscore.js:
_.isUndefined(obj)
_.isUndefined(obj.prop)
Автор: Vitalii Fedorenko
Размещён: 14.12.2014 10:35
6 плюса
Я использую, if (this.variable)
чтобы проверить, если это определено. Простое if (variable)
, рекомендованное выше , для меня не получается. Оказывается, это работает только тогда, когда переменная является полем некоторого объекта, obj.someField
чтобы проверить, определена ли она в словаре. Но мы можем использовать this
или window
как объект словаря, так как любая переменная является полем в текущем окне, насколько я понимаю. Поэтому вот тест
if (this.abc) alert("defined"); else alert("undefined");
abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");
Сначала он обнаруживает, что переменная abc
не определена, и определяется после инициализации.
5 плюса
Я предлагаю три способа для тех, кто ожидает странных ответов:
function isUndefined1(val) {
try {
val.a;
} catch (e) {
return /undefined/.test(e.message);
}
return false;
}
function isUndefined2(val) {
return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
const defaultVal={};
return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
console.group(`test start :`+func.name);
console.log(func(undefined));
console.log(func(null));
console.log(func(1));
console.log(func("1"));
console.log(func(0));
console.log(func({}));
console.log(func(function () { }));
console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);
isUndefined1:
Попробуйте получить свойство входного значения, проверьте сообщение об ошибке, если оно существует. Если входное значение не определено, сообщение об ошибке будет Uncaught TypeError: Невозможно прочитать свойство 'b' из неопределенного
isUndefined2:
Преобразуйте входное значение в строку для сравнения "undefined"
и убедитесь, что это отрицательное значение.
isUndefined3:
В js необязательный параметр работает, когда входное значение точно undefined
.
4 плюса
function isUnset(inp) {
return (typeof inp === 'undefined')
}
Возвращает false, если переменная установлена, и true, если не определено.
Тогда используйте:
if (isUnset(var)) {
// initialize variable here
}
Автор: Rixius
Размещён: 12.07.2010 08:54
4 плюса
Я хотел бы показать вам кое-что, что я использую для защиты undefined
переменной:
Object.defineProperty(window, 'undefined', {});
Это запрещает кому-либо изменять window.undefined
значение, поэтому уничтожает код на основе этой переменной. При использовании "use strict"
все попытки изменить его значение будут заканчиваться ошибкой, в противном случае это будет игнорироваться.
4 плюса
Вы также можете использовать Proxy, он будет работать с вложенными вызовами, но потребует одну дополнительную проверку:
function resolveUnknownProps(obj, resolveKey) {
const handler = {
get(target, key) {
if (
target[key] !== null &&
typeof target[key] === 'object'
) {
return resolveUnknownProps(target[key], resolveKey);
} else if (!target[key]) {
return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
}
return target[key];
},
};
return new Proxy(obj, handler);
}
const user = {}
console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }
так что вы будете использовать его так:
const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
// do someting
}
Автор: Sarkis Arutiunian
Размещён: 21.03.2018 04:50
4 плюса
Из lodash.js.
var undefined;
function isUndefined(value) {
return value === undefined;
}
Он создает переменную LOCAL с именем, undefined
которая инициализируется значением по умолчанию - действительным undefined
, а затем сравнивается value
с переменной undefined
.
Обновление 9/9/2019
Я нашел, что lodash обновил свою реализацию. Смотрите мою проблему и код .
Для пуленепробиваемости просто используйте:
function isUndefined(value) {
return value === void 0;
}
Автор: lzl124631x
Размещён: 14.01.2016 05:43
Вопросы из категории :
- javascript Как определить, какой из указанных шрифтов был использован на веб-странице?
- javascript Валидация клиентской стороны ASP.Net
- javascript Длина объекта JavaScript
- javascript Получение текста из выпадающего списка
- javascript Скрипт входа со скрытыми кнопками
- javascript Как автоматически изменить размер текстовой области с помощью Prototype?
- object Вызов функции модуля с использованием его имени (строки)
- object Создайте базовый итератор Python
- object Обнаружение неопределенного свойства объекта
- object Каков наиболее эффективный способ глубокого клонирования объекта в JavaScript?
- object Как определить равенство для двух объектов JavaScript?
- object Избегать! = Нулевые заявления
- undefined Каковы все распространенные неопределенные поведения, о которых должен знать программист C ++?
- undefined Почему null является объектом и в чем разница между null и undefined?
- undefined Как проверить неопределенную переменную в JavaScript
- undefined Как сбросить переменную JavaScript?
- undefined неопределенное смещение PHP ошибка