Cách kiểm tra nếu loại là Boolean

Làm cách nào để kiểm tra xem loại của biến có thuộc loại Boolean không?

Ý tôi là, có một số lựa chọn thay thế như:

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

Nhưng điều đó dường như không đẹp với tôi.

Có cách nào sạch hơn để đạt được điều này?

Đó là những gì typeofđang có. Các dấu ngoặc là tùy chọn vì nó là một toán tử .

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

Nếu bạn chỉ muốn kiểm tra giá trị nguyên thủy

typeof variable === 'boolean'

Nếu vì một lý do kỳ lạ nào đó mà bạn có booleans được tạo bằng hàm tạo, thì những đối tượng đó không thực sự là booleans mà là các đối tượng chứa giá trị boolean nguyên thủy và một cách để kiểm tra cả booleans nguyên thủy và đối tượng được tạo new Booleanlà:

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

Với JavaScript thuần túy , bạn chỉ cần sử dụng typeofvà làm một cái gì đó giống như typeof falsehoặc typeof truenó sẽ trả về "boolean"...

Nhưng đó không phải là cách duy nhất để làm điều đó, tôi đang tạo các hàm bên dưới để hiển thị các cách khác nhau mà bạn có thể kiểm tra Boolean trong JavaScript, cũng là các cách khác nhau bạn có thể thực hiện trong một số khung mới, hãy bắt đầu với cách này:

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

Hoặc cách ES6 một dòng ...

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

và gọi nó như thế nào!

isBoolean(false); //return true

Ngoài ra, trong mã nguồn Underscore, họ kiểm tra nó như thế này (với _. Ở đầu tên hàm):

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

Ngoài ra trong jQuery bạn có thể kiểm tra nó như thế này:

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

Trong React , nếu sử dụng propTypes, bạn có thể kiểm tra một giá trị để được boolean như thế này:

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

Nếu sử dụng TypeScript , bạn cũng có thể sử dụng kiểu boolean :

let isDone: boolean = false;

Ngoài ra, một cách khác để làm điều đó, cũng giống như chuyển đổi giá trị thành boolean và xem liệu nó có hoàn toàn giống như vậy không, đại loại như:

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

hoặc thích:

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

và gọi nó!

isBoolean(false); //return true

Không nên sử dụng bất kỳ khuôn khổ nào cho việc này vì đây thực sự là một kiểm tra đơn giản trong JavaScript.

Có ba cách "vanilla" để kiểm tra điều này có hoặc không có jQuery.

1. Đầu tiên là buộc đánh giá boolean bằng cách ép buộc, sau đó kiểm tra xem nó có bằng giá trị ban đầu không:

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

2. Làm một typeofkiểm tra đơn giản :

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

3. Thực hiện quá mức cần thiết và khởi tạo không cần thiết của trình bao bọc lớp trên một nguyên hàm:

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

Thứ ba sẽ chỉ trở lại true nếu bạn tạo một new Booleanlớp và vượt qua nó trong.

Để giải thích về sự ép buộc nguyên thủy (như thể hiện trong mục 1), tất cả các loại nguyên thủy có thể được kiểm tra theo cách này:

• Boolean:

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

• Number:

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

• String:

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

Bạn có thể sử dụng Javascript thuần túy để đạt được điều này:

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

Nếu bạn muốn chức năng của mình có thể xác nhận các đối tượng boolean, giải pháp hiệu quả nhất phải là:

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

Cách đáng tin cậy nhất để kiểm tra loại biến trong JavaScript là như sau :

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"

Lý do cho sự phức tạp này là typeof truetrả về "boolean"trong khi typeof new Boolean(true)trả lại "object".

Tôi sẽ đi với Lodash: isBoolean kiểm tra xem biến được truyền vào là đối tượng trình bao bọc boolean nguyên thủy hay Boolean và do đó chiếm tất cả các trường hợp.

Bạn có thể tạo một hàm kiểm tra typeofđối số.

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

Đôi khi chúng ta cần một cách duy nhất để kiểm tra nó. typeof không hoạt động cho ngày, vv Vì vậy, tôi đã làm cho nó dễ dàng bằng

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

Cũng cho Number, String, Booleanvv chúng tôi thường cần phải kiểm tra loại một cách duy nhất ...

Tạo các chức năng như isBooleanchứa oneliner typeof v === "boolean"có vẻ rất không ổn trong thời gian dài. tôi ngạc nhiên rằng hầu hết mọi người đề nghị tạo ra chức năng của riêng bạn. Nó dường như là ung thư giống như mở rộng các nguyên mẫu bản địa.

• bạn cần tạo lại chúng trong mọi dự án bạn tham gia
• các nhà phát triển khác có thể có các thói quen khác nhau ,, hoặc cần kiểm tra nguồn của chức năng của bạn để xem bạn sử dụng loại séc nào để biết điểm yếu của séc của bạn là gì
• bạn sẽ thất vọng khi bạn cố gắng viết một lớp trong bảng điều khiển trên trang web không thuộc về dự án của bạn

chỉ cần ghi nhớ typeof v === "boolean"và đó là tất cả. Thêm một mẫu vào IDE của bạn để có thể đặt nó bằng một số phím tắt ba chữ cái và hài lòng.

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

nếu bạn có một chuỗi

• Dễ đọc nhất : val === false || val === true.
• Cũng có thể đọc được : typeof variable == typeof true.

• Ngắn nhất, nhưng không thể đọc được chút nào : !!val === val.

  Giải trình:

  • [!!] Dấu chấm than kép chuyển đổi giá trị thành Boolean.
  • [===] Phép thử ba bằng cho kiểm tra đẳng thức nghiêm ngặt: cả loại (Boolean) và giá trị phải giống nhau.
  • Nếu giá trị ban đầu không phải là giá trị Boolean, nó sẽ không vượt qua bài kiểm tra ba bằng. Nếu đó là biến Boolean, nó sẽ vượt qua bài kiểm tra ba bằng (với cả loại & giá trị).

  Các xét nghiệm:

  • !! 5 === 5 // sai
  • !! 'kiểm tra' === 'kiểm tra' // sai
  • Đặt val = Ngày mới (); !! val === val // sai
  • !! đúng === đúng // đúng
  • !! sai === sai // đúng

Trong nodejs bằng cách sử dụng nút-boolify, chúng ta có thể sử dụng 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

Thêm một quyết định với chức năng mũi tên es2015

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