부울 값 (예 : 'true', 'false')을 나타내는 문자열을 JavaScript에서 내장 유형으로 변환 할 수 있습니까?

목록에서 사용자의 선택에 따라 업데이트되는 HTML의 숨겨진 양식이 있습니다. 이 형식에는 부울 값을 나타내는 일부 필드가 포함되며 고유 부울 값으로 동적으로 채워집니다. 그러나이 값이 숨겨진 입력 필드에 배치되면 문자열이됩니다.

필드의 부울 값을 결정하는 유일한 방법은 일단 문자열로 변환되면 문자열 표현의 리터럴 값에 의존하는 것입니다.

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';

이것을 달성하는 더 좋은 방법이 있습니까?

하다:

var isTrueSet = (myValue == 'true');

항등 연산자 ( ===) 대신 비교 변수의 유형이 다른 경우 암시 적 유형 변환을 수행하지 않는 항등 연산자 ( ) 를 사용하여 더 엄격하게 만들 수 있습니다 ==.

var isTrueSet = (myValue === 'true');

하지 마십시오 :

당신은 아마한다 이러한 두 가지 방법 사용에 대한주의 사용자의 특정 요구를 들어 :

var myBool = Boolean("false");  // == true

var myBool = !!"false";  // == true

빈 문자열이 아닌 문자열은이 true를 사용하여 평가됩니다 . 부울 변환과 관련하여 내가 생각할 수있는 가장 깨끗한 방법이지만, 당신이 찾고있는 것이 아니라고 생각합니다.

경고

이 고도로 공명 된 레거시 답변은 기술적으로 정확하지만 문자열 값이 EXACTLY "true"또는 인 경우 매우 구체적인 시나리오에만 적용됩니다 "false".

유효하지 않은 json 문자열이 아래 함수에 전달 되면 예외가 발생 합니다.

원래 답변 :

어때요?

JSON.parse("True".toLowerCase());

또는 jQuery와 함께

$.parseJSON("TRUE".toLowerCase());

stringToBoolean: function(string){
    switch(string.toLowerCase().trim()){
        case "true": case "yes": case "1": return true;
        case "false": case "no": case "0": case null: return false;
        default: return Boolean(string);
    }
}

나는 이것이 매우 보편적이라고 생각합니다.

if (String(a) == "true") ...

간다 :

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false

대소 문자를 일치시켜야합니다.

var isTrueSet = (myValue.toLowerCase() === 'true');

또한 양식 요소 확인란 인 경우 확인란이 선택되어 있는지 확인할 수도 있습니다.

var isTrueSet = document.myForm.IS_TRUE.checked;

체크되어 있다고 가정하면, "set"은 true와 같습니다. 이것은 참 / 거짓으로 평가됩니다.

정규식을 사용할 수 있습니다.

/*
 * Converts a string to a bool.
 *
 * This conversion will:
 *
 *  - match 'true', 'on', or '1' as true.
 *  - ignore all white-space padding
 *  - ignore capitalization (case).
 *
 * '  tRue  ','ON', and '1   ' will all evaluate as true.
 *
 */
function strToBool(s)
{
    // will match one and only one of the string 'true','1', or 'on' rerardless
    // of capitalization and regardless off surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

String 클래스를 확장하고 싶다면 다음을 수행하십시오.

String.prototype.bool = function() {
    return strToBool(this);
};

alert("true".bool());

이것을 얻기 위해 String 객체를 확장하고 싶지만 열거 가능성에 대해 걱정하고 String 객체를 확장하는 다른 코드와 충돌하는 것을 걱정하는 사람들 (주석 참조)의 경우 :

Object.defineProperty(String.prototype, "com_example_bool", {
    get : function() {
        return (/^(true|1)$/i).test(this);
    }
});
alert("true".com_example_bool);

(오래된 브라우저에서는 작동하지 않으며 Opera, Chrome, Safari 및 IE는 true 인 반면 Firefox는 false를 표시합니다. 버그 720760 )

우드 아이는 조심해야합니다. 500 개 이상의 공감 율로 최고 답변을 적용한 후 결과를 본 후 실제로 유용한 내용을 게시 할 의무가 있습니다.

가장 짧지 만 매우 엄격한 방법으로 시작하겠습니다.

var str = "true";
var mybool = JSON.parse(str);

그리고 더 적절하고 관용적 인 방법으로 끝내십시오.

var parseBool = function(str) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)

    if(str == null)
        return false;

    if (typeof str === 'boolean')
    {
        return (str === true);
    } 

    if(typeof str === 'string')
    {
        if(str == "")
            return false;

        str = str.replace(/^\s+|\s+$/g, '');
        if(str.toLowerCase() == 'true' || str.toLowerCase() == 'yes')
            return true;

        str = str.replace(/,/g, '.');
        str = str.replace(/^\s*\-\s*/g, '-');
    }

    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);

    return false;
}

