Питання Виявлення невизначеного об'єкта властивості


Який найкращий спосіб перевірки, якщо властивість об'єкта в JavaScript не визначено?


2434
2017-08-26 07:25


походження




Відповіді:


Використання:

if (typeof something === "undefined") {
    alert("something is undefined");
}

Якщо для об'єктної змінної, яка має деякі властивості, ви можете використовувати таке саме те саме:

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

Оскільки ECMAScript 5, undefined не може бути перезаписаний, так що my_obj === undefined буде працювати теж, але тільки якщо my_obj існує Це може бути або не бажаним, тому що ви також можете використовувати null якщо вам потрібна ця семантика (див Яка різниця між нульовим та невизначеним в JavaScript?) Хоча для властивостей об'єкта він працює незалежно від того, існує така властивість.


2321
2018-01-06 12:27



якщо щось нульове, він визначається (як нульовий), але ви також можете зв'язати теж перевірки. Прикріплювальна деталь вищезазначеного коду полягає в тому, що ви не можете визначити функцію перевірки, і ви можете визначити функцію ... але спробуйте її використовувати. - neu-rah
@ neu-rah чому ти не можеш написати функцію? чому б не щось подібне до цієї роботи? Здається, це працює для мене. Чи є справа, яку я не розглядаю? jsfiddle.net/djH9N/6 - Zack
@ Забивати ваші тести на isNullorUndefined не розглянув випадок, коли ви викликаєте isNullOrUndefined (f), і f не є оголошеною (тобто де не існує декларації "var f"). - pnkfelix
Бла, тепер тисячі голосів. Це найгірший спосіб це зробити. Я сподіваюсь, що перехожі побачать цей коментар і вирішили перевірити ... ах ... інший відповіді - Ry-♦
Ви можете просто використовувати obj !== undefined зараз undefined колись змінювався, як undefined = 1234 що призведе до цікавих результатів. Але після Ecmascript 5 він більше не можна записувати, тому ми можемо використовувати простішу версію. codereadability.com/how-to-check-for-undefined-in-javascript - Bruno Buccolo


Я вважаю, що є ряд неправильних відповідей на цю тему. Всупереч поширеній думці, "невизначеною" є ні ключове слово в 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 незареєстрований.


805
2017-08-23 18:03



+1, щоб зауважити, що myVar === undefined викликає помилку, якщо myVar не було оголошено - Enrique
так - ЦІЛІ, очевидно, є життєво важливими. Я думаю, що функція typeof повертає рядок (з очікуваного формату) - jsh
Я знайшов перше виправдання, наведене тут, для того, щоб не користуватися === undefined здивування Так, ви можете призначити undefined, але немає законних підстав для цього, і передбачається, що це може призвести до порушення вашого коду. У C ви можете #define true false, і в Python ви можете призначити True і False, але люди не відчувають необхідності розробляти свій код на цих мовах таким чином, щоб захищатись від можливості самі себе навмисно саботувати своє середовище в іншому місці коду. Чому є можливість присвоєння undefined навіть варто тут розглянути? - Mark Amery
на додаток до коментарів Marks я не розумію: "myVar === undefined підніме помилку в ситуації, коли myVar незареєстрований". - чому це погано? Чому б я ні Хочете отримати помилку, якщо я посилаюсь на незадекларовані змінні? - eis
У сучасних браузерах (FF4 +, IE9 +, Chrome невідомий) більше неможливо змінити undefined. MDN: невизначено - Stijn


У JavaScript існує нуль і є невизначено. Вони мають різні значення.

  • невизначено означає, що значення змінної не було визначено; невідомо, що таке значення.
  • нуль означає, що значення змінної визначено і встановлено на нуль (не має значення).

Марийн Хавербеке у своїй безкоштовній онлайн-книзі "Лаконічний JavaScript"(наголос мій):

Існує також аналогічне значення, null, значення якого означає "це значення визначено, але воно не має значення". Різниця в значенні між невизначеними та нульовими переважно є академічною, і, як правило, не дуже цікавою. У практичних програмах часто доводиться перевіряти, чи є щось "має значення". У таких випадках може використовуватися вираз something == undefined, оскільки, хоча вони не точно однакові значення, null == undefined дасть значення true.

Отже, я думаю, що найкращим способом перевірити, чи є щось невизначеним, буде:

if (something == undefined)

Сподіваюся, це допомагає!

Редагувати: У відповідь на ваше редагування властивості об'єкта повинні працювати однаково.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

133
2017-08-26 07:36



