Türün Boolean olup olmadığını kontrol etme

Bir değişkenin türünün Boolean türünde olup olmadığını nasıl kontrol edebilirim?

Yani, bazı alternatifler var:

if(jQuery.type(new Boolean()) === jQuery.type(variable))
      //Do something..

Ama bu bana pek hoş gelmiyor.

Bunu başarmanın daha temiz bir yolu var mı?

Bunun typeofiçin var. Parantez, bir işleç olduğu için isteğe bağlıdır .

if (typeof variable === "boolean"){
  // variable is a boolean
}

Sadece ilkel bir değer olup olmadığını kontrol etmek istiyorsanız

typeof variable === 'boolean'

Bazı garip nedenlerden dolayı yapıcı ile oluşturulan booleanlarınız varsa, bunlar gerçekten boolean değil, ilkel bir boolean değeri içeren nesnelerdir ve hem ilkel boolean'ları hem de ile oluşturulan nesneleri kontrol etmenin bir yolu new Boolean:

function checkBool(bool) {
    return typeof bool === 'boolean' || 
           (typeof bool === 'object' && 
            bool !== null            &&
           typeof bool.valueOf() === 'boolean');
}

function checkBool(bool) {
    return typeof bool === 'boolean' || 
           (typeof bool === 'object' && 
            bool !== null            &&
           typeof bool.valueOf() === 'boolean');
}

console.log( checkBool( 'string'          )); // false, string
console.log( checkBool( {test: 'this'}    )); // false, object
console.log( checkBool( null              )); // false, null
console.log( checkBool( undefined         )); // false, undefined
console.log( checkBool( new Boolean(true) )); // true
console.log( checkBool( new Boolean()     )); // true
console.log( checkBool( true              )); // true
console.log( checkBool( false             )); // true

İle saf JavaScript , sadece basitçe kullanabilirsiniz typeofve böyle bir şey yapmak typeof falseya da typeof trueve onu dönecektir "boolean"...

Ama bunu yapmanın tek yolu bu değil, JavaScript'te Boole için kontrol edebileceğiniz farklı yolları göstermek için aşağıdaki işlevleri oluşturuyorum , ayrıca bazı yeni çerçevelerde yapabileceğiniz farklı yollar, bununla başlayalım:

function isBoolean(val) {
   return val === false || val === true;
}

Veya tek satır ES6 yolu ...

const isBoolean = val => 'boolean' === typeof val;

ve şöyle deyin!

isBoolean(false); //return true

Ayrıca Underscore kaynak kodu onlar (_ ile fonksiyon adının başında.) Şöyle kontrol edin:

isBoolean = function(obj) {
   return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
};

Ayrıca jQuery'de şöyle kontrol edebilirsiniz:

jQuery.type(true); //return "boolean"

Gelen tepki , propTypes kullanıyorsanız, böyle boole olmak bir değer kontrol edebilirsiniz:

MyComponent.propTypes = {
  children: PropTypes.bool.isRequired
};

TypeScript kullanıyorsanız , boolean türünü de kullanabilirsiniz :

let isDone: boolean = false;

Ayrıca bunu yapmanın başka bir yolu, değeri boole'ye dönüştürmek ve hala aynı olup olmadığını görmek gibidir:

const isBoolean = val => !!val === val;

veya benzeri:

const isBoolean = val => Boolean(val) === val;

ve ara!

isBoolean(false); //return true

JavaScript için basit bir kontrol olduğu için bunun için herhangi bir çerçeve kullanılması önerilmez.

Bunu jQuery ile veya jQuery olmadan kontrol etmenin üç "vanilya" yolu vardır.

1. Birincisi, boolean değerlendirmeyi zorlama ile zorlamak, ardından orijinal değere eşit olup olmadığını kontrol etmektir:

   function isBoolean( n ) {
       return !!n === n;
   }

2. Basit bir typeofkontrol yapmak:

   function isBoolean( n ) {
       return typeof n === 'boolean';
   }

3. Bir sınıf sarıcısının bir ilkel üzerinde tamamen aşırı ve gereksiz bir şekilde başlatılması:

   function isBoolean( n ) {
       return n instanceof Boolean;
   }

Üçüncüsü, sadece bir sınıf oluşturup true içeri girerseniz geri döner new Boolean.

