Як перевірити, чи є тип булевим

Як я можу перевірити, чи є тип змінної булевим?

Я маю на увазі, є деякі альтернативи, такі як:

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

Але це мені не здається гарним.

Чи є більш чистий спосіб досягти цього?

Ось для чого typeofце. Дужки не є обов'язковими, оскільки це оператор .

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

Якщо ви просто хочете перевірити наявність примітивного значення

typeof variable === 'boolean'

Якщо з якоїсь дивної причини у вас є булеви, створені за допомогою конструктора, це насправді не булеві, а об'єкти, що містять примітивне булеве значення, і один із способів перевірити як примітивні булеві, так і об’єкти, створені за допомогою 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

За допомогою чистого JavaScript ви можете просто використовувати typeofта робити щось на кшталт typeof falseабо, typeof trueі воно повернеться "boolean"...

Але це не єдиний спосіб зробити це, я створюю функції нижче, щоб показати різні способи перевірки Boolean в JavaScript, а також різні способи, як це можна зробити в деяких нових рамках, почнемо з цього:

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

Або однолінійний спосіб ES6 ...

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

і називайте це так!

isBoolean(false); //return true

Також у вихідному коді підкреслення вони перевіряють його так (з _. На початку назви функції):

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

Також у jQuery ви можете перевірити це так:

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

У React , якщо ви використовуєте propTypes, ви можете перевірити значення булевим таким чином:

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

Якщо ви використовуєте TypeScript , ви також можете використовувати тип boolean :

let isDone: boolean = false;

Також інший спосіб зробити це - це як перетворити значення на булеве і побачити, чи все-таки це все одно, щось на кшталт:

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

або як:

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

і зателефонуйте!

isBoolean(false); //return true

Для цього не рекомендується використовувати будь-які рамки, оскільки це справді проста перевірка JavaScript.

Існує три "ванільні" способи перевірити це за допомогою або без jQuery.

1. Спочатку потрібно змусити булеву оцінку за допомогою примусу, а потім перевірити, чи вона дорівнює початковій величині:

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

2. Проста typeofперевірка:

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

3. Здійснення повністю зайвого набору та непотрібної інстанції обгортки класу на первісному:

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

Третій повернеться лише у тому true випадку, якщо ви створите new Booleanклас та передасте його.

Для розробки примусу примітивів (як показано на №1) усі типи примітивів можна перевірити таким чином:

• Boolean:

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

• Number:

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

• String:

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

Для цього можна використовувати чистий Javascript:

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

Якщо ви хочете, щоб ваша функція також могла перевірити булі об'єкти, найефективнішим рішенням повинно бути:

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

Найнадійніший спосіб перевірити тип змінної в JavaScript є наступне :

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"

Причиною цього ускладнення є те, що typeof trueповертається, "boolean"а typeof new Boolean(true)повертається "object".

Я б пішов з Лодашем: isBoolean перевіряє, чи є передана змінна або примітивним булевим, або булевим об'єктом обгортки, і тому обліковує всі випадки.

Ви можете створити функцію, яка перевіряє typeofаргумент.

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

Іноді нам потрібен єдиний спосіб перевірити це. typeof не працює на дату і т. д. Тож я полегшив її

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

Крім того, для Number, String, і Booleanт.д. , ми часто повинні перевірити тип в одному шляху ...

Створення таких функцій, як те, isBooleanщо містить oneliner, typeof v === "boolean"здається дуже незмінним у довгостроковій перспективі. я здивований, що майже кожен пропонує створити власну функцію. Здається, це такий же рак, як і розширення нативних прототипів.

• вам потрібно відтворити їх у кожному проекті, в якому ви берете участь
• інші розробники можуть мати різні звички, або вам потрібно перевірити джерело вашої функції, щоб побачити, яке саме використання чека ви використовуєте, щоб знати, які слабкі моменти вашої перевірки
• ви будете розчаровані, коли спробуєте написати один вкладиш у консолі на сайті, який не належить до вашого проекту

просто запам'ятай typeof v === "boolean"і все. Додайте шаблон до IDE, щоб мати змогу розмістити його за допомогою якихось трьох літер.

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

якщо у вас є рядок

• Найчитабельніші: val === false || val === true .
• Також читаємо: typeof variable == typeof true.

• Найкоротший, але зовсім не читабельний: !!val === val .

  Пояснення:

  • [!!] Подвійний вигук перетворює значення в булеве.
  • [===] Тест потрійного рівняння на сувору рівність: і тип (булева), і значення повинні бути однаковими.
  • Якщо початкове значення не булеве, воно не пройде тест потрійних рівностей. Якщо це булева змінна, вона пройде тест потрійних рівностей (з обома типами та значенням).

  Тести:

  • !! 5 === 5 // false
  • !! 'test' === 'test' // false
  • нехай val = нова дата (); !! val === val // помилково
  • !! true === true // вірно
  • !! false === false // правда

У nodejs за допомогою node-boolify ми можемо використовувати 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

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