якщо (щось == undefined) краще написано так, ніби (щось === undefined) - Sebastian Rittau
Слід зазначити, що це не цілком безпечно. undefined це просто змінна, яку користувач може повторно призначити: написання undefined = 'a'; призведе до того, що ваш код більше не робить те, що ви думаєте. Використовуючи typeof краще, а також працює для змінних (а не лише властивостей), які не були оголошені. - Gabe Moothart
якщо щось є невизначеною глобальною змінною, (щось == undefined) виникає помилка JavaScript. - Morgan Cheng
Проблема з цим полягає в тому, що якщо var a = null, то a == undefined оцінює true, навіть якщо a безумовно визначено. - Andrew
Це тлумачення коментаря "Еволюційний Javascript" назад. Якщо ви дійсно хочете перевірити на невизначеність, запропонований код не буде працювати (він також буде виявляти умову, але значення ще не підтверджено [i.e.null]). Це нульове значення. Пропонований код "if (something == undefined) ..." перевіряє обидва undefined і null (без набору значень), тобто він інтерпретується як "if ((щось невизначене) ІЛИ (щось нульове)" ... "... Те, що автор каже, часто те, що ви дійсно хочу перевірити обидва undefined і null. - Chuck Kollars


Незважаючи на те, що гостро рекомендується багатьма іншими відповідями тут, 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!
}

Отже, якщо ви не робите виявлення функцій2, виникає невизначеність щодо того, чи матиме якесь ім'я (наприклад, перевірку typeof module !== 'undefined' як крок у коді, специфічному для середовища CommonJS), typeof є шкідливим вибором при використанні змінної, а правильним варіантом є безпосереднє порівняння значення:

var foo = …;

if (foo === undefined) {
    ⋮
}

Деякі поширені неправильні уявлення про це включають:

  • це читання "неініціалізованої" змінної (var foo) або параметр (function bar(foo) { … }, називається як bar()) не вийде. Це просто не відповідає дійсності - завжди змінюються змінні без явної ініціалізації та параметри, які не були заданими значеннями undefined, і завжди є об'єктом.

  • це undefined може бути перезаписаний. Там набагато більше. undefined не є ключовим словом у JavaScript. Замість цього це властивість глобального об'єкта з значенням Undefined. Однак з ES5 ця властивість була лише для читання і не налаштовуваний. Жоден сучасний браузер не дозволить undefined майно, яке буде змінено, і станом на 2017 рік це було справою довгий час. Відсутність жорсткого режиму не впливає undefinedРосійська поведінка або - це просто робить висловлювання, як undefined = 5 нічого не робити, а кидати. Хоча це не ключове слово, ви можете декларувати змінні з ім'ям undefined, і ці змінні можуть бути змінені, роблячи цю загальну схему:

    (function (undefined) {
        // …
    })()
    

    більше небезпечний, ніж використання глобального undefined. Якщо ви повинні бути ES3-сумісні, замініть undefined з void 0 - не вдаватися до typeof. (void завжди був універсальним оператором, який оцінює значення Undefined для будь-якого операнда.)

З тим, як змінні працюють поза способом, пора вирішити фактичне питання: властивості об'єкта. Немає ніяких підстав для використання будь-коли 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.
² не вважайте, що не знаючи, що в сферах, все в порядку взагалі, однак. бонусна вразливість, викликана зловживанням динамічного масштабу: Проект Zero 1225
³ ще раз припускаючи середовище ES5 + і це undefined відноситься до undefined властивість глобального об'єкта. замінити void 0 інакше


132
2018-02-26 21:17



