javascript - assignment - what is the operator// used for?




ما هو !!(not not) operator في JavaScript؟ (20)

! "boolean not" ، وهو ما يطبع أساسًا قيمة "enable" (تمكين) إلى منطقيها. الثاني ! يقلب هذه القيمة. لذا ، يعني !!enable "عدم التمكين" ، مما يمنحك قيمة enable أنه منطقي.

رأيت بعض التعليمات البرمجية التي يبدو أنها تستخدم عاملًا لا أعرفه ، في شكل نقطتي تعجب ، مثل: !! . هل يمكن لشخص ما أن يخبرني ما يفعله هذا المشغل؟

السياق الذي رأيت فيه هذا ،

this.vertical = vertical !== undefined ? !!vertical : this.vertical;

Coerces oObject to boolean. إذا كانت خاطئة (مثل 0 ، null ، undefined ، إلخ.) ، ستكون false ، وإلا ، true .

!oObject  //Inverted boolean
!!oObject //Non inverted boolean so true boolean representation

هكذا !! ليس مشغل ، هو فقط ! مشغل مرتين.

مثال العالم الحقيقي "اختبار إصدار IE":

let isIE8 = false;  
isIE8 = !! navigator.userAgent.match(/MSIE 8.0/);  
console.log(isIE8); // returns true or false 

إذا كنت ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns null  

ولكن إذا كنت ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false

أظن أن هذا هو بقايا من C ++ حيث يتجاوز الناس! عامل التشغيل ولكن ليس مشغل bool.

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


أعتقد أن الجدير بالذكر هو أن شرطًا مدمجًا مع منطقي AND / OR لن يعرض قيمة منطقية ولكن النجاح الأخير أو الفشل الأول في حالة && و أول نجاح أو فشل أخير في حالة || من سلسلة الشرط.

res = (1 && 2); // res is 2
res = (true && alert) // res is function alert()
res = ('foo' || alert) // res is 'foo'

لكي نلقي الشرط إلى حرفي منطقي حقيقي يمكننا استخدام النفي المزدوج:

res = !!(1 && 2); // res is true
res = !!(true && alert) // res is true
res = !!('foo' || alert) // res is true

إنها طريقة غامضة بشكل فظيع لإجراء تحويل نوع.

! ليس كذلك . !true false ، و !false true . !0 true ، و !1 غير false .

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

// Maximum Obscurity:
val.enabled = !!userId;

// Partial Obscurity:
val.enabled = (userId != 0) ? true : false;

// And finally, much easier to understand:
val.enabled = (userId != 0);

إنها عملية مزدوجة. الأول ! يحول القيمة إلى قيمة منطقية ويؤدي إلى عكس قيمته المنطقية. الثاني ! يعيد القيمة المنطقية إلى الخلف.


ال !! البنية هي طريقة بسيطة لتحويل أي تعبير JavaScript إلى ما يعادل Boolean الخاص به.

على سبيل المثال: !!"he shot me down" === true و !!0 === false .


الكثير من الإجابات تفعل نصف العمل. نعم ، يمكن قراءة "X" على أنها "صدق X [مثلها منطقية]". لكن !! لا ، من الناحية العملية ، مهم جدا لمعرفة ما إذا كان المتغير الوحيد (أو حتى إذا كان العديد من المتغيرات) صحيح أو كاذب. !!myVar === true هو نفسه myVar فقط. مقارنة !!X إلى منطقي "حقيقي" ليس مفيدًا حقًا.

ما تكسبه مع !! هي القدرة على التحقق من مصداقية المتغيرات المتعددة ضد بعضها البعض بطريقة متكررة وموحدة (و JSLint).

