วิธีตรวจสอบว่าเป็นประเภทบูลีนหรือไม่

ฉันจะตรวจสอบว่าประเภทของตัวแปรเป็นประเภทบูลีนได้อย่างไร

ฉันหมายถึงมีทางเลือกบางอย่างเช่น:

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

แต่นั่นไม่ได้ดูสวยสำหรับฉัน

มีวิธีที่สะอาดกว่าเพื่อให้บรรลุสิ่งนี้หรือไม่?

นั่นคือสิ่งที่typeofมีอยู่ วงเล็บเป็นตัวเลือกเพราะมันเป็นผู้ประกอบการ

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

ถ้าคุณแค่ต้องการตรวจสอบค่าดั้งเดิม

typeof variable === 'boolean'

ถ้าด้วยเหตุผลแปลก ๆ บางอย่างที่คุณมีบูลีนที่สร้างขึ้นด้วยคอนสตรัคเตอร์พวกนั้นไม่ใช่บูลีนจริงๆ แต่เป็นวัตถุที่มีค่าบูลีนดั้งเดิมและวิธีหนึ่งในการตรวจสอบทั้งบูลีนดั้งเดิมและวัตถุที่สร้างขึ้นด้วยnew Boolean:

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

ด้วยJavaScript ที่บริสุทธิ์คุณสามารถใช้typeofและทำสิ่งที่ชอบtypeof falseหรือtypeof trueมันจะส่งคืน"boolean"...

แต่นั่นไม่ใช่วิธีเดียวที่จะทำอย่างนั้นฉันกำลังสร้างฟังก์ชั่นด้านล่างเพื่อแสดงวิธีการต่าง ๆ ที่คุณสามารถตรวจสอบบูลีนใน JavaScript และวิธีที่คุณสามารถทำได้ในเฟรมเวิร์กใหม่เริ่มด้วย:

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

หรือทางเดียวที่ES6 ...

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

และเรียกว่าชอบ!

isBoolean(false); //return true

นอกจากนี้ในUnderscoreซอร์สโค้ดพวกเขาตรวจสอบเช่นนี้ (ด้วย _. ที่จุดเริ่มต้นของชื่อฟังก์ชัน):

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

นอกจากนี้ในjQueryคุณสามารถตรวจสอบได้ดังนี้:

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

ในReactหากใช้ propTypes คุณสามารถตรวจสอบค่าที่เป็นบูลีนดังนี้

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

หากใช้TypeScriptคุณสามารถใช้บูลีนประเภท:

let isDone: boolean = false;

อีกวิธีหนึ่งในการทำเช่นการแปลงค่าเป็นบูลีนและดูว่ามันยังคงเหมือนเดิมหรือไม่:

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

หรือชอบ:

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

และเรียกมันว่า!

isBoolean(false); //return true

ไม่แนะนำให้ใช้เฟรมเวิร์กใด ๆ กับสิ่งนี้เนื่องจากเป็นการตรวจสอบที่ง่ายใน JavaScript

มีวิธี "วานิลลา" สามวิธีในการตรวจสอบว่ามีหรือไม่มี jQuery

1. สิ่งแรกคือบังคับให้ประเมินค่าบูลีนโดยการข่มขู่จากนั้นตรวจสอบว่าเท่ากับค่าเดิมหรือไม่:

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

2. ทำการtypeofตรวจสอบง่าย ๆ:

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

3. ทำการ overkill อย่างสมบูรณ์และไม่จำเป็นของการห่อหุ้มคลาสในแบบดั้งเดิม:

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

ที่สามจะกลับมาtrue ถ้าคุณสร้างnew Booleanชั้นเรียนและส่งผ่านสิ่งนั้น

