web-dev-qa-db-fra.com

Comment vérifier si le type est booléen

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

Je veux dire, il existe des alternatives telles que:

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

Mais ça ne me semble pas joli.

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

javascriptjquerytypes
183
Matias Cicero

C'est ce que typeof est là pour. Les parenthèses sont facultatives puisqu'il s'agit d'un opérateur .

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

Si vous voulez juste vérifier une valeur primitive

typeof variable === 'boolean'

Si, pour une raison quelconque, vous avez créé des booléens avec le constructeur, ceux-ci ne sont pas vraiment des booléens, mais des objets contenant une valeur booléenne primitive. Un moyen de vérifier les booléens primitifs et les objets créés avec new Boolean consiste à effectuer:

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

29
adeneo

Avec JavaScript pur , vous pouvez simplement utiliser typeof et faire quelque chose comme typeof false ou typeof true et il retournera "boolean"...

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

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

Ou en ligne ES6 way ...

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

et appelez comme ça!

isBoolean(false); //return true

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

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

Également 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 utiliser le type boolean aussi:

let isDone: boolean = false;

Une autre façon de procéder consiste également à convertir la valeur en valeur booléenne et à voir si elle est toujours identique, quelque chose comme:

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

ou comme:

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

et appelez ça!

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.

18
Alireza

Vous pouvez utiliser du Javascript pur pour y parvenir:

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

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

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

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

  2. Effectuer une simple vérification typeof:

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

  3. Faire une instanciation excessive et inutile d'un wrapper de classe sur un primatif:

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

Le troisième ne renverra que true si vous créez une classe new Boolean et le transmettez.

Pour élaborer sur la contrainte des primitives (comme indiqué au n ° 1), tous les types de primitives peuvent être vérifiés de la manière suivante:

  • Boolean:

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

  • Number:

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

  • String:

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

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

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

Je voudrais aller avec Lodash: isBoolean vérifie si la variable transmise est un objet wrapper booléen ou booléen primitif et rend compte de tous les cas.

2
Marcus Junius Brutus

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 true renvoie "boolean" alors que typeof new Boolean(true) renvoie "object".

2
Volodymyr Frolov
  • Le plus lisible: val === false || val === true.
  • Également lisible: typeof variable == typeof true.

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

    Explication:

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

    Tests:

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

Créer des fonctions telles que isBoolean qui contient oneliner typeof v === "boolean" semble très peu pratique à 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 indigènes.

  • 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 mise en oeuvre de chèque vous utilisez, pour connaître les points faibles de votre chèque
  • vous serez frustré lorsque vous essaierez d'écrire un liner dans la console sur site qui n'appartient pas à votre projet

il suffit de mémoriser typeof v === "boolean" et c'est tout. Ajoutez un modèle à votre IDE pour pouvoir le mettre en forme avec un raccourci de trois lettres et être heureux.

0
Kamil Orzechowski

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
0
Ratan Uday Kumar

Encore une décision avec la fonction es2015 arrow

const isBoolean = val => typeof val === 'boolean';
0
Gor
if(['true', 'yes', '1'].includes(single_value)) {
    return  true;   
}
else if(['false', 'no', '0'].includes(single_value)) {
    return  false;  
}

si vous avez une ficelle

0
Denver

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

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

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

0
Imam Kuncoro

Vous pouvez créer une fonction qui vérifie la typeof pour un argument.

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