İlkel baskılar (# 1'de gösterildiği gibi) hakkında ayrıntılı bilgi vermek için tüm ilkel tipler şu şekilde kontrol edilebilir:

• Boolean:

  function isBoolean( n ) {
      return !!n === n;
  }

• Number:

  function isNumber( n ) {
      return +n === n;
  }

• String:

  function isString( n ) {
      return ''+n === n;
  }

Bunu başarmak için saf Javascript kullanabilirsiniz:

var test = true;
if (typeof test === 'boolean')
   console.log('test is a boolean!');

İşlevinizin boolean nesnelerini de doğrulayabilmesini istiyorsanız, en etkili çözüm şöyle olmalıdır:

function isBoolean(val) {
  return val === false || val === true || val instanceof Boolean;
}

JavaScript'te bir değişkenin türünü kontrol etmenin en güvenilir yolu şudur :

var toType = function(obj) {
  return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}
toType(new Boolean(true)) // returns "boolean"
toType(true); // returns "boolean"

Bu komplikasyonun nedeni, typeof truegeri "boolean"dönerken typeof new Boolean(true)geri dönmesidir "object".

Lodash ile gitmek istiyorum: isBoolean geçirilen değişken ilkel boolean veya Boolean sarıcı nesne olup olmadığını denetler ve böylece tüm durumlar için hesaplar.

typeofBir bağımsız değişkeni kontrol eden bir işlev oluşturabilirsiniz .

function isBoolean(value) {
  return typeof value === "boolean";
}

Bazen kontrol etmek için tek bir yola ihtiyacımız var. typeof tarih vb için çalışmıyor. Böylece kolay

Date.prototype.getType() { return "date"; }

Ayrıca için Number, String, Booleanvb sık sık tek şekilde türünü kontrol gerekiyor ...

isBooleanOneliner içeren fonksiyonlar oluşturmak typeof v === "boolean"uzun vadede çok kullanışlı görünmüyor. Neredeyse herkesin kendi işlevinizi yaratmasını önermesinden şaşırıyorum. Yerli prototipleri genişletmekle aynı kanser gibi görünüyor.

• katıldığınız her projede bunları yeniden oluşturmanız gerekir
• diğer geliştiricilerin farklı alışkanlıkları olabilir, ya da kontrolün zayıf noktalarının ne olduğunu bilmek için hangi kontrol imgesini kullandığınızı görmek için işlevinizin kaynağını kontrol etmeniz gerekebilir
• projenize ait olmayan bir konsolda konsolda bir astar yazmaya çalışacağınız zaman meyve vereceksiniz

sadece not edin typeof v === "boolean"ve hepsi bu. Üç harfli bir kısayolla yerleştirmek ve mutlu olmak için IDE'nize bir şablon ekleyin.

if(['true', 'yes', '1'].includes(single_value)) {
    return  true;   
}
else if(['false', 'no', '0'].includes(single_value)) {
    return  false;  
}

eğer bir ipin varsa

• En okunabilir: val === false || val === true.
• Ayrıca okunabilir: typeof variable == typeof true.

• Hiç kısa, fakat okunabilir değil: !!val === val.

  Açıklama:

  • [!!] Çift ünlem işareti, değeri bir Boole değerine dönüştürür.
  • [===] Üçlü katı eşitlik testine eşittir : hem tür (Boolean) hem de değer aynı olmalıdır.
  • Orijinal değer bir Boole değeri değilse, üçlü eşitlik testini geçmez. Eğer bir Boolean değişkeni ise, üçlü eşitlik testini geçecektir (hem tip hem de değerle birlikte).

  Testler:

  • !! 5 === 5 // yanlış
  • !! 'test' === 'test' // yanlış
  • let val = new Date (); !! val === val // yanlış
  • !! true === true // true
  • !! false === false // true

Düğümlerde node-boolify kullanarak isBoolean ();

        var isBoolean = require('node-boolify').isBoolean;
        isBoolean(true); //true
        isBoolean('true'); //true
        isBoolean('TRUE'); //false
        isBoolean(1); //true
        isBoolean(2); //false
        isBoolean(false); //true
        isBoolean('false'); //true
        isBoolean('FALSE'); //false
        isBoolean(0); //true
        isBoolean(null); //false
        isBoolean(undefined); //false
        isBoolean(); //false
        isBoolean(''); //false

Es2015 ok işlevi ile bir karar daha

const isBoolean = val => typeof val === 'boolean';