Nedir !! (değil) operatörü JavaScript’te?


Alınan cevaba git


Öyle gibi iki ünlem işareti şeklinde, tanımadığım bir operatör kullanmak gibi görünüyor bazı kodlar gördük: !! . Birisi lütfen bu operatörün ne yaptığını söyleyebilir mi?

Bunu gördüğüm bağlam,

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

2857





2009-04-24




Cevap sayısını say: 30






oObject Boole zorlanır . De (örneğin 0, Falsey idiyse null , undefined vs.), bu olacak false , aksi takdirde, true .

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

Yani !! bir operatör değil, sadece ! iki kez operatör.

Gerçek Dünya Örneği "Test IE sürümü":

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

Eğer sen

 console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns either an Array or null  
 

ama eğer ⇒

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

2550


2009-04-24





Bir tür dönüştürmesi yapmak için korkunç bir yol.

! olduğu DEĞİL . Yani !true olduğunu false ve !false bir true . !0 olduğu true ve !1 bir false .

Yani bir değeri bir boole dönüştürür, sonra tersine çevirir, sonra tekrar tersine çevirirsiniz.

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

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

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

823


2009-09-10





!!expr İfadenin doğruluğuna bağlı olarak bir Boole değeri ( true veya false ) döndürür . Boole olmayan tiplerde kullanıldığında daha anlamlı olur. Bu örnekleri, özellikle de 3. örneği ve ileriyi düşünün:

           !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 is truthy

             !!"" === false // empty string is falsy
          !!"foo" === true  // non-empty string is truthy
        !!"false" === true  // ...even if it contains a falsy value

     !!window.foo === false // undefined is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!
 

425


2012-05-15





Biraz çay demleyin:

!! bir operatör değil. ! Mantıklı "değil" işlecinin - çift ​​kullanımıdır .


Teoride:

! bir değerin ne olmadığının "gerçeğini" belirler:

  • Gerçek şu ki false değil true (bu yüzden !false sonuçlanır true )

  • Gerçek şu ki true değil false (bu yüzden !true sonuçlanır false )


!! bir değerin ne olmadığı "gerçeğini" belirler :

  • Gerçek şu ki true değil değil true (en bu yüzden !!true sonuçlanır true )

  • Gerçek şu ki false değil değil false (en bu yüzden !!false sonuçlanır false )


Ne kıyasla belirlemek isteyen "gerçek" olduğunu hakkında bir referans değerinin değil, değeri referans kendisi. Bir değer hakkındaki gerçeği bilmek isteyebileceğimiz, değerin olmasını false (veya falsey) beklememize rağmen ya da değerin türünün olmamasını beklememize rağmen, bir kullanım durumu vardır boolean .


Uygulamada:

Dinamik yazarak (yani "ördek yazarak") özellik işlevselliğini (ve bu durumda platform uyumluluğu) algılayan özlü bir işlev düşünün . true Bir kullanıcının tarayıcısı HTML5 <audio> öğesini destekliyorsa döndüren bir işlev yazmak istiyoruz , ancak işlev <audio> tanımsızsa bir hata atmak istemiyoruz ; ve try ... catch olası hataların üstesinden gelmek istemiyoruz (çünkü çok büyükler); ve ayrıca , fonksiyonun içinde sürekli olarak gerçeği açığa çıkarmayacak bir kontrol işlevi kullanmak istemiyoruz (örneğin, HTML5 desteklenmese bile document.createElement('audio') , hala denilen bir öğe oluşturacaktır ). <audio> <audio>


İşte üç yaklaşım:

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

Her işlev a <tag> ve a için bir argüman kabul eder attribute , ancak her biri karşılaştırmaların belirlediği şeye bağlı olarak farklı değerler döndürür.

Ama bekleyin, dahası var!

Bazılarınız muhtemelen bu özel örnekte, bir sadece hafifçe kullanarak bir özellik için kontrol edebilir fark daha fazla ölçülebilir söz konusu nesne olmadığını kontrol araçlarını sahip bir özellik. Bunu yapmanın iki yolu vardır:

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

