Cara memeriksa apakah tipe adalah Boolean

Bagaimana saya bisa memeriksa apakah tipe variabel adalah tipe Boolean?

Maksud saya, ada beberapa alternatif seperti:

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

Tetapi bagi saya itu tidak terlihat bagus.

Apakah ada cara yang lebih bersih untuk mencapai ini?

Itulah gunanya typeof. Tanda kurung bersifat opsional karena merupakan operator .

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

Jika Anda hanya ingin memeriksa nilai primitif

typeof variable === 'boolean'

Jika karena alasan aneh Anda memiliki boolean yang dibuat dengan konstruktor, itu bukan boolean tetapi objek yang mengandung nilai boolean primitif, dan salah satu cara untuk memeriksa boolean primitif dan objek yang dibuat new Booleanadalah dengan melakukan:

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

Dengan JavaScript murni , Anda cukup menggunakan typeofdan melakukan sesuatu seperti typeof falseatau typeof truedan itu akan kembali "boolean"...

Tapi itu bukan satu-satunya cara untuk melakukan itu, saya membuat fungsi di bawah ini untuk menunjukkan berbagai cara Anda dapat memeriksa Boolean dalam JavaScript, juga berbagai cara yang dapat Anda lakukan dalam beberapa kerangka kerja baru, mari kita mulai dengan yang ini:

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

Atau satu cara ES6 ...

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

dan menyebutnya seperti!

isBoolean(false); //return true

Juga dalam kode sumber Garis Bawah mereka memeriksanya seperti ini (dengan _. Di awal nama fungsi):

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

Juga di jQuery Anda dapat memeriksanya seperti ini:

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

Di Bereaksi , jika menggunakan propTypes, Anda dapat memeriksa nilai menjadi boolean seperti ini:

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

Jika menggunakan TypeScript , Anda dapat menggunakan tipe boolean juga:

let isDone: boolean = false;

Juga cara lain untuk melakukannya, seperti mengubah nilai menjadi boolean dan melihat apakah masih sama persis, sesuatu seperti:

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

atau seperti:

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

dan sebut saja!

isBoolean(false); //return true

Tidak disarankan menggunakan kerangka apa pun untuk ini karena ini benar-benar pemeriksaan sederhana dalam JavaScript.

Ada tiga cara "vanilla" untuk memeriksanya dengan atau tanpa jQuery.

1. Pertama adalah memaksa evaluasi boolean dengan paksaan, lalu periksa apakah itu sama dengan nilai asli:

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

2. Melakukan pemeriksaan sederhana typeof:

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

3. Melakukan pemborosan kelas yang sepenuhnya berlebihan dan tidak perlu pada primatif:

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

Yang ketiga hanya akan kembali true jika Anda membuat new Booleankelas dan meneruskannya.

Untuk menguraikan paksaan primitif (seperti yang ditunjukkan dalam # 1), semua tipe primitif dapat diperiksa dengan cara ini:

• Boolean:

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

• Number:

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

• String:

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

Anda dapat menggunakan Javascript murni untuk mencapai ini:

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

Jika Anda ingin fungsi Anda dapat memvalidasi objek boolean juga, solusi yang paling efisien adalah:

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

Cara paling dapat diandalkan untuk memeriksa jenis variabel dalam JavaScript adalah sebagai berikut :

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"

Alasan untuk komplikasi ini adalah typeof truepengembalian "boolean"sementara typeof new Boolean(true)pengembalian "object".

Saya akan pergi dengan Lodash: isBoolean memeriksa apakah variabel yang lewat adalah boolean primitif atau objek wrapper Boolean dan dengan demikian menyumbang semua kasus.

Anda dapat membuat fungsi yang memeriksa typeofargumen.

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

Terkadang kita membutuhkan satu cara untuk memeriksanya. typeof tidak berfungsi untuk kencan dll. Jadi saya membuatnya mudah

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

Juga untuk Number, String, Booleandll kita sering perlu untuk memeriksa jenis dengan cara tunggal ...

Membuat fungsi seperti isBooleanyang berisi oneliner typeof v === "boolean"sepertinya sangat tidak nyaman dalam jangka panjang. Saya terkejut bahwa hampir semua orang menyarankan untuk membuat fungsi Anda sendiri. Sepertinya kanker yang sama dengan memperluas prototipe asli.

• Anda perlu membuatnya kembali di setiap proyek yang Anda terlibat
• pengembang lain mungkin memiliki kebiasaan berbeda, atau perlu memeriksa sumber fungsi Anda untuk melihat penerapan pemeriksaan yang Anda gunakan, untuk mengetahui apa saja titik lemah pemeriksaan Anda.
• Anda akan terbuai ketika Anda akan mencoba untuk menulis satu liner di konsol di situs yang bukan milik proyek Anda

hanya memoize typeof v === "boolean"dan itu saja. Tambahkan templat ke IDE Anda untuk membuatnya dengan tiga shortcut huruf dan berbahagialah.

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

jika Anda memiliki string

• Yang paling mudah dibaca: val === false || val === true .
• Juga dibaca: typeof variable == typeof true.

• Yang terpendek, tetapi tidak dapat dibaca sama sekali: !!val === val .

  Penjelasan:

  • [!!] Seruan ganda mengubah nilai menjadi Boolean.
  • [===] Tiga sama dengan tes untuk kesetaraan yang ketat: baik tipe (Boolean) dan nilainya harus sama.
  • Jika nilai asli bukan nilai Boolean, itu tidak akan lulus tes triple equals. Jika itu adalah variabel Boolean, itu akan lulus tes triple equals (dengan kedua jenis & nilai).

  Tes:

  • !! 5 === 5 // salah
  • !! 'test' === 'test' // false
  • biarkan val = Tanggal baru (); !! val === val // false
  • !! benar === benar // benar
  • !! false === false // benar

Dalam nodejs dengan menggunakan node-boolify kita bisa menggunakan 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

Satu keputusan lagi dengan fungsi panah es2015

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