الكشف عن خاصية كائن غير محددة

Question

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

Answer 1

يستخدم:

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

إذا كان متغير الكائن يحتوي على بعض الخصائص، فيمكنك استخدام نفس الشيء مثل هذا:

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

Answer 2

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

Answer 3

على الرغم من التوصية بشدة بالعديد من الإجابات الأخرى هنا ، 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.
² لا تفترض أن عدم معرفة ما هو موجود في النطاق هو أمر جيد بشكل عام.ثغرة أمنية إضافية ناجمة عن إساءة استخدام النطاق الديناميكي: مشروع صفر 1225
³ مرة أخرى بافتراض وجود بيئة ES5+ وما إلى ذلك undefined بالعودة الى undefined خاصية الكائن العالمي.بديل void 0 خلاف ذلك.}

Answer 4

في جافا سكريبت هناك باطل وهناك غير معرف.لديهم معاني مختلفة.

• غير معرف يعني أن قيمة المتغير لم يتم تعريفها؛من غير المعروف ما هي القيمة.
• باطل يعني أنه تم تعريف قيمة المتغير وتعيينها على قيمة خالية (ليس لها قيمة).

يقول مارين هافيربيكي في كتابه المجاني على الإنترنت "جافا سكريبت بليغة"(التأكيد على الألغام):

هناك أيضًا قيمة مشابهة، فارغة، ومعناها "تم تعريف هذه القيمة، ولكن ليس لها قيمة".الفرق في المعنى بين غير محدد وفارغ هو في الغالب أكاديمي، وعادة ما لا يكون مثيرًا للاهتمام. في البرامج العملية، غالبًا ما يكون من الضروري التحقق مما إذا كان الشيء "له قيمة".في هذه الحالات، يمكن استخدام التعبير شيء == غير محدد، لأنه على الرغم من أنهما ليسا نفس القيمة تمامًا، فإن null == undefense سينتج صحيحًا.

لذا، أعتقد أن أفضل طريقة للتحقق مما إذا كان هناك شيء غير محدد هي:

if (something == undefined)

أتمنى أن يساعدك هذا!

يحرر: استجابة لتعديلك، يجب أن تعمل خصائص الكائن بنفس الطريقة.

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

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

Answer 5

ماذا يعني هذا: "خاصية كائن غير محددة"?

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

var o = { a: undefined }

يكون o.a غير معرف؟نعم!قيمتها غير محددة.يكون o.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 ومنذ الإصدار 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 مساعدتك إذا أخطأت في كتابتها كما فعلت للتو.

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

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

Answer 6

والمسألة تتلخص في ثلاث حالات:

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); }

ولكن كما ذكرنا، فهذه ليست هي نفسها تمامًا (ولكنها أكثر من جيدة بما يكفي لاحتياجاتي).

Answer 7

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

لقد نجح هذا بالنسبة لي بينما لم ينجح الآخرون.

Answer 8

لست متأكدا من أين أصل الاستخدام === مع 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

Answer 9

نشر في منشوراتي إجابة من السؤال ذي الصلة كيفية التحقق من وجود "غير محدد" في جافا سكريبت؟

بخصوص هذا السؤال، راجع حالات الاختبار مع 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

Answer 10

اذا فعلت

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

سوف تفشل عندما يكون المتغير myvar غير موجود، لأنه لم يتم تعريف myvar، وبالتالي فإن البرنامج النصي معطل ولم يكن للاختبار أي تأثير.

نظرًا لأن كائن النافذة يحتوي على نطاق عام (كائن افتراضي) خارج إحدى الوظائف، فسيتم "إرفاق" إعلان بكائن النافذة.

على سبيل المثال:

var myvar = 'test';

المتغير العالمي myvar بالضبط مثل window.myvar أو نافذة ['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');
}

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

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

(ص)

Answer 11

لم أر (آمل ألا أفوّت ذلك) أي شخص يقوم بفحص الكائن قبل العقار.لذا، هذا هو الأقصر والأكثر فعالية (على الرغم من أنه ليس بالضرورة الأكثر وضوحًا):

if (obj && obj.prop) {
  // Do something;
}

إذا كان obj أو obj.prop غير محدد، أو فارغًا، أو "خطأ"، فلن تقوم عبارة if بتنفيذ كتلة التعليمات البرمجية.هذا هو عادة السلوك المطلوب في معظم عبارات كتل التعليمات البرمجية (في JavaScript).