Daldık ...

Bununla birlikte, nadir görülen bu durumlar olabilir, en özlü, en iyi performans gösteren ve bu nedenle en çok tercih edilen yöntemlerin, true boolean olmayan, muhtemelen tanımsız bir değerden gerçekten de faydalanılarak elde edildiği birkaç senaryo olabilir !! . Umarım bu gülünç temizler.


143


2013-02-22





!! değeri sağındaki değerine eşdeğer boole değerine dönüştürür. (Zavallı adamın "tip atışı" yöntemini düşünün). Onun niyeti kod umursamayan o okuyucuya aktarmaya genellikle neyi değer değişkeni olduğunu, ama onun neyi "gerçek" değer olduğunu.


95


2009-09-10





!!foo unary not operatörünü iki kez uygular ve unary plus kullanımına benzer şekilde boolean tipine döküm yapmak için kullanılır ve +foo sayıya döküm yapmak için boş bir stringi birleştirmek için kullanılır ''+foo .

Bunun yerine bu kesmek, ayrıca (ilkel türlerine karşılık gelen yapıcı işlevleri kullanabilirsiniz olmadan kullanarak new açıkça dökme değerlere, yani kadar)

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

65


2009-09-10





İşin yarısını yapan pek çok cevap var. Evet, !!X “X'in [bir boole olarak temsil edilir] gerçeği” olarak okunabilirdi. Ancak !! , pratik olarak konuşmamak, tek bir değişkenin truthy veya falsy olup olmadığını anlamak için çok önemli değil. !!myVar === true sadece aynıdır myVar . !!X "Gerçek" bir boole ile karşılaştırmak gerçekten yararlı değildir.

Hangi konuda kazanç !! birden değişkenlerin truthiness kontrol yeteneği birbirlerine karşı bir standardize, tekrarlanabilir (ve JSLint dostu) moda.

Basitçe döküm :(

Yani...

  • 0 === false olduğunu false .
  • !!0 === false olduğunu true .

Yukarıdakiler o kadar kullanışlı değil. if (!0) size aynı sonuçları verir if (!!0 === false) . Bir değişkeni boole dönüştürmek ve daha sonra "gerçek" bir boole ile karşılaştırmak için iyi bir durum düşünemiyorum.

JSLint'in talimatlarından "== ve! =" Bölümüne bakın (not: Crockford sitesini bir parça hareket ettiriyor; bu bağlantı bir noktada ölmekle yükümlüdür) neden:

== ve! = Operatörleri karşılaştırmadan önce zorlama yaparlar. Bu kötüdür çünkü '\ t \ r \ n' == 0 doğru olabilir. Bu tür hataları maskeleyebilir. JSLint, == doğru bir şekilde kullanılıp kullanılmadığını güvenilir bir şekilde belirleyemez, bu nedenle == ve! = Hiç kullanmamak ve her zaman daha güvenilir === ve! == operatörlerini kullanmak en iyisidir.

Bir değerin sadece rutubetli veya sahte olduğuna dikkat ediyorsanız, kısa formu kullanın. Yerine
(foo != 0)

sadece söyle
(foo)

ve yerine
(foo == 0)

söylemek
(!foo)

Bir boolenin bir sayı ile karşılaştırılması sırasında bir boolinin sayıya dönüştürüleceği ( true kullanılacağı 1 ve false kullanılacağı 0 ) bazı sezgisel durumlar olduğunu unutmayın . Bu durumda, !! zihinsel olarak faydalı olabilir. Yine de, bunlar, bir boole olmayanı sert bir boole ile kıyasladığınız durumlardır, yani ciddi bir hata. if (-1) hala buraya gitmenin yolu.

 ╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               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
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝
 

Ve motorunuza bağlı olarak işler daha da deliriyor. Örneğin WScript ödülü kazanıyor.

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

Bazı tarihi Windows jiveları nedeniyle, bir mesaj kutusuna -1 çıkacak ! Bir cmd.exe isteminde deneyin ve görün! Ama WScript.echo(-1 == test()) yine de sana 0 veya WScript veriyor false . Gözlerini başka yöne çevirmek. Bu iğrenç.

Doğruluk karşılaştırılması :)

