Comment vérifier si le type est booléen

Comment puis-je vérifier si le type d'une variable est de type booléen?

Je veux dire, il existe des alternatives telles que:

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

Mais cela ne me semble pas joli.

Existe-t-il un moyen plus propre d'y parvenir?

C'est pour ça typeof. Les parenthèses sont facultatives car il s'agit d'un opérateur .

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

Si vous voulez simplement vérifier une valeur primitive

typeof variable === 'boolean'

Si pour une raison étrange vous avez créé des booléens avec le constructeur, ce ne sont pas vraiment des booléens mais des objets contenant une valeur booléenne primitive, et une façon de vérifier les booléens primitifs et les objets créés avec new Booleanest de faire:

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

Avec du JavaScript pur , vous pouvez simplement utiliser typeofet faire quelque chose comme typeof falseou typeof trueet cela reviendra"boolean" ...

Mais ce n'est pas la seule façon de le faire, je crée des fonctions ci-dessous pour montrer différentes façons de vérifier le booléen en JavaScript, ainsi que différentes façons de le faire dans certains nouveaux cadres, commençons par celui-ci:

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

Ou façon ES6 sur une ligne ...

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

et appelez ça comme!

isBoolean(false); //return true

Toujours dans le code source Underscore, ils le vérifient comme ceci (avec le _. Au début du nom de la fonction):

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

Aussi dans jQuery vous pouvez le vérifier comme ceci:

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

Dans React , si vous utilisez propTypes, vous pouvez vérifier qu'une valeur est booléenne comme ceci:

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

Si vous utilisez TypeScript , vous pouvez également utiliser le type booléen :

let isDone: boolean = false;

Une autre façon de le faire, c'est comme convertir la valeur en booléen et voir si c'est toujours la même chose, quelque chose comme:

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

ou comme:

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

et appelez-le!

isBoolean(false); //return true

Il n'est pas recommandé d'utiliser un framework pour cela car c'est vraiment une simple vérification en JavaScript.

Il existe trois façons "vanille" de vérifier cela avec ou sans jQuery.

1. La première consiste à forcer l'évaluation booléenne par coercition, puis à vérifier si elle est égale à la valeur d'origine:

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

2. Faire une simple typeofvérification:

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

3. Faire une instanciation complètement exagérée et inutile d'un wrapper de classe sur une primitive:

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

Le troisième ne reviendra que true si vous créez unnew Boolean classe et la transmettez.

Pour élaborer sur la coercition des primitives (comme indiqué dans # 1), tous les types de primitives peuvent être vérifiés de cette manière:

• Boolean:

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

• Number:

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

• String:

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

Vous pouvez utiliser du Javascript pur pour y parvenir:

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

Si vous voulez que votre fonction puisse également valider des objets booléens, la solution la plus efficace doit être:

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

Le moyen le plus fiable de vérifier le type d'une variable en JavaScript est le suivant :

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"

La raison de cette complication est que typeof trueretourne "boolean"tout typeof new Boolean(true)retourne "object".

J'irais avec Lodash: isBoolean vérifie si la variable transmise est un objet wrapper booléen ou booléen primitif et rend donc compte de tous les cas.

Vous pouvez créer une fonction qui vérifie la présence typeofd'un argument.

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

Parfois, nous avons besoin d'une seule façon de le vérifier. typeof ne fonctionne pas pour la date, etc.

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

Aussi pour Number, String, Booleanetc. nous avons souvent besoin de vérifier le type d'une manière unique ...

La création de fonctions comme celle isBooleanqui contient un typeof v === "boolean"oneliner semble très difficile à long terme. je suis surpris que presque tout le monde suggère de créer votre propre fonction. Il semble que ce soit le même cancer que l'extension de prototypes natifs.

• vous devez les recréer dans chaque projet auquel vous participez
• d'autres développeurs peuvent avoir des habitudes différentes, ou avoir besoin de vérifier la source de votre fonction pour voir quelle implémentation de vérification vous utilisez, pour savoir quels sont les points faibles de votre vérification
• vous serez frustré lorsque vous essaierez d'écrire un liner dans la console sur site qui n'appartient pas à votre projet

juste mémoriser typeof v === "boolean"et c'est tout. Ajoutez un modèle à votre IDE pour pouvoir le mettre par un raccourci de trois lettres et soyez heureux.

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

si vous avez une chaîne

• Le plus lisible: val === false || val === true.
• Aussi facile à lire: typeof variable == typeof true.

• Le plus court, mais pas lisible du tout: !!val === val.

  Explication:

  • [!!] La double exclamation convertit la valeur en booléen.
  • [===] Le triple est égal à un test d'égalité stricte: le type (booléen) et la valeur doivent être identiques.
  • Si la valeur d'origine n'est pas booléenne, elle ne passera pas le test du triple égal. S'il s'agit d'une variable booléenne, elle passera le test du triple égal (avec le type et la valeur).

  Tests:

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

Dans nodejs en utilisant node-boolify, nous pouvons utiliser 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

Une décision de plus avec la fonction flèche es2015

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