javascript - undefined معنى




الكشف عن خاصية كائن غير معرف (20)

" إذا كان (window.x) {} " آمنًا

على الأرجح تريد if (window.x) .هذا الفحص آمن حتى إذا لم يتم الإعلان عن x ( var x;) - لا يلقي المتصفح خطأً.

مثال: أريد معرفة ما إذا كان مستعرضاتي يدعم واجهة برمجة تطبيقات السجل

if (window.history) {
    history.call_some_function();
}

كيف يعمل هذا:

النافذة هي كائن يحتفظ بجميع المتغيرات العالمية كأعضاء ، ومن الطبيعي أن تحاول الوصول إلى عضو غير موجود. إذا لم يتم التصريح عن x أو لم يتم تعيينها ، يتم window.xإرجاع غير معرّف . يؤدي غير معروف إلى false عندما يقوم () بتقييمه.

ما هي أفضل طريقة للتحقق مما إذا كانت خاصية الكائن في JavaScript غير محددة؟


Crossposting answer من سؤال متعلق كيفية التحقق من "غير معرفة" في 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 للتهيئة. عندما تعرف أن جميع المتغيرات التي تعلن أنها قد تمت !window.myvar 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');
}

عندما يكون الشرط الأول والبسيط صحيحًا ، يتخطى المترجم الاختبارات التالية.

من الأفضل دائمًا استخدام مثيل / كائن المتغير للتحقق مما إذا كان لديه قيمة صالحة. إنها أكثر استقرارًا وهي طريقة أفضل للبرمجة.

(ذ)


استعمال:

لمعرفة ما إذا كانت الخاصية غير محددة:

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

للتحقق مما إذا كان الموقع غير معرّف:

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

تتلخص المشكلة في ثلاث حالات:

  1. يحتوي الكائن على الخاصية وقيمته غير undefined .
  2. يحتوي الكائن على الخاصية وقيمته غير undefined .
  3. الكائن ليس لديه الخاصية.

هذا يخبرنا بشيء أعتبره هامًا:

يوجد اختلاف بين عضو غير محدد وعضو محدد ذو قيمة غير محددة.

لكن typeof obj.foo غير 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); }

ولكن كما ذكرنا فإن هذه ليست هي نفسها بالضبط (ولكنها أكثر من كافية لاحتياجاتي).


على الرغم من كونه موصى به بشدة من خلال العديد من الإجابات الأخرى هنا ، فإن 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. بدلاً من ذلك ، تكون خاصية على الكائن العمومي بالقيمة Undefined. ومع ذلك ، منذ 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 للكائن العالمي. void 0 البديل void 0 خلاف ذلك.



لست متأكدًا من مصدر استخدام === مع typeof أتت منه ، 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

ماذا يعني هذا: "خاصية الكائن غير معرفة" ؟

في الواقع ، يمكن أن تعني شيئين مختلفين تمامًا! أولاً ، يمكن أن تعني الخاصية التي لم يتم تعريفها في الكائن ، وثانياً ، يمكن أن تعني الخاصية التي لها قيمة غير محددة . دعونا ننظر في هذا الرمز:

var o = { a: undefined }

هل غير معروف؟ نعم فعلا! قيمتها غير محددة. هو غير محدد؟ بالتأكيد! لا يوجد خاصية "ب" على الإطلاق! حسنًا ، انظر الآن كيف تتصرف الأساليب المختلفة في الحالتين:

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

ملاحظات:

  • لا يمكنك التحقق من كائن وممتلكاته في نفس الوقت. على سبيل المثال ، هذا xa === undefined أو هذا typeof xa == 'undefined' يثير ReferenceError: x is not defined x إذا ReferenceError: x is not defined x.
  • متغير undefined هو متغير شامل (في الواقع إنه window.undefined يتم window.undefined في المتصفحات). وقد تم دعمه منذ الإصدار الأول من ECMAScript ومنذ أن تم قراءة ECMAScript 5 فقط . لذا في المستعرضات الحديثة لا يمكن إعادة تعريفها إلى حقيقة كما يحب العديد من المؤلفين إخافتنا ، ولكن هذا لا يزال صحيحًا بالنسبة للمتصفحات القديمة.

المعركة النهائية: obj.prop === undefined vs typeof obj.prop == 'undefined'