@BenjaminGruenbaum Правда, але абсолютно вводить в оману. Будь-який неконфігурований контекст може визначати його власне undefined, приховує за замовчуванням. Який для більшості практичних цілей має такий же ефект, як і перезапис його. - blgt
@ blgt Це параноїчно і не має значення для чогось практичного. Кожен контекст може переопределяти консоль.log, перевизначити методи прототипу Array і навіть переопределювати Function.prototype.call` для підключення та зміни кожного разу, коли ви викликаєте функцію в JavaScript. Захист від цього дуже параноїк і досить дурний. Як я (і minitech) сказав, ви можете використовувати void 0 порівняти проти невизначеності, але знову ж таки - це нерозумно і надмірно. - Benjamin Gruenbaum
Я б хотів, щоб я мав більше одного виграшу, щоб дати. Це найбільш правильна відповідь. Я дійсно хочу перестати бачити typeof something === "undefined")  в коді - Simon Baumgardt-Wellander
@BenjaminGruenbaum Для ледачих програмістів, void 0 є (на один раз) і коротшим і безпечніше! Це перемога в моїй книзі. - wizzwizz4


Що це значить: "невизначене властивість об'єкта"?

Насправді це може означати дві абсолютно різні речі! По-перше, це може означати властивість, яка ніколи не була визначена в об'єкті, по-друге, це може означати, що властивість, яка має невизначене значення. Давайте поглянемо на цей код:

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 в браузерах) Він підтримується з 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 (його також можна використовувати без "глобального" префікса). Я не знаю про інші реалізації серверного JavaScript.


101
2017-08-08 20:28



@Бергі дякую за ваш коментар. Я виправив мою відповідь. На мій захист я можу сказати, що в даний час (за версією 1.0.10.18) офіційна документація Node.jsнічого не говорить про undefined як член Російської Федерації global. Також ні console.log(global); ні for (var key in global) { ... } не показує невизначено як член Російської Федерації глобальний. Але тест, як 'undefined' in global покажи зворотне. - Konstantin Smolyanin
З неї не потрібна додаткова документація це в специфікації EcmaScript, який також говорить це [[Enumerable]] є помилково :-) - Bergi
Що стосується Minuses of typeof obj.prop == 'undefined', цього можна уникнути, написавши як typeof obj.prop == typeof undefined. Це також дає дуже хорошу симетрію. - hlovdal
@ hlovdal: Це абсолютно безглуздо проти obj.prop === undefined. - Ry-♦
Коли ми відповімо на заголовок питання "Виявлення невизначене майно ", не відповідає (різним і набагато простішим) питанням у першому реченні ("перевірте, чи невизначено ..."), ви відповісте if ('foo' in o) ... Ваша відповідь є справді першою правильною відповіддю тут. Майже всі інші просто відповідають цьому реченню. - Frank Nocke


Питання складається з трьох випадків:

  1. Об'єкт має властивість, а його значення немає undefined.
  2. Об'єкт має властивість, і його значення є undefined.
  3. Об'єкт не має властивості.

Це говорить нам щось, що я вважаю важливим:

Існує різниця між невизначеним членом і певним членом з невизначеним значенням.

Але нещасливо 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); }

Але, як згадувалося, це не точно таке (але більш ніж достатньо для моїх потреб).


59
2018-06-08 04:04



Привіт Майкл. Велика пропозиція, і я думаю, що це робить все чистіше. Одна з них, яку я знайшов, це, коли використовується! оператор з "в". Ви повинні сказати if (!("x" in blob)) {} з дужками навколо, тому що! Оператор має перевагу над "в". Надія, що допомагає комусь. - Simon East
Вибачте Майкла, але це невірно, або, принаймні, вводить в оману з урахуванням оригінального питання. 'in' не є достатнім способом перевірити, чи властивість об'єкта має тип undefined. Для підтвердження, будь ласка, перегляньте цю скрипку: jsfiddle.net/CsLKJ/4 - Tex
Ці дві частини коду роблять інше! Розглянемо і поставте об'єкт a = {b: undefined}; потім typeof a.b === typeof a.c === 'undefined' але 'b' in a і !('c' in a). - mgol
+1 OP не вказує, чи існує власність та має значення невизначено, або ж сама властивість невизначена (тобто не існує). - RobG
Я б запропонував змінити точку (2.) у першому столі до { x : undefined } або, принаймні, додати його як іншу альтернативу (2.) у таблиці - мені довелося миттю думати, щоб зрозуміти, що цей пункт (2) оцінює до undefined (хоча ви згадуєте це пізніше). - mucaho


if ( typeof( something ) == "undefined") 

Це працювало для мене, а інші - ні.


38
2017-07-27 16:03



паренси не потрібні, оскільки typeof є оператором - aehlke
Але вони дають зрозуміліше те, що перевіряється. В іншому випадку це може бути прочитано як typeof (something == "undefined"). - Abhi Beckert
Якщо вам потрібні круглі дужки, тоді ви повинні дізнатись про перевагу в операційній системі JS: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/... - Ian
Корисні посилання корисні саме тому, що вам НЕ потрібно вивчати перевагу в операційній системі JS, і вам не потрібно спекулювати чи майбутнім програмістам технічного обслуговування потрібно буде вивчати перевагу оператора в JS. - DaveWalley
Корисне поле корисно пояснити речі. Але в цьому випадку вони просто роблять оператора схожим на функцію. Без сумніву це пояснює наміри програміста. Але якщо ви не впевнені в пріоритеті оператора, то краще записати його як (typeof something) === "undefined". - Robert


Я не впевнений, де джерело використання === з 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

33
2017-09-22 14:20



Чудова точка Еріка. Також є показ результатів з перевірки? - Simon East
@ Симон: навпаки - можна було очікувати, що невеликий ефект продуктивності не дозволить уникнути примусу у випадку "===". Швидкий та брудний тест показав '===' на 5% швидше, ніж '==' під FF5.0.1 - Antony Hatchkins
Більш ретельний тест показав, що під FF, IE та Chrome '==' більш-менш швидше, ніж '===' (5-10%), і Opera взагалі не має жодної різниці: jsperf.com/triple-equals-vs-twice-equals/6 - Antony Hatchkins
Використовуючи == все ще вимагає принаймні перевірка типу - інтерпретатор не може порівняти два операнди, не знаючи їх типу першим. - Alnitak
== це один менш характер, ніж === :) - svidgen


Перехрести мій відповісти з відповідного питання Як перевірити "невизначені" в 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

19
2018-01-13 17:43