ببساطة الصب :(

هذا هو...

  • 0 === false غير false .
  • !!0 === false true .

ما ورد أعلاه ليست مفيدة جدا. if (!0) النتائج نفسها كما if (!!0 === false) . لا أستطيع التفكير في حالة جيدة لإدخال متغير إلى قيمة منطقية ومن ثم المقارنة مع منطقي "حقيقي".

راجع "== and! =" من اتجاهات JSLint (ملاحظة: يقوم Crockford بتحريك موقعه قليلاً ، وهذا الرابط عرضة للموت في وقت ما) للقليل من الأسباب:

و == و! = مشغلي اكتب الإكراه قبل المقارنة. هذا أمر سيء لأنه يؤدي إلى \ t \ r \ n '== 0 ليكون صحيحًا. هذا يمكن أن يخفي أخطاء الكتابة. لا يمكن لـ JSLint تحديد ما إذا كان يتم استخدام == بشكل صحيح ، لذا فمن الأفضل عدم استخدام == و! = على الإطلاق واستخدام دائمًا عوامل === و! == أكثر موثوقية.

إذا كنت تهتم فقط بأن تكون القيمة صحيحة أو كاذبة ، فاستخدم النموذج القصير. بدلا من
(foo != 0)

فقط قل
(foo)

وبدلا من
(foo == 0)

قل
(!foo)

لاحظ أن هناك بعض الحالات غير الواضحة حيث سيتم عرض منطقي إلى رقم (يتم إرسال true إلى 1 و false إلى 0 ) عند مقارنة منطقي إلى رقم. في هذه الحالة ، !! قد يكون مفيدا عقليا. رغم ذلك ، مرة أخرى ، هذه الحالات حيث تقارن غير منطقي إلى منطقي صلب ، وهو ، imo ، خطأ فادح. if (-1) لا يزال الطريق للذهاب هنا.

╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               Original                ║    Equivalent     ║  Result   ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1 == true) console.log("spam")   ║ if (-1 == 1)      ║ undefined ║
║ if (-1 == false) console.log("spam")  ║ if (-1 == 0)      ║ undefined ║
║   Order doesn't matter...             ║                   ║           ║
║ if (true == -1) console.log("spam")   ║ if (1 == -1)      ║ undefined ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (!!-1 == true) console.log("spam") ║ if (true == true) ║ spam      ║ better
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1) console.log("spam")           ║ if (truthy)       ║ spam      ║ still best
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

وتصبح الأمور أكثر جنونًا اعتمادًا على محركك. WScript ، على سبيل المثال ، يفوز بالجائزة.

function test()
{
    return (1 === 1);
}
WScript.echo(test());

بسبب بعض jive Windows التاريخي ، سوف ينتج ذلك -1 في مربع رسالة! جربها في موجه cmd.exe ونرى! ولكن لا يزال WScript.echo(-1 == test()) يمنحك 0 ، أو false WScript. انظر بعيدا. إنه بشع

مقارنة الصدق :)

ولكن ماذا لو كان عندي قيمتين أحتاج إلى التحقق من المساواة في التوروث / الفالس؟

نتظاهر بأن لدينا myVar1 = 0; و myVar2 = undefined; .

  • myVar1 === myVar2 هو 0 === undefined ومن الواضح أنه خطأ.
  • !!myVar1 === !!myVar2 is !!0 === !!undefined وصحيح! نفس الصدق! (في هذه الحالة ، على حد سواء "لديك حقيقة من الكذب".)

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

لا أستطيع التفكير في حالة استخدام كبيرة وغير مفتعلة لذلك المخرب. ربما لديك حقول "مرتبطة" في نموذج؟

if (!!customerInput.spouseName !== !!customerInput.spouseAge ) {
    errorObjects.spouse = "Please either enter a valid name AND age " 
        + "for your spouse or leave all spouse fields blank.";
}

حتى الآن إذا كان لديك صدق لكل من أو كذب لكلا اسم الزوج والعمر ، يمكنك الاستمرار. بخلاف ذلك ، لن تحصل إلا على حقل واحد ذي قيمة (أو زواج errorObjects جدًا في وقت مبكر) وتحتاج إلى إنشاء خطأ إضافي في مجموعة errorObjects .

EDIT 24 أكتوبر ، 2017:

مكتبات الجهات الخارجية التي تتوقع قيمًا منطقية صريحة

وهنا قضية مثيرة للاهتمام ... !! قد يكون مفيدًا عندما تتوقع libs الطرف الثالث قيم Boolean صريحة.

على سبيل المثال ، يحتوي False في JSX (React) على معنى خاص لا يتم تشغيله بسبب الكذب البسيط. إذا حاولت إرجاع شيء ما مثل ما يلي في JSX ، متوقعًا وجود int في messageCount ...

{messageCount && <div>You have messages!</div>}

... قد تفاجأ برؤية React جعل 0 عند وجود رسائل صفر. يجب عليك إرجاع false بشكل غير صحيح لـ JSX عدم العرض. العبارة أعلاه ترجع 0 ، والتي تقدم JSX بسعادة ، كما ينبغي. لا يمكن أن تخبرك أنه ليس لديك Count: {messageCount && <div>Get your count to zero!</div>} (أو أقل شيوعًا).

  • إصلاح واحد يشمل bangbang ، الذي يكرس 0 إلى !!0 ، وهو false :
    {!!messageCount && <div>You have messages!</div>}

  • توحي مستندات JSX بأنك تكون أكثر وضوحًا ، وكتابة التعليمات البرمجية للتعليق الذاتي ، واستخدام المقارنة لإجبارها على القيمة المنطقية.
    {messageCount > 0 && <div>You have messages!</div>}

  • أنا أكثر راحة التعامل مع الكذب نفسي مع نظام ثلاثي -
    {messageCount ? <div>You have messages!</div> : false}