Peki ya benim iki değerim varsa, eşit truthi / falsiessess kontrol etmem gerekir?

Elimizdeki Pretend myVar1 = 0; ve myVar2 = undefined; .

  • myVar1 === myVar2 açık 0 === undefined ve yanlış.
  • !!myVar1 === !!myVar2 olduğu !!0 === !!undefined ve doğrudur! Aynı doğruluk! (Bu durumda, her ikisi de "sahtekârlık gerçeğine sahiptir")

Yani "boolean-cast değişkenleri" kullanmanız gereken tek yer, her iki değişkenin de aynı gerçekliğe sahip olup olmadığını kontrol ettiğiniz bir durum olsaydı, değil mi? Yani, kullanım !! iki vars olup olmadığını görmek için gerekirse truthy veya her ikisi falsy hem , (veya değil), eşit (veya değil) doğruluğuna .

Bu hazırlıksız kullanım için büyük, kesin olmayan bir kullanım durumu düşünemiyorum. Belki bir formda "bağlantılı" alanlar vardır?

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

Demek artık ikisi için de bir truthy varsa veya eş adı ve yaşı ikisi için de bir falsy, devam edebilir. Aksi halde, değeri (veya çok erken ayarlanmış bir evlilik) olan yalnızca bir alanınız olur ve errorObjects koleksiyonunuzda fazladan bir hata oluşturmanız gerekir .


EDIT 24 Eki 2017, 6 Şub 19:

Açık Boolean değerleri bekleyen 3. parti kütüphaneler

İşte ilginç bir durum ... !! 3. parti libleri açık Boolean değerleri beklediğinde faydalı olabilir.

Örneğin, JSX'teki False (React) basit yanlışlıkla tetiklenmemiş özel bir anlamı vardır. JSX'inizde aşağıdaki gibi bir şey döndürmeyi denediyseniz, bir int beklemek messageCount ...

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

... 0 sıfır mesajınız varken React'in a oluşturduğunu görünce şaşırabilirsiniz . JSX'in oluşturmaması için açıkça false döndürmeniz gerekir. Yukarıdaki ifade 0 , JSX’in olması gerektiği gibi mutlu olmasını sağlayan bir sonuçtur. Size sahip olmadığınızı söyleyemez Count: {messageCount && <div>Get your count to zero!</div>} (ya da daha az tartışmalı bir şey).

  • Bir düzeltme coerces BangBang, içerir 0 içine !!0 olan false :
    {!!messageCount && <div>You have messages!</div>}

  • JSX’in dokümanları daha açık olmanızı, kendi kendini yorumlama kodunu yazmanızı ve bir Boole’ye zorlamak için bir karşılaştırma yapmanızı önermektedir.
    {messageCount > 0 && <div>You have messages!</div>}

  • Sahtekarlıkla kendimi üçlü bir şekilde ele almak daha rahatım.
    {messageCount ? <div>You have messages!</div> : false}

Typescript'te aynı anlaşma: Bir boole döndüren bir işleviniz varsa (veya bir boole değişkenine bir değer atarsanız), [genellikle] bir boolean-y değeri döndüremez / atamadı; şiddetle yazılmış bir boolean olmalı. Bunun anlamı, iff myObject yazıldığında , return !myObject; boolean döndüren bir işlev için çalışır, ancak return myObject; yazmaz. return !!myObject Typescript'in beklentilerine uymak zorundasın .

Typescript istisnası? Eğer myObject bir oldu any , geri JavaScript'in Vahşi Batı'da konum ve olmadan iade edebilirsiniz !! dönüş tipi bir boolean olsa bile.