Answer 12

في المقالة استكشاف هاوية اللاغية وغير المحددة في جافا سكريبت قرأت أن الأطر مثل تسطير أسفل السطر.js استخدم هذه الوظيفة:

function isUndefined(obj){
    return obj === void 0;
}

Answer 13

'إذا (window.x) { }' هو خطأ آمن

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

مثال:أريد أن أعرف ما إذا كان متصفحي يدعم History API

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

كيف يعمل هذا:

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

Answer 14

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

Answer 15

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

لم يتم تعريفها أبدًا

إذا لم يتم تحديد قيمة الكائن مطلقًا، فسيمنع ذلك من العودة 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");
}

Answer 16

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

 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 وصلة

Answer 17

ببساطة لم يتم تعريف أي شيء في جافا سكريبت، هو غير معرف, ، لا يهم إذا كانت خاصية داخل كائن/مصفوفة أو مجرد متغير بسيط ...

جافا سكريبت لديها 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 في التعليمات البرمجية الخاصة بك، ولكن إذا كنت تستخدمها مرارًا وتكرارًا، فقم بإنشاء وظيفة مثل العينة الزاويّة التي أشاركها وأواصل إعادة استخدامها على النحو التالي لنمط التعليمات البرمجية DRY.

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

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

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

بهذه البساطة يمكنك الالتفاف داخل عبارة if كما يلي:

if(typeof x !== 'undefined') {
  //do something
}

والذي يساوي أيضًا isDefined in Angular 1.x...

function isDefined(value) {return typeof value !== 'undefined';}

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

أقوم أيضًا بإضافة هذا القسم من MDN الذي يحتوي على معلومات مفيدة حول النوع وغير المحدد والباطل (0).

مساواة صارمة وغير محددة
يمكنك استخدام عوامل المساواة غير المحددة والمساواة الصارمة وعدم المساواة لتحديد ما إذا كان المتغير له قيمة.في الكود التالي ، لم يتم تعريف المتغير x ، ويتم تقييم البيان IF إلى True.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

ملحوظة:عامل المساواة الصارمة بدلا من المساواة القياسية يجب استخدام عامل التشغيل هنا ، لأن x == غير محدد يتحقق أيضا مما إذا كان 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

}

ومع ذلك، ينبغي تجنب هذا النوع من التقنية.جافا سكريبت هو لغة ذات نطاق ثابت ، لذا فإن معرفة ما إذا كان يتم الإعلان عن متغير يمكن أن تقرأ من خلال معرفة ما إذا كان قد تم الإعلان عنها في سياق مرفق.ال الاستثناء الوحيد هو النطاق العالمي ، لكن النطاق العالمي ملزم ب الكائن العام، ومن ثم التحقق من وجود متغير في يمكن القيام بالسياق العالمي عن طريق التحقق من وجود خاصية على الكائن العام (باستخدام عامل التشغيل IN ، على سبيل المثال).

---

عامل باطل وغير محدد

عامل الفراغ هو البديل الثالث.

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`)
}

المزيد > هنا

Answer 18

مقارنة مع void 0, ، للإيجاز.

if (foo !== void 0)

انها ليست مطولة كما if (typeof foo !== 'undefined')

Answer 19

الحل غير صحيح.في جافا سكريبت،

null == undefined

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

if (something === undefined)

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

Answer 20

هنا حالتي:

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

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

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

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

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

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

Answer 21

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

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

Answer 22

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

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

Answer 23

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

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

Answer 24

إذا كنت تستخدم Angular:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

تسطير أسفل السطر:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

Answer 25

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

Answer 26

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

يُرجع خطأ إذا تم تعيين المتغير، ويُرجع صحيحًا إذا كان غير محدد.

ثم استخدام:

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

Answer 27

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

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

أو

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

Answer 28

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

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

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

Answer 29

من lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

يقوم بإنشاء متغير محلي اسمه undefined والتي تتم تهيئتها بالقيمة الافتراضية - الحقيقية undefined, ، ثم يقارن value مع المتغير undefined.

Answer 30

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

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

غير محدد1:

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

غير محدد2:

تحويل قيمة الإدخال إلى سلسلة للمقارنة بها "undefined" والتأكد من قيمتها السلبية.

غير محدد3:

في JS، تعمل المعلمة الاختيارية عندما تكون قيمة الإدخال مطابقة تمامًا undefined.