테스트 :

var array_1 = new Array(true, 1, "1",-1, "-1", " - 1", "true", "TrUe", "  true  ", "  TrUe", 1/0, "1.5", "1,5", 1.5, 5, -3, -0.1, 0.1, " - 0.1", Infinity, "Infinity", -Infinity, "-Infinity"," - Infinity", " yEs");

var array_2 = new Array(null, "", false, "false", "   false   ", " f alse", "FaLsE", 0, "00", "1/0", 0.0, "0.0", "0,0", "100a", "1 00", " 0 ", 0.0, "0.0", -0.0, "-0.0", " -1a ", "abc");


for(var i =0; i < array_1.length;++i){ console.log("array_1["+i+"] ("+array_1[i]+"): " + parseBool(array_1[i]));}

for(var i =0; i < array_2.length;++i){ console.log("array_2["+i+"] ("+array_2[i]+"): " + parseBool(array_2[i]));}

for(var i =0; i < array_1.length;++i){ console.log(parseBool(array_1[i]));}
for(var i =0; i < array_2.length;++i){ console.log(parseBool(array_2[i]));}

@Steven의 대답이 가장 좋은 것이라고 생각하고 들어오는 값이 문자열 인 경우보다 훨씬 더 많은 경우를 처리했습니다. 나는 그것을 조금 확장하고 다음을 제공하고 싶었다.

function isTrue(value){
    if (typeof(value) === 'string'){
        value = value.trim().toLowerCase();
    }
    switch(value){
        case true:
        case "true":
        case 1:
        case "1":
        case "on":
        case "yes":
            return true;
        default: 
            return false;
    }
}

설명해야 할 모든 false사례를 이미 알고 있는 경우 모든 사례 를 다룰 필요는 없습니다 true. 이 메소드에 true값을 전달할 수있는 모든 것을 전달할 수 있으며 (또는 다른 것을 추가하면 매우 간단합니다), 다른 모든 것이 고려됩니다.false

JSON 구문 분석을 사용한 범용 솔루션 :

function getBool(val) {
    return !!JSON.parse(String(val).toLowerCase());
}

getBool("1"); //true
getBool("0"); //false
getBool("true"); //true
getBool("false"); //false
getBool("TRUE"); //true
getBool("FALSE"); //false

업데이트 (JSON 제외) :

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

나는 또한 그것을 테스트하기 위해 바이올린을 만들었습니다 http://jsfiddle.net/remunda/2GRhG/

당신의 해결책은 괜찮습니다.

===이 경우 필드 value는 항상 이므로 사용하는 것은 어리석은 일입니다 String.

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

이 반환 false모든 falsy 값과 true를 제외한 모든 truthy 값 'false', 'f', 'no', 'n', 및 '0'(대소 문자 구분).

// False
Boolean.parse(false);
Boolean.parse('false');
Boolean.parse('False');
Boolean.parse('FALSE');
Boolean.parse('f');
Boolean.parse('F');
Boolean.parse('no');
Boolean.parse('No');
Boolean.parse('NO');
Boolean.parse('n');
Boolean.parse('N');
Boolean.parse('0');
Boolean.parse('');
Boolean.parse(0);
Boolean.parse(null);
Boolean.parse(undefined);
Boolean.parse(NaN);
Boolean.parse();

//True
Boolean.parse(true);
Boolean.parse('true');
Boolean.parse('True');
Boolean.parse('t');
Boolean.parse('yes');
Boolean.parse('YES');
Boolean.parse('y');
Boolean.parse('1');
Boolean.parse('foo');
Boolean.parse({});
Boolean.parse(1);
Boolean.parse(-1);
Boolean.parse(new Date());

부울 객체에는 'parse'메소드가 없습니다. Boolean('false')true를 반환하므로 작동하지 않습니다. !!'false'또한 반환true 하므로 작동하지 않습니다.

문자열 'true'이 부울을 반환 true하고 문자열 'false'이 부울을 반환 false하도록하려면 가장 간단한 해결책을 사용하는 것 eval()입니다. eval('true')true를 eval('false')반환하고 false를 반환합니다 . eval()그래도 성능에 영향을 미칩니다 .

이것은 받아 들인 대답에서 가져 왔지만 실제로는 매우 약한 점이 있습니다. 대소수에 민감하지 않기 때문에 문자열의 대소 문자를 고려해야하는 문제는 얼마나 많은 공짜를 얻었는지에 놀랐습니다.

var isTrueSet = (myValue.toLowerCase() === 'true');

나는 다음을 사용한다 :

function parseBool(b) {
    return !(/^(false|0)$/i).test(b) && !!b;
}