หากต้องการอธิบายรายละเอียดเกี่ยวกับการข่มขู่พื้นฐาน (ดังที่แสดงใน # 1) คุณสามารถตรวจสอบประเภทพื้นฐานทั้งหมดได้ด้วยวิธีนี้:

• Boolean:

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

• Number:

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

• String:

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

คุณสามารถใช้จาวาสคริปต์ที่แท้จริงเพื่อให้บรรลุสิ่งนี้:

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

หากคุณต้องการให้ฟังก์ชันของคุณสามารถตรวจสอบความถูกต้องของวัตถุบูลีนได้โซลูชั่นที่มีประสิทธิภาพที่สุดจะต้อง:

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

วิธีที่เชื่อถือได้มากที่สุดในการตรวจสอบชนิดของตัวแปรใน JavaScript เป็นดังต่อไปนี้ :

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"

เหตุผลสำหรับภาวะแทรกซ้อนนี้ก็คือtypeof trueผลตอบแทน"boolean"ในขณะที่ผลตอบแทนtypeof new Boolean(true)"object"

ฉันจะไปกับ Lodash: isBooleanตรวจสอบว่าตัวแปรpass -in เป็นวัตถุบูลีนดั้งเดิมหรือวัตถุห่อหุ้มบูลีนและบัญชีสำหรับทุกกรณี

คุณสามารถสร้างฟังก์ชั่นที่ตรวจสอบtypeofการโต้แย้ง

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

บางครั้งเราต้องการวิธีเดียวในการตรวจสอบ พิมพ์ไม่ได้ไปเดทเป็นต้นฉันเลยทำให้มันง่ายด้วย

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

นอกจากนี้สำหรับNumber, String, Booleanฯลฯ เรามักจะต้องตรวจสอบประเภทในทางเดียว ...

การสร้างฟังก์ชั่นisBooleanที่มี oneliner typeof v === "boolean"ดูเหมือนจะไม่ค่อยสะดวกในระยะยาว ฉันประหลาดใจที่เกือบทุกคนแนะนำให้สร้างฟังก์ชั่นของคุณเอง ดูเหมือนว่าจะเป็นมะเร็งชนิดเดียวกันกับการขยายต้นแบบพื้นเมือง

• คุณต้องสร้างมันขึ้นมาใหม่ในทุกโครงการที่คุณมีส่วนร่วม
• ผู้พัฒนารายอื่นอาจมีนิสัยที่แตกต่างกันหรือต้องการตรวจสอบแหล่งที่มาของฟังก์ชั่นของคุณเพื่อดูว่าคุณใช้เช็คแบบใดในการรู้ว่าจุดอ่อนของเช็คของคุณคืออะไร
• คุณจะรู้สึกหงุดหงิดเมื่อคุณพยายามเขียนหนึ่งซับในคอนโซลบนไซต์ซึ่งไม่ได้เป็นของโครงการของคุณ

เพียงแค่บันทึกtypeof v === "boolean"และนั่นคือทั้งหมด เพิ่มเทมเพลตลงใน IDE ของคุณเพื่อให้สามารถวางโดยทางลัดตัวอักษรสามตัวและมีความสุข

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

หากคุณมีสตริง

• อ่านได้มากที่สุด: val === false || val === true.
• typeof variable == typeof trueนอกจากนี้ยังสามารถอ่านได้:

• สั้นที่สุด แต่ไม่สามารถอ่านได้ทั้งหมด: !!val === val.

  คำอธิบาย:

  • [!!] เครื่องหมายอัศเจรีย์คู่แปลงค่าเป็นบูลีน
  • [===] การทดสอบสามเท่าสำหรับความเท่าเทียมที่เข้มงวด: ทั้งประเภท (บูลีน) และค่าจะต้องเหมือนกัน
  • หากค่าดั้งเดิมไม่ใช่ค่าบูลีนค่าจะไม่ผ่านการทดสอบเท่ากับสาม หากเป็นตัวแปรบูลีนมันจะผ่านการทดสอบสามเท่า (ทั้งประเภทและค่า)

  แบบทดสอบ:

  • !! 5 === 5 // false
  • !! 'test' === 'test' // false
  • ให้ val = new Date (); !! val === val // false
  • !! true === จริง // จริง
  • !! false === false // true

ใน nodejs โดยใช้node-boolifyเราสามารถใช้ 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

อีกหนึ่งการตัดสินใจด้วยฟังก์ชั่นลูกศร es2015

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