Bunların Javascript'e özgü olmayan JSX & Typescript kuralları olduğunu unutmayın .

Fakat 0 işlenmiş JSX'inizde garip şeyler görüyorsanız , gevşek sahte yönetim düşünün.


63


2015-04-29





Bu sadece iki kez mantıksal NOT operatörü değil, bir şeyi boole dönüştürmek için kullanılıyor, örneğin:

 true === !!10

false === !!0
 

51


2009-04-24





Soneki bir Boolean değerine dönüştürür.


30


2009-09-10





Bu çift not operasyon. Birincisi ! , değeri boole dönüştürür ve mantıksal değerini tersine çevirir. İkinci ! mantıksal değeri geri çevirir.


24


2009-09-10





Boolean() Döküm işlevinin davranışını simüle eder . İlki, NOT hangi işlenenin verildiğine bakılmaksızın bir Boolean değeri verir. İkincisi NOT bu Boolean değeri olumsuzlar ve böylece true bir değişkenin Boolean değerini verir . Sonuç, Boolean() fonksiyonun bir değer üzerinde kullanılması ile aynıdır .


22


2011-03-23





!! Operatörün çift bir olumsuzlama ile sonuçlandığı anlaşılıyor .

 var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true
 

21


2009-04-24





! "boolean not değil" ifadesidir, esasen "enable" değerini booleanin karşısına yazmaktadır. İkinci ! bu değeri çevirir. Yani, !!enable "bir etkin değil" demek, size enable bir boole olarak değer vermek .


18


2009-09-10





Bence kayda değer, mantıksal AND / OR ile birleştirilen bir koşulun bir boolean değeri getirmeyeceği, ancak son olarak veya ilk ve son olarak başarısız olması durumunda && ve ilk veya son olarak başarısız olması durumunda || durum zincirinin

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

Durumu gerçek bir boole değişmezine çevirmek için çift olumsuzlamayı kullanabiliriz:

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

17


2016-05-25





!! Yapı kendi Boole eşdeğer içine herhangi bir JavaScript ifadesini dönüm basit bir yoludur.

Örneğin: !!"he shot me down" === true ve !!0 === false .


14


2014-04-09





Tek bir operatör değil, iki kişi. Aşağıdakine eşdeğerdir ve Boolean'a bir değer vermenin hızlı bir yoludur.

 val.enabled = !(!enable);
 

12


2009-09-10





!! NOT iki işlemi birlikte kullanıyor ! , değeri boolean a'ya çevirip tersine çeviriyor, işte nasıl !! çalıştığını görmek için basit bir örnek :

İlk başta, sahip olduğunuz yer:

 var zero = 0;
 

Öyleyse !0 , boolean'a dönüştürülür ve değerlendirilir true , çünkü 0, falsy tersine çevrilen değeri alır ve boolean'a dönüştürür, böylece değerlendirilir true .

 !zero; //true
 

ancak değerin tersine çevrilmiş boole versiyonunu istemiyoruz , bu yüzden sonucumuzu almak için tekrar tersine çevirebiliriz! Bu yüzden başka kullanıyoruz ! .

Temel olarak, !! bize, elde ettiğimiz değerin boolean, falsy değil, truthy veya string vs ... olduğundan emin olun.

Bu Boolean , javascript'te işlevi kullanmak gibi , ancak bir değeri boole değerine dönüştürmenin kolay ve kısa yoludur:

 var zero = 0;
!!zero; //false
 

12


2017-06-24





if Ve while tablolar ve ? operatör kullanımı gerçeği değerleri vadede kod hangi dalı belirlemek için. Örneğin, sıfır ve NaN sayıları ve boş dize yanlıştır, ancak diğer sayılar ve dizeler doğrudur. Nesneler doğrudur, fakat tanımsız değer ve null ikisi de yanlıştır.

