So überprüfen Sie, ob der Typ Boolean ist

Wie kann ich überprüfen, ob der Typ einer Variablen vom Typ Boolean ist?

Ich meine, es gibt einige Alternativen wie:

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

Aber das scheint mir nicht schön zu sein.

Gibt es einen saubereren Weg, um dies zu erreichen?

Dafür gibt typeofes da. Die Klammern sind optional, da es sich um einen Operator handelt .

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

Wenn Sie nur nach einem primitiven Wert suchen möchten

typeof variable === 'boolean'

Wenn Sie aus irgendeinem seltsamen Grund Boolesche Werte mit dem Konstruktor erstellt haben, handelt es sich nicht wirklich um Boolesche Werte, sondern um Objekte, die einen primitiven Booleschen Wert enthalten. Eine Möglichkeit, nach primitiven Booleschen Werten und Objekten zu suchen, die mit erstellt wurden, new Booleanbesteht darin, Folgendes zu tun:

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

Mit reinem JavaScript können Sie einfach typeofetwas wie typeof falseoder verwenden typeof trueund es wird zurückkehren "boolean"...

Aber das ist nicht die einzige Möglichkeit, dies zu tun. Ich erstelle Funktionen unten, um verschiedene Möglichkeiten aufzuzeigen, wie Sie in JavaScript nach Booleschen Werten suchen können, und auch verschiedene Möglichkeiten, wie Sie dies in einigen neuen Frameworks tun können. Beginnen wir mit dieser:

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

Oder einzeiliger ES6- Weg ...

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

und nenne es wie!

isBoolean(false); //return true

Auch im Unterstrich- Quellcode überprüfen sie dies folgendermaßen (mit dem _ am Anfang des Funktionsnamens):

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

Auch in jQuery können Sie dies folgendermaßen überprüfen:

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

Wenn Sie in React propTypes verwenden, können Sie überprüfen, ob ein Wert wie folgt boolesch ist:

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

Wenn Sie TypeScript verwenden , können Sie auch den Typ Boolean verwenden :

let isDone: boolean = false;

Eine andere Möglichkeit besteht darin, den Wert in einen Booleschen Wert umzuwandeln und zu prüfen, ob er immer noch genau derselbe ist.

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

oder wie:

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

und nenn es!

isBoolean(false); //return true

Es wird nicht empfohlen, dafür ein Framework zu verwenden, da es sich wirklich um eine einfache Überprüfung in JavaScript handelt.

Es gibt drei "Vanille" -Möglichkeiten, um dies mit oder ohne jQuery zu überprüfen.

1. Zuerst müssen Sie die boolesche Auswertung durch Zwang erzwingen und dann prüfen, ob sie dem ursprünglichen Wert entspricht:

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

2. Eine einfache typeofÜberprüfung durchführen:

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

3. Einen völlig übertriebenen und unnötigen Instanziierung eines Klassen-Wrappers auf einem Primativ durchführen:

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

Der dritte wird nur zurückgegeben, true wenn Sie eine new BooleanKlasse erstellen und diese übergeben.

Um den Zwang der Primitiven (wie in Nr. 1 gezeigt) zu erläutern, können alle Primitivtypen auf folgende Weise überprüft werden:

• Boolean::

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

• Number::

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

• String::

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

Sie können reines Javascript verwenden, um dies zu erreichen:

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

Wenn Sie möchten, dass Ihre Funktion auch boolesche Objekte validieren kann, muss die effizienteste Lösung sein:

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

Der zuverlässigste Weg, um den Typ einer Variablen in JavaScript zu überprüfen, ist der folgende :

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"

Der Grund für diese Komplikation ist , dass typeof trueErträge , "boolean"während typeof new Boolean(true)Renditen "object".

Ich würde mich für Lodash entscheiden: isBoolean prüft, ob die übergebene Variable entweder ein primitives boolesches oder ein boolesches Wrapper-Objekt ist, und berücksichtigt daher alle Fälle.

Sie können eine Funktion erstellen, die das typeofauf ein Argument überprüft .

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

Manchmal brauchen wir einen einzigen Weg, um das zu überprüfen. Art funktioniert nicht für Datum usw. Also machte ich es einfach durch

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

Auch für Number, String, Booleanusw. wir oft müssen die Art in einer einzigen Art und Weise überprüfen ...

Das Erstellen von Funktionen, isBooleandie Oneliner enthalten, typeof v === "boolean"scheint auf lange Sicht sehr unhandlich zu sein. Ich bin überrascht, dass fast jeder vorschlägt, eine eigene Funktion zu erstellen. Es scheint der gleiche Krebs zu sein wie die Erweiterung nativer Prototypen.

• Sie müssen sie in jedem Projekt, an dem Sie beteiligt sind, neu erstellen
• Andere Entwickler haben möglicherweise andere Gewohnheiten oder müssen die Quelle Ihrer Funktion überprüfen, um festzustellen, welche Implementierung der Überprüfung Sie verwenden, um zu wissen, was Schwachstellen Ihrer Prüfung sind
• Sie werden begeistert sein, wenn Sie versuchen, einen Liner in der Konsole vor Ort zu schreiben, der nicht zu Ihrem Projekt gehört

nur auswendig lernen typeof v === "boolean"und das ist alles. Fügen Sie Ihrer IDE eine Vorlage hinzu, um sie mit einer Verknüpfung aus drei Buchstaben zu versehen und glücklich zu sein.

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

wenn Sie eine Zeichenfolge haben

• Am lesbarsten : val === false || val === true.
• Auch lesbar : typeof variable == typeof true.

• Das kürzeste, aber überhaupt nicht lesbare : !!val === val.

  Erläuterung:

  • [!!] Das doppelte Ausrufezeichen konvertiert den Wert in einen Booleschen Wert.
  • [===] Der Triple-Equals- Test für strikte Gleichheit: Sowohl der Typ (Boolean) als auch der Wert müssen gleich sein.
  • Wenn der ursprüngliche Wert kein Boolescher Wert ist, besteht er den Triple-Equals-Test nicht. Wenn es sich um eine boolesche Variable handelt, besteht sie den Triple-Equals-Test (mit Typ und Wert).

  Tests:

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

In nodejs können wir mit node-boolify isBoolean () verwenden;

        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

Noch eine Entscheidung mit der Pfeilfunktion es2015

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