ブール値（「true」、「false」など）を表す文字列をJavaScriptの組み込み型に変換できますか？

リスト内のユーザーの選択に基づいて更新されるHTMLの非表示フォームがあります。このフォームには、ブール値を表し、動的に固有のブール値が入力されるいくつかのフィールドが含まれています。ただし、この値が非表示の入力フィールドに配置されると、文字列になります。

文字列に変換された後、フィールドのブール値を特定する唯一の方法は、文字列表現のリテラル値に依存することでした。

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

これを達成するためのより良い方法はありますか？

行う：

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

===等価演算子（==）の代わりに、比較される変数の型が異なる場合に暗黙の型変換を行わない識別演算子（）を使用して、より厳密にすることができます。

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

してはいけないこと：

特定のニーズにこれらの2つの方法を使用する場合は、おそらく注意が必要です。

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;

チェックされている場合は、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);

（もちろん、古いブラウザーでは機能せず、Firefoxはfalseを示しますが、Opera、Chrome、Safari、IEはtrueを示します。バグ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());

ブールオブジェクトには「解析」メソッドがありません。Boolean('false')trueを返すため、機能しません。!!'false'もを返すtrueため、これも機能しません。

string 'true'がブール値を返しtrue、string '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"）とブール値の両方をブール値に変換するには

('' + 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;
    });
}

これは、1つの例がブール値ではない場合に役立ちます。

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が言ったように、直接変換することはできません。また、コードが他の人によって再利用/使用される場合は、「真」と「偽」の他に、「真実」と「偽」の文字列入力を検討することをお勧めします。これは私が使用するものです：

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;
  }
}

選択の値とその値の表現を（考えて）分離する必要があります。

JavaScriptロジックで、文字列センチネルからネイティブタイプに遷移する必要があるポイントを選択し、そこで比較を行います。できれば、変換が必要な値ごとに1回だけ実行されるのが望ましい場所です。文字列センチネルがスクリプトが認識しないものである場合に何が必要かを忘れずに対処してください（つまり、デフォルトでtrueまたはfalseになっていますか？）

つまり、はい、文字列の値に依存する必要があります。:-)

この質問に対する私の見方は、それが3つの目的を満たすことを目的としているということです：

• 真と偽の値の場合はtrue / falseを返しますが、文字列ではなくブール値の場合に真または偽となる複数の文字列値の場合もtrue / falseを返します。
• 次に、指定された値以外の値が失敗しないように、復元力のあるインターフェイスを提供しますが、デフォルト値を返します
• 3番目に、これらすべてを可能な限り少ないコードで実行します。

JSONを使用する場合の問題は、JavaScriptエラーが発生して失敗することです。このソリューションは弾力性がありません（ただし、1および3を満たします）。

JSON.parse("FALSE") // fails

このソリューションは十分に簡潔ではありません：

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

Typecast.jsのこの正確な問題の解決に取り組んでいます。そして、3つの目的すべてに対する最良の解決策はこれです。

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

多くの場合に機能し、{}などの値が渡されても失敗せず、非常に簡潔です。また、未定義またはエラーをスローするのではなく、デフォルト値としてfalseを返します。これは、緩やかに型付けされたJavascript開発でより役立ちます。それを示唆した他の答えへのブラボー！

私は少し遅れましたが、これを実行するための小さなスニペットがあります。これは、本質的にすべてのJScriptの真偽/偽/ 不潔さを維持しますが、許容可能な"false"偽の値として含みます。

サードパーティに依存せずにコードを解析するため、この方法を使用します（例：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と、boolのスキンを作成するその無数の方法が大好きです。

私がまだ見ていないことにショックを受けた私の好みは次のとおりです。

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