이 함수는 문자열 "false"(대 / 소문자 구분 안 함) 및 "0"을 제외하고 일반적인 부울 강제 변환을 수행합니다.

많은 답변이 있으며 하나를 선택하기가 어렵습니다. 필자의 경우 선택할 때 성능의 우선 순위를 지정 하므로이 jsPerf를 만듭니다. 여기에 약간의 빛을 던질 수있는 를 .

결과 요약 (높을수록 좋음) :

1. 조건문 : 2,826,922
2. Bool 오브젝트의 케이스 전환 : 2,825,469
3. JSON으로 전송 : 1,867,774
4. !! 전환 : 805,322
5. 문자열 프로토 타입 : 713,637

그것들은 당신이 각각에 대한 더 많은 정보 (장단점)를 찾을 수있는 관련 답변에 연결되어 있습니다. 특별히 의견에.

Boolean.parse = function (str) {
  switch (str.toLowerCase ()) {
    case "true":
      return true;
    case "false":
      return false;
    default:
      throw new Error ("Boolean.parse: Cannot convert string to boolean.");
  }
};

당신이 찾고있는 표현은

/^true$/i.test(myValue)

에서와 같이

var isTrueSet = /^true$/i.test(myValue);

이 테스트 myValue 대소 문자를 구분하지 않는 정규식에 대해 하며 프로토 타입을 수정하지 않습니다.

예 :

/^true$/i.test("true"); // true
/^true$/i.test("TRUE"); // true
/^true$/i.test("tRuE"); // true
/^true$/i.test(" tRuE"); // false (notice the space at the beginning)
/^true$/i.test("untrue"); // false (some other solutions here will incorrectly return true
/^true$/i.test("false");// returns false
/^true$/i.test("xyz");  // returns false

string ( "true", "false") 및 boolean을 모두 부울로 변환하려면

('' + flag) === "true"

어디에서 flag할 수 있습니다

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

이미 많은 답변이 있습니다. 그러나 다음 시나리오는 일부 시나리오에서 유용 할 수 있습니다.

// One can specify all values against which you consider truthy
var TRUTHY_VALUES = [true, 'true', 1];

function getBoolean(a) {
    return TRUTHY_VALUES.some(function(t) {
        return t === a;
    });
}

부울 값이 아닌 예제가있는 경우 유용 할 수 있습니다.

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

왜 이런 식으로 시도하지 않습니까

Boolean(JSON.parse((yourString.toString()).toLowerCase()));

대소 문자와 상관없이 true 또는 false가 아닌 다른 텍스트가 제공되면 오류를 반환하고 숫자를 다음과 같이 캡처합니다.

// 0-> false
// any other number -> true

이 함수는 문자열과 부울 true / false를 처리 할 수 ​​있습니다.

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

아래 데모 :

function stringToBoolean(val) {
  var a = {
    'true': true,
    'false': false
  };
  return a[val];
}

console.log(stringToBoolean("true"));

console.log(typeof(stringToBoolean("true")));

console.log(stringToBoolean("false"));

console.log(typeof(stringToBoolean("false")));

console.log(stringToBoolean(true));

console.log(typeof(stringToBoolean(true)));

console.log(stringToBoolean(false));

console.log(typeof(stringToBoolean(false)));

console.log("=============================================");
// what if value was undefined? 
console.log("undefined result:  " + stringToBoolean(undefined));
console.log("type of undefined result:  " + typeof(stringToBoolean(undefined)));
console.log("=============================================");
// what if value was an unrelated string?
console.log("unrelated string result:  " + stringToBoolean("hello world"));
console.log("type of unrelated string result:  " + typeof(stringToBoolean(undefined)));

나는 이것을 사용하고 있습니다

String.prototype.maybeBool = function(){

    if ( ["yes", "true", "1", "on"].indexOf( this.toLowerCase() ) !== -1 ) return true;
    if ( ["no", "false", "0", "off"].indexOf( this.toLowerCase() ) !== -1 ) return false;

    return this;

}

"on".maybeBool(); //returns true;
"off".maybeBool(); //returns false;
"I like js".maybeBool(); //returns "I like js"

가장 쉬운 방법은 다음과 같습니다 (문자열이 'true'또는 'false'라고 가정).

var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false

이러한 유형의 변환에는 항상 == 연산자 대신 === 연산자를 사용하십시오!

@ Shadow2531이 말했듯이 직접 변환 할 수는 없습니다. 또한 코드가 다른 사람에 의해 재사용 / 사용될 경우 "참"및 "거짓"인 "true"및 "false"이외의 문자열 입력을 고려하는 것이 좋습니다. 이것이 내가 사용하는 것입니다 :

function parseBoolean(string) {
  switch (String(string).toLowerCase()) {
    case "true":
    case "1":
    case "yes":
    case "y":
      return true;
    case "false":
    case "0":
    case "no":
    case "n":
      return false;
    default:
      //you could throw an error, but 'undefined' seems a more logical reply
      return undefined;
  }
}