ضع في اعتبارك أن هذا هو أحد اصطلاحات JSX ، وليس واحدًا مضمّنًا في جافا سكريبت .

ولكن إذا كنت ترى 0 s غريبة في JSX الخاص بك المقدمة ، فكر في الإدارة الفاسدة.


بعض مشغلي جافا سكريبت ينفذون تحويلات من النوع الضمني ، ويتم استخدامها أحيانًا لتحويل النوع.

الأوحد يقوم المشغل بتحويل المعامل الخاص به إلى منطقي وينفيه.

تؤدي هذه الحقيقة إلى العبارة التالية التي يمكنك رؤيتها في شفرة المصدر الخاصة بك:

!!x // Same as Boolean(x). Note double exclamation mark

في while و while التصريحات و ? يستخدم المشغل قيم الحقيقة لتحديد أي فرع من الكود سيتم تشغيله. على سبيل المثال ، الصفر وأرقام NaN والسلسلة الفارغة خاطئة ، لكن الأرقام والسلسلة الأخرى صحيحة. الكائنات صحيحة ، لكن القيمة غير المعرفة والقيمة null هما كاذبة.

عامل النفي المزدوج !! بحساب قيمة الحقيقة لقيمة ما. إنها في الواقع مشغلين ، حيث تعني !!x !(!x) ، وتتصرف كما يلي:

  • إذا كانت x قيمة خاطئة ، !x true ، و !!x هو false .
  • إذا كانت x قيمة حقيقية ، فإن !x غير false ، و !!x true .

عند استخدامها على المستوى الأعلى من السياق المنطقي ( if ، أو ، أو ? ) ، فإن !! المشغل هو سلوكي لا. على سبيل المثال ، if (x) if (!!x) تعني نفس الشيء.

الاستخدامات العملية

ومع ذلك فقد عدة استخدامات عملية.

أحد الاستخدامات هو ضغط كائن لقيمة الحقيقة الخاصة به بشكل ضار ، بحيث لا يحمل كودك إشارة إلى كائن كبير ويبقيه على قيد الحياة. !!some_big_object تعيين بعض !!some_big_object على متغير بدلاً من some_big_object من ذلك لمجمع البيانات المهملة. وهذا مفيد للحالات التي تنتج إما كائنًا أو قيمة خاطئة مثل قيمة null أو غير معرفة ، مثل اكتشاف ميزة المتصفح.

استخدام آخر ، والتي ذكرتها في إجابة عن C's المقابلة !! المشغل ، مع أدوات "الوبر" التي تبحث عن الأخطاء المطبعية الشائعة وعمليات تشخيص الطباعة. على سبيل المثال ، في كل من C وجافا سكريبت ، تنتج بعض الأخطاء الشائعة الشائعة للعمليات المنطقية سلوكيات أخرى لا يكون ناتجها تمامًا مثل Boolean:

  • if (a = b) هو الواجب متبوعًا باستخدام قيمة الحقيقة b ؛ if (a == b) هي مقارنة للمساواة.
  • if (a & b) عبارة عن bitwise AND؛ if (a && b) منطقية AND. 2 & 5 هي 0 (قيمة خاطئة) ؛ 2 && 5 صحيح.

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

الاستخدام الثالث هو إنتاج منطقية XOR والمنطقية XNOR. في كل من C وجافا سكريبت ، a && b بإجراء منطقية AND (صحيح إذا كان كلا الجانبين صحيحين) ، ويقوم a & b بإجراء عملية البت AND AND. a || b a || b ينفذ OR منطقي (صحيح إذا كان واحد على الأقل صحيح) ، و a | b a | b يقوم بتنفيذ دالة OR للخطأ. يوجد XOR (OR OR) على أساس biter مثل a ^ b ، ولكن لا يوجد مشغل مضمن لـ XOR المنطقي (صحيح إذا كان أحد الأطراف صحيحًا بالضبط). قد ترغب ، على سبيل المثال ، في السماح للمستخدم بإدخال نص في أحد حقلين بالضبط. ما يمكنك القيام به هو تحويل كل إلى قيمة الحقيقة ومقارنتها: !!x !== !!y .


