Обнаружение неопределенного свойства объекта
Как лучше всего проверить, не задано ли свойство объекта в JavaScript?
51 ответ
Использование:
if (typeof something === "undefined") {
alert("something is undefined");
}
Если переменная объекта имеет некоторые свойства, вы можете использовать то же самое, как это:
if (typeof my_obj.someproperties === "undefined"){
console.log('the property is not available...'); // print into console
}
Я считаю, что есть ряд неправильных ответов на эту тему. Вопреки распространенному мнению, "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 не объявлен.
Несмотря на то, что я настоятельно рекомендую многие другие ответы здесь, 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, Если вы должны быть ES3-совместимым, заменитеundefinedсvoid 0- не прибегай кtypeof, (voidвсегда был унарным оператором, который оценивается как неопределенное значение для любого операнда.)
С тем, как переменные работают не по пути, пришло время обратиться к актуальному вопросу: свойствам объекта. Там нет причин, чтобы когда-либо использовать typeof для свойств объекта. Предыдущее исключение в отношении обнаружения функций здесь не применимо - typeof имеет специальное поведение только для переменных, а выражения, которые ссылаются на свойства объекта, не являются переменными.
Это:
if (typeof foo.bar === 'undefined') {
⋮
}
всегда точно соответствует этому:
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 иначе.
В 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
Что это значит: "неопределенное свойство объекта"?
На самом деле это может означать две совершенно разные вещи! Во-первых, это может означать свойство, которое никогда не было определено в объекте, и, во-вторых, это может означать свойство, которое имеет неопределенное значение. Давайте посмотрим на этот код:
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если х не определено. - переменная
undefinedявляется глобальной переменной (так на самом деле этоwindow.undefinedв браузерах). Он поддерживается с 1-го издания ECMAScript, а с 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.
Проблема сводится к трем случаям:
- Объект имеет свойство и его значение не
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); }
Но, как уже упоминалось, это не совсем то же самое (но более чем достаточно для моих нужд).
if ( typeof( something ) == "undefined")
Это сработало для меня, а другие нет.
Я не уверен, где источник использования === с 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
Я не видел (надеюсь, что не пропустил) никого, кто проверял объект перед собственностью. Итак, это самый короткий и самый эффективный (хотя не обязательно самый понятный):
if (obj && obj.prop) {
// Do something;
}
Если obj или obj.prop не определены, имеют значение null или "falsy", оператор if не выполнит блок кода. Это обычно желаемое поведение в большинстве операторов блока кода (в JavaScript).
Перекрестный ответ на мой ответ по смежному вопросу Как проверить наличие "неопределенного" в 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
Если вы делаете
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');
}
Когда первое и простое условие выполняется, интерпретатор пропускает следующие тесты.
Всегда лучше использовать экземпляр / объект переменной, чтобы проверить, получило ли оно допустимое значение. Это более стабильный и лучший способ программирования.
(У)
ECMAScript 10 представил новую функцию - необязательную цепочку, которую вы можете использовать для использования свойства объекта, только если объект определен следующим образом:
const userPhone = user?.contactDetails?.phone;
Он будет ссылаться на свойство phone только тогда, когда определены user и contactDetails.
Ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
В статье " Изучение бездны нуля и неопределенности в JavaScript" я прочитал, что фреймворки, такие как Underscore.js, используют эту функцию:
function isUndefined(obj){
return obj === void 0;
}
Просто что-то не определено в JavaScript, не определено, не имеет значения, является ли оно свойством внутри Object/Array или просто как переменная...
JavaScript имеет typeof что позволяет очень легко обнаружить неопределенную переменную.
Просто проверьте, если typeof whatever === 'undefined' и он вернет логическое значение.
Вот как знаменитая функция isUndefined() в AngularJs v.1x написано:
function isUndefined(value) {return typeof value === 'undefined';}
Итак, как вы видите, функция получает значение, если это значение определено, она вернет falseв противном случае для неопределенных значений вернуть true,
Итак, давайте посмотрим, какими будут результаты, когда мы передаем значения, включая свойства объекта, как показано ниже, это список переменных, которые у нас есть:
var stackru = {};
stackru.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;
и мы проверяем их, как показано ниже, вы можете увидеть результаты перед ними в качестве комментария:
isUndefined(stackru); //false
isUndefined(stackru.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackru.java); //true
isUndefined(stackru.php); //true
isUndefined(stackru && stackru.css); //true
Как вы видите, мы можем проверить что угодно, используя что-то подобное в нашем коде, как уже упоминалось, вы можете просто использовать typeof в своем коде, но если вы используете его снова и снова, создайте функцию, подобную угловой выборке, которую я разделяю, и продолжаю использовать повторно. как следующий шаблон кода DRY.
Также еще одна вещь, для проверки свойства объекта в реальном приложении, в котором вы не уверены, существует ли этот объект или нет, сначала проверьте, существует ли объект.
Если вы проверите свойство объекта и объект не существует, вы получите ошибку и остановите работу всего приложения.
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 может быть использован:
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`)
}
больше> здесь
Прочитав это, я поражен, что не видел этого. Я нашел несколько алгоритмов, которые будут работать для этого.
Никогда не определен
Если значение объекта никогда не было определено, это предотвратит возврат 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");
}
'if (window.x) {}' безопасен от ошибок
Скорее всего, вы хотите if (window.x), Эта проверка безопасна, даже если x не был объявлен (var x;) - браузер не выдает ошибку.
Пример: я хочу знать, поддерживает ли мой браузер History API
if (window.history) {
history.call_some_function();
}
Как это работает:
window - это объект, который содержит все глобальные переменные в качестве своих членов, и разрешено пытаться получить доступ к несуществующему члену. Если x не был объявлен или не был установлен, то window.x возвращает неопределенное. undefined приводит к ложному, когда if() оценивает его.
Решение неверное. В JavaScript
null == undefined
вернет true, потому что они оба "приведены" к логическому значению и являются ложными. Правильный способ будет проверить
if (something === undefined)
который является оператором идентичности...
Вы можете получить массив с неопределенным путем, используя следующий код.
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
Сравнить с void 0для краткости.
if (foo !== void 0)
Это не так многословно, как if (typeof foo !== '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
Вот моя ситуация:
Я использую результат вызова REST. Результат должен быть проанализирован из JSON в объект JavaScript.
Есть одна ошибка, которую я должен защитить. Если аргументы для вызова rest были неправильными, поскольку пользователь указал неправильные аргументы, вызов rest возвращается в основном пустым.
Используя этот пост, чтобы помочь мне защититься от этого, я попробовал это.
if( typeof restResult.data[0] === "undefined" ) { throw "Some error"; }
В моей ситуации, если restResult.data[0] === "объект", я могу смело начинать проверку остальных членов. Если значение не определено, выведите ошибку, как указано выше.
Я говорю о том, что для моей ситуации все предложения, приведенные выше в этом посте, не сработали. Я не говорю, что я прав, а все не правы. Я вообще не являюсь мастером JavaScript, но, надеюсь, это кому-нибудь поможет.
Проходя по комментариям, для тех, кто хочет проверить, является ли он неопределенным или его значение равно нулю:
//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;
Все ответы неполные. Это правильный способ узнать, что есть свойство, определенное как неопределенное:
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
Есть очень простой и легкий способ.
Вы можете использовать необязательную цепочку:
x = {prop:{name:"sajad"}}
console.log(x.prop?.name) // Output is: "sajad"
console.log(x.prop?.lastName) // Output is: undefined
или
if(x.prop?.lastName) // The result of this 'if' statement is false and is not throwing an error
Вы можете использовать необязательную цепочку даже для функций или массивов.
По состоянию на середину 2020 года это реализовано не повсеместно. Проверьте документацию на https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining.
Если вы используете Angular:
angular.isUndefined(obj)
angular.isUndefined(obj.prop)
Underscore.js:
_.isUndefined(obj)
_.isUndefined(obj.prop)
Я использую 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 не определено и определяется после инициализации.
Я предлагаю три способа для тех, кто ожидает странных ответов:
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,
В недавней версии JavaScript введен новый оператор цепочки, который, скорее всего, является лучшим способом проверить, существует ли свойство, иначе он даст вам undefined.
см. пример ниже
const adventurer = {
name: 'Alice',
cat: {
name: 'Dinah'
}
};
const dogName = adventurer.dog?.name;
console.log(dogName);
// expected output: undefined
console.log(adventurer.someNonExistentMethod?.());
// expected output: undefined
Мы можем заменить этот старый синтаксис
if (response && response.data && response.data.someData && response.data.someData.someMoreData) {}
с этим более аккуратным синтаксисом
if( response?.data?.someData?.someMoreData) {}
Этот синтаксис не поддерживается в IE, Opera, safari и samsund android.
для более подробной информации вы можете проверить этот URL
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
function isUnset(inp) {
return (typeof inp === 'undefined')
}
Возвращает false, если переменная установлена, и true, если не определено.
Тогда используйте:
if (isUnset(var)) {
// initialize variable here
}