Как проверить, является ли тип логическим

Как я могу проверить, имеет ли тип переменной тип Boolean?

Я имею в виду, есть несколько альтернатив, таких как:

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"...

Но это не единственный способ сделать это, я создаю функции ниже, чтобы показать различные способы проверки логического значения в JavaScript, а также различные способы сделать это в некоторых новых средах, давайте начнем с этого:

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

Или однострочный способ ES6 ...

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

и назовите это как!

isBoolean(false); //return true

Также в исходном коде Underscore они проверяют это следующим образом (с _. В начале имени функции):

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".

Я бы пошел с Lodash: isBoolean проверяет, является ли передаваемая переменная примитивным логическим или логическим объектом-оболочкой, и поэтому учитывает все случаи.

Вы можете создать функцию, которая проверяет typeofаргумент.

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

Иногда нам нужен единственный способ проверить это. typeof не работает на дату и т. д. Так что я сделал это легко

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

Кроме того, для Number, String, и Booleanт.д. , мы часто должны проверить тип в одном пути ...

Создание таких функций, как isBooleanoneliner, 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.

  Объяснение:

  • [!!] Двойной восклицательный знак преобразует значение в логическое значение.
  • [===] Тройное равенство проверяет строгое равенство: и тип (Boolean), и значение должны быть одинаковыми.
  • Если исходное значение не является логическим, оно не пройдет тест на тройное равенство. Если это булева переменная, она пройдет тест тройного равенства (как с типом, так и со значением).

  тесты:

  • !! 5 === 5 // false
  • !! 'test' === 'test' // false
  • let val = новая дата (); !! val === val // false
  • !! верно === правда // правда
  • !! false === false // true

В 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';