الإيجابيات من obj.prop === undefined :

  • انها أقصر قليلا وتبدو أجمل قليلا
  • سيعطيك محرك جافا سكريبت رسالة خطأ إذا كان لديك خطأ إملائي undefined

obj.prop === undefined of obj.prop === undefined :

  • يمكن تجاوزها undefined في المتصفحات القديمة

الإيجابيات من typeof obj.prop == 'undefined' :

  • إنها حقا عالمية! وهو يعمل في المتصفحات الجديدة والقديمة.

typeof obj.prop == 'undefined' of typeof obj.prop == 'undefined' :

  • 'undefned' ( خطأ إملائي ) هنا هو مجرد ثابت سلسلة ، لذلك لا يمكن أن يساعدك محرك جافا سكريبت إذا كنت قد أخطأت في تهجئة كما فعلت أنا فقط.

تحديث (لجافا سكريبت من جانب الخادم):

يدعم Node.js المتغير الشامل undefined كـ global.undefined (يمكن استخدامه أيضًا بدون البادئة "العمومية"). لا أعرف أي تطبيقات أخرى لجافا سكريبت من جانب الخادم.


أيضا يمكن كتابة نفس الأشياء أقصر:

if (!variable){
    //do it if variable is Undefined
}

أو

if (variable){
    //do it if variable is Defined
}

الذهاب من خلال التعليقات ، لأولئك الذين يريدون التحقق من كل منهما هو غير معرفة أو قيمتها فارغة:

//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;

ها هو موقفي:

أستخدم نتيجة مكالمة REST. يجب تحليل النتيجة من JSON إلى كائن جافا سكريبت.

هناك خطأ واحد يجب أن أدافع عنه. إذا كان args إلى استدعاء الباقي غير صحيحة بقدر ما يحدد المستخدم الخطأ في arg ، فستظهر مكالمة الاستراحة فارغة بشكل أساسي.

أثناء استخدام هذا المنشور لمساعدتي في الدفاع عن هذا ، حاولت ذلك.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

لحالتي ، إذا كان restResult.data [0] === "كائن" ، فعندئذ يمكن أن أبدأ بأمان في فحص بقية الأعضاء. إذا كان غير محدد ثم رمي الخطأ على النحو الوارد أعلاه.

ما أقوله هو أنه بالنسبة لحالتي ، لم تنجح جميع الاقتراحات الواردة أعلاه في هذه المشاركة. أنا لا أقول أنني على حق والجميع على خطأ. أنا لست أستاذ جافا سكريبت على الإطلاق ، ولكن نأمل أن يساعد هذا الشخص.


يمكنك الحصول على مصفوفة غير معروفة بمسار باستخدام التعليمة البرمجية التالية.

 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رابط jsFiddle


أنا استخدم 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غير معروف ويتم تعريفه بعد التهيئة.


أود أن أريكم شيئًا أستخدمه لحماية undefinedالمتغير:

Object.defineProperty(window, 'undefined', {});

هذا يمنع أي شخص من تغيير window.undefinedالقيمة وبالتالي تدمير الكود بناء على هذا المتغير. في حالة استخدام "use strict"، فإن أي شيء يحاول تغيير قيمته سينتهي بالخطأ ، وإلا سيتم تجاهله بصمت.


الحل غير صحيح. في JavaScript ،

null == undefined

سيعود صحيحًا ، نظرًا لأن كليهما يتم "إرسال" إلى قيمة منطقية وهي غير صحيحة. الطريقة الصحيحة ستكون للتحقق

if (something === undefined)

وهو مشغل الهوية ...


جميع الإجابات غير كاملة. هذه هي الطريقة الصحيحة لمعرفة أن هناك خاصية محددة بأنها غير محددة:

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

قراءة من خلال هذا ، أنا مندهش أنني لم أر هذا. لقد وجدت العديد من الخوارزميات التي من شأنها أن تعمل لهذا الغرض.

غير محدد

إذا لم يتم تعريف قيمة الكائن أبدًا ، فسيؤدي ذلك إلى منع الرجوع 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");
}

"propertyName" in obj //-> true | false

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

إرجاع false إذا تم تعيين المتغير ، وصحيح إذا كان غير محدد.

ثم استخدام:

if (isUnset(var)) {
  // initialize variable here
}




undefined