هنا هو قطعة من رمز من شبيبة الزاوي

var requestAnimationFrame = $window.requestAnimationFrame ||
                                $window.webkitRequestAnimationFrame ||
                                $window.mozRequestAnimationFrame;

 var rafSupported = !!requestAnimationFrame;

نيتهم ​​هو تعيين raf يعتمد على صواب أو خطأ على أساس توافر وظيفة في requestAnimationFrame

يمكن تحقيقه عن طريق التحقق بطريقة عامة بشكل عام:

if(typeof  requestAnimationFrame === 'function')
rafSupported =true;
else
rafSupported =false;

الطريق القصير يمكن أن تستخدم !!

rafSupported = !!requestAnimationFrame ;

لذلك إذا تم تعيين "طلب تعديل" ، فقد تم تعيين وظيفة "!" من سيكون ذلك صحيحا

إذا كان requestAnimationFrame قد تم تأكيده بعد ذلك! requestAnimationFrame سيكون صحيحًا وواحد آخر! سيكون من الخطأ


وهو يحاكي سلوك وظيفة الصب Boolean() . أول NOT إرجاع قيمة منطقية بغض النظر عن المعامل الذي يتم منحه. الثاني NOT يلغي القيمة Boolean ويعطي القيمة المنطقية true للمتغير. النتيجة النهائية هي نفس استخدام الدالة Boolean() على قيمة.


يطبق !!foo المصطلح unary not operator مرتين ويتم استخدامه للإرسال إلى نوع منطقي مشابه لاستخدام unary plus +foo إلى عدد وسلسلة سلسلة فارغة ''+foo إلى السلسلة.

بدلاً من هذه الاختراقات ، يمكنك أيضًا استخدام وظائف المنشئ المطابقة للأنواع البدائية ( بدون استخدام new ) لقيم الإلقاء الصريحة ،

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo

يقوم بتحويل اللاحقة إلى قيمة منطقية.


!! يحول القيمة إلى يمينها إلى قيمتها المنطقية المكافئة. (فكر بطريقة الرجل الضعيف في "كتابة الصب"). وغالبًا ما ينوي القارئ أن ينقل للقارئ أن الكود لا يهتم بالقيمة في المتغير ، ولكن ما هي قيمة "الحقيقة" .


!!يشبه استخدام منشئ منطقية ، أو يمكن القول أكثر مثل وظيفة منطقية.

console.log(Boolean(null)); // Preffered over the Boolean object

console.log(new Boolean(null).valueOf()); // Not recommended for coverting non-boolean values

console.log(!!null); // A hacky way to omit calling the Boolean function, but essentially does the same thing. 


// The context you saw earlier (your example)
var vertical;

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical; 
        // Let's break it down: If vertical is strictly not undefined, return the boolean value of vertical and set it to this.vertical. If not, don't set a value for this.vertical (just ignore it and set it back to what it was before; in this case, nothing).   

        return this.vertical;
}

console.log( "\n---------------------" )

// vertical is currently undefined

console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = 12.5; // set vertical to 12.5, a truthy value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be true anyway
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = -0; // set vertical to -0, a falsey value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be false either way
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

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

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

لماذا وكيف يعمل

أن تكون موجزة، يبدو شيئا من هذا القبيل: ! ( !null ). في حين أنه nullغير صحيح ، لذلك !nullسيكون ذلك صحيحًا . ثم !trueسيكون كاذبة وسيكون أساسا عكس يعود إلى ما كان عليه من قبل، إلا هذه المرة بوصفه قيمة منطقية سليمة (أو حتى العكس بالعكس مع القيم truthy مثل {}أو 1).


العودة إلى المثال الخاص بك

وعموما ، فإن السياق الذي رأيته يضبط ببساطة this.verticalحسب ما إذا كان verticalيتم تعريفه أم لا ، وإذا كان الأمر كذلك ؛ سيتم ضبطه على القيمة المنطقية الناتجة للعمودي ، وإلا لن يتغير. وبعبارة أخرى ، إذا verticalتم تعريفها ؛ this.verticalسيتم تعيينها إلى القيمة المنطقية لها ، وإلا ، فإنها ستظل كما هي. أعتقد أن هذا في حد ذاته هو مثال لكيفية استخدامك !!، وماذا يفعل.


مثال I / O عمودي