선택의 가치와 그 가치의 표현을 (생각 적으로) 분리해야합니다.

자바 스크립트 로직에서 문자열 센티넬에서 기본 유형으로 전환해야하는 지점을 선택하고 비교해야합니다. 바람직하게는 변환해야하는 각 값에 대해 한 번만 수행됩니다. 문자열 센티넬이 스크립트가 아는 것이 아니라면 어떤 일이 발생해야하는지 기억해야합니다 (예 : 기본값은 true 또는 false입니까?)

다시 말해, 문자열 값에 의존해야합니다. :-)

이 질문에 대한 나의 견해는 세 가지 목표를 충족시키는 것입니다.

• true 및 false 값의 경우 true / false를 반환하지만 문자열 대신 부울 인 경우 true 또는 false 인 여러 문자열 값의 경우 true / false를 반환합니다.
• 둘째, 지정된 값 이외의 값은 실패하지 않고 오히려 기본값을 반환하도록 복원력있는 인터페이스를 제공하십시오.
• 셋째, 가능한 적은 코드로이 모든 작업을 수행하십시오.

JSON 사용의 문제점은 Javascript 오류를 발생시켜 실패한다는 것입니다. 이 솔루션은 탄력적이지 않습니다 (1과 3을 만족하더라도).

JSON.parse("FALSE") // fails

이 솔루션은 간결하지 않습니다.

if(value === "TRUE" || value === "yes" || ...) { return true; }

Typecast.js에 대한이 정확한 문제를 해결하기 위해 노력하고 있습니다. 세 가지 목표 모두에 대한 최상의 솔루션은 다음과 같습니다.

return /^true$/i.test(v);

많은 경우에 작동하며 {}와 같은 값이 전달 될 때 실패하지 않으며 매우 간결합니다. 또한 정의되지 않거나 오류를 발생시키는 것이 아니라 기본값으로 false를 반환하므로 느슨하게 형식화 된 Javascript 개발에 더 유용합니다. 그것을 제안한 다른 답변에 브라보!

조금 늦었지만이 작업을 수행하기 위해 약간의 스 니펫이 있습니다 .JScript의 모든 진실 / 거짓 / 더러움을 유지하지만 "false"false에 대한 허용 가능한 값으로 포함 합니다.

필자가 언급 한 것 보다이 방법을 선호합니다. 제 3자가 코드를 구문 분석하는 데 의존하지 않기 때문에 (예 : eval / JSON.parse) 내 마음에 너무 잔인합니다. 유틸리티 기능을 필요로하지 않고 유지 보수가 충분하지 않습니다. 다른 진실 / 거짓말 협약.

var value = "false";
var result = (value == "false") != Boolean(value);

// value = "true"  => result = true
// value = "false" => result = false
// value = true    => result = true
// value = false   => result = false
// value = null    => result = false
// value = []      => result = true
// etc..

다른 해결책. jsFiddle

var toBoolean = function(value) {
    var strValue = String(value).toLowerCase();
    strValue = ((!isNaN(strValue) && strValue !== '0') &&
        strValue !== '' &&
        strValue !== 'null' &&
        strValue !== 'undefined') ? '1' : strValue;
    return strValue === 'true' || strValue === '1' ? true : false
};

테스트 사례는 노드에서 실행

> toBoolean(true)
true
> toBoolean(false)
false
> toBoolean(undefined)
false
> toBoolean(null)
false
> toBoolean('true')
true
> toBoolean('True')
true
> toBoolean('False')
false
> toBoolean('false')
false
> toBoolean('0')
false
> toBoolean('1')
true
> toBoolean('100')
true
> 

이런 하나님의 답변 중 일부는 야생입니다. 나는 JS와 부울을 스키닝하는 수많은 방법을 좋아합니다.

내가 아직 보지 못했던 내 선호는 다음과 같습니다.

testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? true : false;

짧막 한 농담

다른 문자열 ( "true"포함)이 이미 있으므로 "false"문자열 만 고려하면됩니다 true.

function b(v){ return v==="false" ? false : !!v; }

테스트

b(true)    //true
b('true')  //true
b(false)   //false
b('false') //false

더 풍성한 버전

function bool(v){ return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v; }

테스트

bool(true)        //true
bool("true")      //true
bool(1)           //true
bool("1")         //true
bool("hello")     //true

bool(false)       //false
bool("false")     //false
bool(0)           //false
bool("0")         //false
bool(null)        //false
bool("null")      //false
bool(NaN)         //false
bool("NaN")       //false
bool(undefined)   //false
bool("undefined") //false
bool("")          //false

bool([])          //true
bool({})          //true
bool(alert)       //true
bool(window)      //true