İkili olumsuzlama işleci !! bir değerin doğruluk değerini hesaplar. Aslında iki operatör var, nerede !!x demektir !(!x) ve şu şekilde davranır:

  • Eğer x , yanlış bir değerdir !x olduğunu true ve !!x bir false .
  • Eğer x gerçek bir değer !x ise false , !!x vedir true .

Boolean bağlamda üst düzeyinde kullanıldığında ( if , while ya da ? ), !! operatör davranışsal no-operasyon. Örneğin, if (x) ve if (!!x) aynı anlama geliyor.

Pratik kullanımlar

Bununla birlikte, birkaç pratik kullanımı vardır.

Bir kullanım, bir nesneyi gerçeğe uygun değerine zararsız bir şekilde sıkıştırmaktır, böylece kodunuz büyük bir nesneye başvuruda bulunmaz ve hayatta kalmaz. !!some_big_object Bunun yerine bir değişkene atamak some_big_object , çöp toplayıcı için serbest bırakılmasını sağlar. Bu, bir nesneyi veya bunun gibi yanlış bir değeri null veya tarayıcı özelliği algılama gibi tanımsız değeri üreten durumlar için kullanışlıdır .

C'nin ilgili !! operatörü hakkında bir cevapta bahsettiğim bir diğer kullanım, genel yazım hataları ve baskı teşhisi arayan "tüysüz" araçlardır. Örneğin, hem C hem de JavaScript'te, Boolean işlemleri için birkaç yaygın yazım hatası, çıktısı Boolean gibi olmayan başka davranışlar oluşturur:

  • if (a = b) doğruluk değerini kullanarak takip edilen ödevdir b ; if (a == b) eşitlik karşılaştırmasıdır.
  • if (a & b) bitidir VE; if (a && b) mantıklı bir VE. 2 & 5 olduğu 0 (yanlış bir değer); 2 && 5 doğru.

!! Operatör ne yazmış ne anlama geldiğini olduğu tiftik aracını güvence: bu işlem, daha sonra sonucun doğruluk değerini almak yoktur.

Üçüncü kullanım mantıksal XOR ve mantıksal XNOR üretmektir. Hem C hem de JavaScript'te, a && b mantıksal bir AND (her iki taraf da doğruysa true) a & b gerçekleştirir ve bit yönünde bir AND gerçekleştirir. a || b mantıksal bir OR gerçekleştirir (en az biri doğruysa doğru) ve a | b bit yönünde bir OR gerçekleştirir. Bitsel bir XOR (özel VEYA) a ^ b var, ancak mantıksal XOR için yerleşik bir operatör yok (bir tarafın doğru olması durumunda geçerlidir). Örneğin, kullanıcının tam olarak iki alandan birine metin girmesine izin vermek isteyebilirsiniz. Ne yapabilirsiniz bir hakikat değerine her dönüştürmek ve bunları karşılaştırmak olduğunu: !!x !== !!y .


9


2016-03-06





Bunun, C ++ 'dan insanların artık geride bıraktığı bir artık olduğundan şüpheleniyorum! operatör ama bool operatörü değil.

Bu yüzden, bu durumda olumsuz (veya olumlu) bir cevap almak için önce kullanmanız gerekir! Bir boolean almak için operatör, ancak olumlu durumda kontrol etmek istiyorsanız kullanmak istiyorsunuz !!


8


2009-04-24





Çift Boolean Olumsuzluk. Genellikle değerin tanımsız olup olmadığını kontrol etmek için kullanılır.


7


2010-12-02





Burada çok sayıda harika cevap var, ancak bu kadarını okuduysanız, bu bana 'almamda yardımcı oldu. Konsolu Chrome'da (vb.) Açın ve yazmaya başlayın:

 !(!(1))
!(!(0))
!(!('truthy')) 
!(!(null))
!(!(''))
!(!(undefined))
!(!(new Object())
!(!({}))
woo = 'hoo'
!(!(woo))
...etc, etc, until the light goes on ;)
 