قم بتشغيل هذا المثال وقم بالعبث مع القيمة الرأسية في الإدخال. تعرف على النتيجة التي تشير إليها النتيجة حتى تتمكن من فهم شفرة السياق بالكامل. في الإدخال ، أدخل أي قيمة جافا سكريبت صالحة. تذكر تضمين الاقتباسات إذا كنت تختبر سلسلة. لا تمانع في استخدام شفرة CSS و HTML كثيرًا ، ما عليك سوى تشغيل هذا المقتطف والتلاعب به. ومع ذلك ، قد ترغب في إلقاء نظرة على شفرة جافا سكريبت ذات الصلة بـ DOM على الرغم من ذلك (استخدام منشئ المثال والمتغير الرأسي).

var vertical = document.getElementById("vertical");
var p = document.getElementById("result");

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical;   

        return this.vertical;
}

document.getElementById("run").onclick = function()
{

  p.innerHTML = !!( new Example(eval(vertical.value)).vertical );
  
}
input
{
  text-align: center;
  width: 5em;
} 

button 
{
  margin: 15.5px;
  width: 14em;
  height: 3.4em;
  color: blue;
}

var 
{
  color: purple;
}

p {
  margin: 15px;
}

span.comment {
  color: brown;
}
<!--Vertical I/O Example-->
<h4>Vertical Example</h4>
<code id="code"><var class="var">var</var> vertical = <input type="text" id="vertical" maxlength="9" />; <span class="comment">// enter any valid javascript value</span></code>
<br />
<button id="run">Run</button>
<p id="result">...</p>


!!x اختصار لـ Boolean(x)

يدفع الانفجار الأول محرك js لتشغيل Boolean(x) ولكن له أيضًا التأثير الجانبي لخلع القيمة. لذا فإن الانفجار الثاني يلغي التأثير الجانبي.


اشرب بعض الشاي:

!! ليس مشغل. هذا هو الاستخدام المزدوج ! - وهو العامل المنطقي "لا".

نظريا:

! يحدد "الحقيقة" ما هي القيمة ليست:

  • الحقيقة هي أن false غير true (لهذا السبب !false نتائج !false true )

  • والحقيقة هي أن الحقيقة ليست false (لهذا السبب !true نتائج !true false )

!! يحدد "الحقيقة" ما هي القيمة ليست:

  • والحقيقة هي أن الحقيقة ليست غير true (لهذا السبب !!true النتائج true في true )

  • الحقيقة هي أن false ليس false (هذا هو السبب في أن النتائج false )

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

في التمرين:

ضع في اعتبارك وظيفة مختصرة تقوم باكتشاف وظائف الميزة (وفي هذه الحالة ، توافق النظام الأساسي) عن طريق الكتابة الديناميكية (ويعرف أيضا باسم "كتابة البطة"). نريد أن نكتب دالة ترجع true إذا كان متصفح المستخدم يدعم عنصر <audio> HTML5 ، لكننا لا نريد أن تقوم الدالة بطرح خطأ إذا كان <audio> غير محدد ؛ ونحن لا نرغب في استخدام try ... catch للتعامل مع أي أخطاء محتملة (لأنهم الإجمالي) ؛ كما أننا لا نريد استخدام التحقق داخل الوظيفة التي لن تكشف باستمرار عن حقيقة الميزة (على سبيل المثال ، سيظل document.createElement('audio') مكونًا يسمى <audio> حتى إذا كان HTML5 <audio> غير مدعوم).

فيما يلي الطرق الثلاثة:

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

تقبل كل دالة وسيطة <tag> attribute للبحث عنها ، ولكن كل منهما يقوم بإرجاع قيم مختلفة بناءً على ما تحدده المقارنات.

ولكن انتظر هناك المزيد!

ربما لاحظ بعضكم أنه في هذا المثال المحدد ، يمكن للمرء ببساطة التحقق من خاصية باستخدام وسائل أكثر قليلا من الأداء للتحقق ما إذا كان الكائن المعني لديه خاصية. هناك طريقتان للقيام بذلك:

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

نحن نستخرج ...

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


بعد رؤية كل هذه الإجابات الرائعة ، أود إضافة سبب آخر لاستخدامها !! .Currenty أعمل في Angular 2-4 (TypeScript) وأريد إرجاع منطقي كما هو الحال falseعند عدم مصادقة المستخدم. إذا لم يكن موثقًا ، فسيكون رمز الرمز المميز nullأو "". يمكنني القيام بذلك عن طريق استخدام الكود التالي من الكود:

public isAuthenticated(): boolean {
   return !!this.getToken();
}

استخدم المنطقية لا المشغل مرتين
يعني! true = false
و !! true = true





operators