javascript - Hur man kontrollerar om typen är Boolean

Hur kan jag kontrollera om en variabels typ är av typen Boolean?

Jag menar, det finns några alternativ såsom:

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

Men det verkar inte vackert för mig.

Finns det ett renare sätt att uppnå detta?

Svar #1

Det är det typeof är till för. Parenteser är valfria eftersom det är en operator.

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

Svar #2

Med ren JavaScript kan du helt enkelt använda typeof och göra något som typeof false eller typeof true och det kommer att returnera "boolean"...

Men vänta, det är inte det enda sättet att göra det på, jag skapar funktioner nedan för att visa olika sätt du kan kontrollera Boolean i JavaScript, samt olika sätt du kan göra det på i några nya ramverk, vi börjar med denna:

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

Eller en-rad ES6-sätt ...

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

och kalla det så!

isBoolean(false); //return true

Även i Underscore-källkoden kontrollerar de det så här (med _. i början av funktionsnamnet):

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

Även i jQuery kan du kontrollera det så här:

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

I React, om du använder propTypes, kan du kontrollera att ett värde är boolean på detta sätt:

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

Om du använder TypeScript kan du också använda typen boolean:

let isDone: boolean = false;

Ett annat sätt att göra det på är också att konvertera värdet till boolean och se om det fortfarande är exakt samma, något i stil med:

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

eller som:

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

och kalla det!

isBoolean(false); //return true

Det rekommenderas inte att använda något ramverk för detta eftersom det egentligen bara är en enkel kontroll i JavaScript.

Svar #3

Om du bara vill kontrollera ett primitivt värde:

typeof variable === 'boolean'

Om du av någon konstig anledning har Booleans skapade med konstruktorn, är de egentligen inte Booleans utan objekt som innehåller ett primitivt Boolean-värde, och ett sätt att kontrollera både primitiva Booleans och objekt skapade med new Boolean är att göra:

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

Svar #4

Det finns tre "vanliga" sätt att kontrollera detta med eller utan jQuery.

  1. Först är att tvinga boolean-utvärdering genom tvång, sedan kontrollera om det är lika med det ursprungliga värdet:

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

  2. Gör en enkel typeof-kontroll:

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

  3. Att göra en helt överdriven och onödig instansiering av en klasswrapper på en primitiv:

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

Den tredje kommer endast att returnera true om du skapar en ny Boolean-klass och skickar in den.

För att utveckla om primitiv typkonvertering (som visas i #1), kan alla primitiva typer kontrolleras på detta sätt:

  • Boolean:

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

  • Nummer:

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

  • Sträng:

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

Svar #5

Du kan använda ren JavaScript för att uppnå detta:

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

Svar #6

Om du vill att din funktion också kan validera boolean-objekt, måste den mest effektiva lösningen vara:

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

Relaterade artiklar