Jak sprawdzić, czy typ ma wartość logiczną

Jak mogę sprawdzić, czy typ zmiennej jest typu Boolean?

Mam na myśli kilka alternatyw, takich jak:

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

Ale to nie wydaje mi się ładne.

Czy istnieje czystszy sposób na osiągnięcie tego?

Po to typeofjest. Nawiasy są opcjonalne, ponieważ jest to operator .

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

Jeśli chcesz po prostu sprawdzić pierwotną wartość

typeof variable === 'boolean'

Jeśli z jakiegoś dziwnego powodu masz booleany utworzone za pomocą konstruktora, nie są to tak naprawdę booleany, ale obiekty zawierające prymitywną wartość boolowską, a jednym ze sposobów sprawdzenia zarówno prymitywnych boolanów i obiektów utworzonych za pomocą new Booleanjest:

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

Dzięki czystemu JavaScriptowi możesz po prostu użyć typeofi zrobić coś takiego typeof falselub, typeof truea on zwróci "boolean"...

Ale to nie jedyny sposób, aby to zrobić, poniżej tworzę funkcje, aby pokazać różne sposoby sprawdzania Boolean w JavaScript, a także różne sposoby, w jakie możesz to zrobić w niektórych nowych ramach, zacznijmy od tego:

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

Lub jedno-liniowy sposób ES6 ...

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

i nazwij to tak!

isBoolean(false); //return true

Również w kodzie źródłowym podkreślenia sprawdzają to w ten sposób (z _. Na początku nazwy funkcji):

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

Również w jQuery możesz to sprawdzić w następujący sposób:

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

W React , jeśli używasz propTypes, możesz sprawdzić wartość logiczną:

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

Jeśli używasz TypeScript , możesz także użyć typu boolean :

let isDone: boolean = false;

Innym sposobem na zrobienie tego jest konwersja wartości na wartość logiczną i sprawdzenie, czy nadal jest dokładnie taka sama, na przykład:

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

lub jak:

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

i nazwij to!

isBoolean(false); //return true

Nie jest zalecane używanie do tego żadnych ram, ponieważ jest to naprawdę proste sprawdzenie w JavaScript.

Istnieją trzy „waniliowe” sposoby na sprawdzenie tego z lub bez jQuery.

1. Najpierw należy wymusić ocenę logiczną przez przymus, a następnie sprawdzić, czy jest równa pierwotnej wartości:

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

2. Przeprowadzanie prostej typeofkontroli:

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

3. Wykonanie całkowicie przesadnej i niepotrzebnej instancji opakowania klasy na prymitywie:

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

Trzeci powróci tylko true wtedy , gdy utworzysz new Booleanklasę i przekażesz ją.

Aby rozwinąć przymus prymitywów (jak pokazano w punkcie 1), wszystkie typy prymitywów można sprawdzić w ten sposób:

• Boolean:

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

• Number:

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

• String:

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

Aby to osiągnąć, możesz użyć czystego Javascript.

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

Jeśli chcesz, aby Twoja funkcja mogła również sprawdzać poprawność obiektów boolowskich, najbardziej wydajnym rozwiązaniem musi być:

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

Najbardziej wiarygodnym sposobem sprawdzenia typ zmiennej w JavaScripcie jest następujący :

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"

Powodem tej komplikacji jest to, że typeof truewraca "boolean"podczas typeof new Boolean(true)powrotu "object".

Wybrałbym Lodash: isBoolean sprawdza, czy przekazana zmienna jest pierwotnym obiektem typu boolean, czy też obiekt logiczny Boolean, a więc uwzględnia wszystkie przypadki.

Możesz utworzyć funkcję, która sprawdza typeofargument.

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

Czasami potrzebujemy jednego sposobu, aby to sprawdzić. typeof nie działa na randkę itp. Ułatwiłem więc

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

Również Number, String, Booleanitd. Często musimy sprawdzić typ w jednym drodze ...

Tworzenie funkcji takich jak isBooleanoneliner typeof v === "boolean"wydaje się w dłuższej perspektywie bardzo niewygodne. Jestem zaskoczony, że prawie wszyscy sugerują stworzenie własnej funkcji. Wydaje się, że jest to ten sam rak, co rozszerzanie natywnych prototypów.

• musisz je odtworzyć w każdym zaangażowanym projekcie
• inni programiści mogą mieć inne nawyki, lub muszą sprawdzić źródło twojej funkcji, aby zobaczyć, z jakiego impulsu czeku korzystasz, aby dowiedzieć się, jakie są słabe strony twojego czeku
• poczujesz frustrację, gdy spróbujesz napisać jedną konsolę w konsoli na stronie, która nie należy do twojego projektu

po prostu zapamiętaj typeof v === "boolean"i to wszystko. Dodaj szablon do swojego IDE, aby móc go umieścić za pomocą trzyliterowego skrótu i ​​być szczęśliwym.

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

jeśli masz ciąg

• Najbardziej czytelny: val === false || val === true.
• Również czytelny: typeof variable == typeof true.

• Najkrótsza, ale nie w ogóle czytelny: !!val === val.

  Wyjaśnienie:

  • [!!] Podwójny wykrzyknik przekształca wartość w wartość logiczną.
  • [===] Test potrójnej równości zapewnia ścisłą równość: zarówno typ (wartość logiczna), jak i wartość muszą być takie same.
  • Jeśli oryginalna wartość nie jest wartością logiczną, nie przejdzie testu potrójnej równości. Jeśli jest to zmienna boolowska, przejdzie test potrójnej równości (zarówno z typem, jak i wartością).

  Testy:

  • !! 5 === 5 // false
  • !! „test” === „test” // false
  • let val = nowa data (); !! val === val // false
  • !! true === true // true
  • !! false === false // true

W nodejs za pomocą node-boolify możemy użyć 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

Jeszcze jedna decyzja z funkcją strzałki es2015

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