Doğal olarak, bunların hepsi sadece bazılarını yazmakla aynıdır !! someThing, ancak eklenen parantezler daha anlaşılır olmasına yardımcı olabilir.


7


2014-04-24





!!x kısaca Boolean(x)

İlk patlama js motorunu çalışmaya zorlar Boolean(x) ancak aynı zamanda değerin tersine çevrilmesinin de yan etkisi vardır. Böylece ikinci patlama yan etkiyi geri alır.


7


2015-12-04





Her şeyi boole olmaya zorlar.

Örneğin:

 console.log(undefined); // -> undefined
console.log(!undefined); // -> true
console.log(!!undefined); // -> false

console.log('abc'); // -> abc
console.log(!'abc'); // -> false
console.log(!!'abc'); // -> true

console.log(0 === false); // -> undefined
console.log(!0 === false); // -> false
console.log(!!0 === false); // -> true
 

5


2018-07-25





Sadece bunu eklemek istedim

 if(variableThing){
  // do something
}
 

aynıdır

 if(!!variableThing){
  // do something
}
 

Ancak, bir şey tanımsız olduğunda bu bir sorun olabilir.

 // a === undefined, b is an empty object (eg. b.asdf === undefined)
var a, b = {};

// Both of these give error a.foo is not defined etc.
// you'd see the same behavior for !!a.foo and !!b.foo.bar

a.foo 
b.foo.bar

// This works -- these return undefined

a && a.foo
b.foo && b.foo.bar
b && b.foo && b.foo.bar
 

Burada hile zinciri olan && dönecektir s ilk Falsey değerini bulduğu - ve eğer bu bir beslenebilir deyimi vb b.foo tanımlanmamış Yani, eğer tanımsız ve atlama döndürecektir b.foo.bar deyimi ve biz hiçbir almak hata.

Yukarıdakiler undefined döndürür, ancak boş bir dizgeniz varsa, false, null, 0, undefined bu değerler döndürülür ve zincirde karşılaştığımız andan itibaren geri döner - [] ve {} her ikisi de "truthy" olur ve sözde "devam eder" && zincir "sağdaki bir sonraki değere.

PS Aynı şeyi yapmanın başka bir yolu (b || {}).foo , çünkü b tanımsızsa o zaman b || {} olacaktır {} ve “tanımsız” içindeki bir değere erişmeye çalışmak yerine boş bir nesnede bir değere erişiyor olacaksınız (hata yok) (bir hataya neden olur) ). Yani, (b || {}).foo aynı b && b.foo ve ((b || {}).foo || {}).bar aynıdır b && b.foo && b.foo.bar .


5


2016-10-19





Burada açısal js kodundan bir parça

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

 var rafSupported = !!requestAnimationFrame;
 

niyetleri requestAnimationFrame işlevinin kullanılabilirliğine bağlı olarak rafSupported öğesini doğru ya da yanlış olarak ayarlamaktır

genel olarak aşağıdaki şekilde kontrol ederek elde edilebilir:

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

kısa yol kullanıyor olabilir!

 rafSupported = !!requestAnimationFrame ;
 

requestAnimationFrame bir işleve atanırsa, o zaman! requestAnimationFrame yanlış ve bir tane daha olur! bunun doğru olurdu

requestAnimationFrame tanımsız olarak tanımlandıysa o zaman! requestAnimationFrame doğru ve bir tane daha olur! yanlış olur


4







Tüm bu harika cevapları gördükten sonra kullanmak için başka bir sebep eklemek istiyorum !! . Currenty Angular 2-4 (TypeScript) ile çalışıyorum ve false kullanıcımın kimliği doğrulanmadığında olduğu gibi bir boole döndürmek istiyorum . Kimlik doğrulaması yapılmadıysa, belirteç dizgisi null ya da olur "" . Bunu bir sonraki kod bloğunu kullanarak yapabilirim:

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

4


2017-03-29





