유형이 부울인지 확인하는 방법

유형이 부울인지 확인하는 방법

---

변수 유형이 부울 유형인지 어떻게 확인합니까?

내 말은, 다음과 같은 대안이 있습니다.

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

---

로 순수 자바 스크립트 , 그냥 간단하게 사용할 수 있습니다 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"

에 반작용 , propTypes를 사용하는 경우, 당신은이 같은 부울로 값을 확인할 수 있습니다 :

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

사용하는 경우 타이프 라이터를 , 당신은 입력 사용할 수있는 부울 도 :

let isDone: boolean = false;

Also another way to do it, is like converting the value to boolean and see if it's exactly the same still, something like:

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

or like:

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

and call it!

isBoolean(false); //return true

It's not recommended using any framework for this as it's really a simple check in JavaScript.

---

You can use pure Javascript to achieve this:

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

---

There are three "vanilla" ways to check this with or without jQuery.

1. First is to force boolean evaluation by coercion, then check if it's equal to the original value:

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

2. Doing a simple typeof check:

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

3. Doing a completely overkill and unnecessary instantiation of a class wrapper on a primative:

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

The third will only return true if you create a new Boolean class and pass that in.

To elaborate on primitives coercion (as shown in #1), all primitives types can be checked in this way:

• Boolean:

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

• Number:

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

• String:

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

---

If you want your function can validate boolean objects too, the most efficient solution must be:

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

---

The most reliable way to check type of a variable in JavaScript is the following:

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"

The reason for this complication is that typeof true returns "boolean" while typeof new Boolean(true) returns "object".

---

I would go with Lodash: isBoolean checks whether the passed-in variable is either primitive boolean or Boolean wrapper object and so accounts for all cases.

---

You can create a function that checks the typeof for an argument.

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

---

Sometimes we need a single way to check it. typeof not working for date etc. So I made it easy by

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

Also for Number, String, Boolean etc. we often need to check the type in a single way...

---

Creating functions like isBoolean which contains oneliner typeof v === "boolean" seems very unhandy in long term. i am suprised that almost everyone suggest to create your own function. It seems to be same cancer as extending native prototypes.

• you need to recreate them in every project you are involved
• other developers might have different habits,, or need to check source of your function to see which impementation of check you use, to know what are weak points of your check
• you will be fruustrated when you will try to write one liner in console on site which doesn't belong to your project

just memoize typeof v === "boolean" and that's all. Add a template to your IDE to be able to put it by some three letter shortcut and be happy.

---

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

if you have a string

---

• The most readable: val === false || val === true.
• Also readable: typeof variable == typeof true.

• The shortest, but not readable at all: !!val === val.

  Explanation:

  • [!!] The double exclamation mark converts the value into a Boolean.
  • [===] The triple equals test for strict equality: both the type (Boolean) and the value have to be the same.
  • If the original value is not a Boolean one, it won't pass the triple equals test. If it is a Boolean variable, it will pass the triple equals test (with both type & value).

  Tests:

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

---

In nodejs by using node-boolify we can use 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

---

One more decision with es2015 arrow function

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

참고URL : https://stackoverflow.com/questions/28814585/how-to-check-if-type-is-boolean