Bu soru oldukça ayrıntılı bir şekilde cevaplandı, ancak umarım mümkün olduğunca basitleştirilebileceğine dair bir cevap eklemek istiyorum. kavramak kadar basit.

Javascript "truthy" ve "falsey" değerleri olarak adlandırılan değerlere sahip olduğu için, incelenen değer ya da ifadenin gerçekte true ya da olmasa da, diğer ifadelerde değerlendirildiğinde doğru ya da yanlış koşulla sonuçlanacağı ifadeleri vardır false .

Örneğin:

 if (document.getElementById('myElement')) {
    // code block
}
 

Eğer bu eleman aslında varsa, ifade doğru olarak değerlendirilir ve kod bloğu çalıştırılır.

Ancak:

 if (document.getElementById('myElement') == true) {
    // code block
}
 

... gerçek bir koşulla sonuçlanmayacaktır ve eleman mevcut olsa bile kod bloğu çalıştırılmayacaktır.

Niye ya? Çünkü document.getElementById() bu if() ifadede doğru olarak değerlendirecek bir "gerçek" ifadesidir , ancak gerçek bir boole değeri değildir true .

Bu durumda çift "değil" oldukça basittir. Sadece not arka arkaya iki saniye.

Bunlardan ilki, gerçek bir boolean türüyle sonuçlanan, gerçeği veya falsey değerini "tersine çevirir" ve ikincisi, gerçek bir boolean türüyle sonuçlanan "ters" eder, ancak şimdi gerçek bir boolean değerindedir. Bu şekilde tutarlılık var:

 if (!!document.getElementById('myElement')) {}
 

ve

 if (!!document.getElementById('myElement') == true) {}
 

beklendiği gibi her şey doğru dönecektir.


4


2019-03-10





JavaScript'teki bazı operatörler örtülü tür dönüşümleri gerçekleştirir ve bazen tür dönüşümü için kullanılır.

Birlik ! operatörü, işlecini bir boole dönüştürür ve olumsuzlar.

Bu gerçek, kaynak kodunuzda görebileceğiniz aşağıdaki deyime yol açar:

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

3


2015-07-01





Mantıksal olmayan işleci iki kez kullanın
! True = false
ve !! true = true


3


2016-07-15





Bir değişkenin boolean değerini döndürür.

Bunun yerine, Boolean sınıf kullanılabilir.

(lütfen kod açıklamalarını okuyun)

 var X = "test"; // X value is "test" as a String value
var booleanX = !!X // booleanX is `true` as a Boolean value beacuse non-empty strings evaluates as `true` in boolean
var whatIsXValueInBoolean = Boolean(X) // whatIsXValueInBoolean is `true` again
console.log(Boolean(X) === !!X) // writes `true`
 

Yani Boolean(X) = !!X kullanımda.

Lütfen kod parçacığını aşağıda kontrol edin

 let a = 0
console.log("a: ", a) // writes a value in its kind
console.log("!a: ", !a) // writes '0 is NOT true in boolean' value as boolean - So that's true.In boolean 0 means false and 1 means true.
console.log("!!a: ", !!a) // writes 0 value in boolean. 0 means false.
console.log("Boolean(a): ", Boolean(a)) // equals to `!!a`
console.log("\n") // newline

a = 1
console.log("a: ", a)
console.log("!a: ", !a)
console.log("!!a: ", !!a) // writes 1 value in boolean
console.log("\n") // newline

a = ""
console.log("a: ", a)
console.log("!a: ", !a) // writes '"" is NOT true in boolean' value as boolean - So that's true.In boolean empty strings, null and undefined values mean false and if there is a string it means true.
console.log("!!a: ", !!a) // writes "" value in boolean
console.log("\n") // newline

a = "test"
console.log("a: ", a) // writes a value in its kind
console.log("!a: ", !a)
console.log("!!a: ", !!a) // writes "test" value in boolean

console.log("Boolean(a) === !!a: ", Boolean(a) === !!a) // writes true 


3


2017-07-11