ブール値 (「true」、「false」など) を表す文字列を JavaScript の組み込み型に変換できますか?
リスト内のユーザーの選択に基づいて更新される HTML の非表示のフォームがあります。このフォームには、ブール値を表すいくつかのフィールドが含まれており、固有のブール値が動的に入力されます。ただし、この値が非表示の入力フィールドに配置されると、文字列になります。
フィールドが文字列に変換された後、フィールドのブール値を特定する唯一の方法は、その文字列表現のリテラル値に依存することでした。
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
これを達成するためのより良い方法はありますか？
var isTrueSet = (myValue === 'true');
同一性演算子 ( ===) を使用します。これは、比較される変数の型が異なる場合に暗黙的な型変換を行いません。
特定のニーズに合わせてこれら 2 つの方法を使用する場合は、おそらく注意が必要です。
var myBool = Boolean("false"); // == true
var myBool = !!"false"; // == true
空の文字列ではない文字列は、trueそれらを使用して評価されます。これらはブール変換に関して私が考えることができる最もクリーンな方法ですが、あなたが探しているものではないと思います。
この非常に賛成のレガシー回答は技術的には正しいですが、文字列値が正確"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).toLowerCase() == "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 )
これは、私が最近見つけたブール変換を行う最も簡単な方法です。それを追加する考え。
JSON.parse('true');
let trueResponse = JSON.parse('true');
let falseResponse = JSON.parse('false');
console.log(trueResponse);
console.log(falseResponse);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偽の値とすべての真の値に対して返されます。true'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 オブジェクトには 'parse' メソッドがありません。Boolean('false')true を返すため、機能しません。!!'false'も返すtrueので、それも機能しません。
string'true'が boolean を返しtrue、 stringが boolean'false'を返すようfalseにする場合、最も簡単な解決策は を使用することeval()です。eval('true')true をeval('false')返し、false を返します。ただし、使用するときはパフォーマンスへの影響に注意してくださいeval()。
たくさんの答えがあり、1つを選ぶのは難しいです。私の場合、パフォーマンスを優先して選択するので、ここに光を当てることができればと思い、この jsPerfを作成します。
結果の概要 (高いほど良い):
それらは関連する回答にリンクされており、それぞれの詳細情報 (長所と短所) を見つけることができます。特にコメントで。
これは受け入れられた回答から取られたものですが、実際には非常に弱点があり、賛成票の数がどのように得られたかにショックを受けています。これは大文字と小文字が区別されるため、文字列の大文字と小文字を考慮する必要があるという問題です。
var isTrueSet = (myValue.toLowerCase() === 'true');
私は以下を使用します：
function parseBool(b) {
return !(/^(false|0)$/i).test(b) && !!b;
}
この関数は、文字列 "false" (大文字と小文字を区別しない) と "0" を除いて、通常のブール型強制を実行します。
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
論理 NOTを 2 回使用します[ !! ]変換された文字列を取得する
この式を貼り付けるだけで...
const stringToBoolean = (string) => string === 'false' ? false : !!string
そしてそれにあなたの文字列を渡してください！
stringToBoolean('') // false
stringToBoolean('false') // false
stringToBoolean('true') // true
stringToBoolean('hello my friend!') // true
const betterStringToBoolean = (string) =>
string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
false : !!string
この式の使用法を簡単に拡張するために、自由に他の文字列を含めることができます...:
betterStringToBoolean('undefined') // false
betterStringToBoolean('null') // false
betterStringToBoolean('0') // false
betterStringToBoolean('false') // false
betterStringToBoolean('') // false
betterStringToBoolean('true') // true
betterStringToBoolean('anything else') // true
string("true", "false") と boolean の両方を boolean に変換するには
('' + flag) === "true"
どこにいるflagことができます
var flag = true
var flag = "true"
var flag = false
var flag = "false"
私はこれを使っています
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"
選択の値とその値の表現を (考えて) 分離する必要があります。
文字列センチネルからネイティブ型に移行する必要がある JavaScript ロジックのポイントを選択し、そこで比較を行います。文字列番兵がスクリプトに認識されていない場合 (つまり、デフォルトで true にするか false にするか?) に対処する必要があることを忘れないでください。
つまり、はい、文字列の値に依存する必要があります。:-)
他の文字列 (「true」を含む) は既に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
@ Shadow2531が言ったように、それを直接変換することはできません。また、コードが他の人によって再利用/使用される場合は、「true」と「false」以外の文字列入力を「truthy」と「falsey」と見なすことをお勧めします。これは私が使用するものです：
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;
}
}
別の解決策。 jsフィドル
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
>
最も簡単な方法 (文字列が「true」または「false」であると仮定) は次のとおりです。
var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false
これらのタイプの変換には、常に== 演算子の代わりに === 演算子を使用してください!
神聖な神、これらの答えのいくつかはただワイルドです。私は JS と、bool を皮をむく無限の方法が大好きです。
まだ見ていないことにショックを受けた私の好みは次のとおりです。
testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? 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 開発でより役立ちます。それを提案した他の回答にブラボー！
これをうまく行う PHP の filter_var に一致する関数を書きました。Gist で利用可能: https://gist.github.com/CMCDragonkai/7389368
/**
* Parses mixed type values into booleans. This is the same function as filter_var in PHP using boolean validation
* @param {Mixed} value
* @param {Boolean} nullOnFailure = false
* @return {Boolean|Null}
*/
var parseBooleanStyle = function(value, nullOnFailure = false){
switch(value){
case true:
case 'true':
case 1:
case '1':
case 'on':
case 'yes':
value = true;
break;
case false:
case 'false':
case 0:
case '0':
case 'off':
case 'no':
value = false;
break;
default:
if(nullOnFailure){
value = null;
}else{
value = false;
}
break;
}
return value;
};
function parseBool(value) {
if (typeof value === "boolean") return value;
if (typeof value === "number") {
return value === 1 ? true : value === 0 ? false : undefined;
}
if (typeof value != "string") return undefined;
return value.toLowerCase() === 'true' ? true : false;
}
ここにはたくさんの空想的な答えがあります。誰もこのソリューションを投稿していないことに本当に驚いています:
var booleanVal = toCast > '';
これは、bool false、数値ゼロ、および空の文字列 (明らかに) 以外のほとんどの場合、true に解決されます。事後に他の誤った文字列値を簡単に探すことができます。
var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';
テスト対象が常に文字列であることが確実な場合は、それが等しいことを明示的に確認することがtrue最善の策です。
サブジェクトが実際にブール値である可能性がある場合に備えて、余分なコードを含めることを検討することをお勧めします。
var isTrueSet =
myValue === true ||
myValue != null &&
myValue.toString().toLowerCase() === 'true';
これにより、文字列の代わりに実際のブール値を使用するようにコードが改善/リファクタリングされた場合、将来の作業を少し節約できます。
私はこれを行い、1=TRUE=yes=YES=true、0=FALSE=no=NO=false を処理します:
BOOL=false
if (STRING)
BOOL=JSON.parse(STRING.toLowerCase().replace('no','false').replace('yes','true'));
STRING を文字列変数の名前に置き換えます。
null、数値、または次のいずれかの文字列の場合: "true"、"TRUE"、"false"、"FALSE"、"yes"、"YES"、"no"、"NO" エラーがスローされます。 （意図的に。）
オブジェクトが最初に存在するかどうかのチェックと、ブール値へのより直感的な変換を含む独自のメソッドを使用します。
function str2bool(strvalue){
return (strvalue && typeof strvalue == 'string') ? (strvalue.toLowerCase() == 'true' || strvalue == '1') : (strvalue == true);
}
結果は次のとおりです。
var test; // false
var test2 = null; // false
var test3 = 'undefined'; // false
var test4 = 'true'; // true
var test5 = 'false'; // false
var test6 = true; // true
var test7 = false; // false
var test8 = 1; // true
var test9 = 0; // false
var test10 = '1'; // true
var test11 = '0'; // false
ブール値に「1」と空の値「」を使用すると、「true」または「false」の文字列値よりもはるかに予測どおりに機能することがわかりました...特にhtmlフォームでは、Dom要素の初期化されていない/空の値が一貫して評価されるためですそれらの中の値は true に評価されますが、falseになります。
例えば：
<input type='button' onclick='this.value = tog(this.value);' />
<script type="text/javascript">
function tog(off) {
if(off) {
alert('true, toggle to false');
return '';
} else {
alert('false, toggle to true');
return '1';
}
}
</script>
簡単な道のように思えましたが、これまでのところ非常に一貫性があり、簡単です...おそらく誰かがこれを破る方法を決定できますか?
@guinaps>空の文字列ではない文字列は、それらを使用することでtrueと評価されます。
String.match() メソッドを使用するのはどうですか
var str="true";
var boolStr=Boolean(str.match(/^true$/i));
これだけでは 1/0 や yes/no は得られませんが、TRUE/true をキャッチします。同様に、部分文字列として "true" を持つ文字列に対して false を返します。
編集
以下は、true/false、1/0、yes/no (大文字と小文字を区別しない) を処理する関数です。
function stringToBool(str) {
var bool;
if (str.match(/^(true|1|yes)$/i) !== null) {
bool = true;
} else if (str.match(/^(false|0|no)*$/i) !== null) {
bool = false;
} else {
bool = null;
if (console) console.log('"' + str + '" is not a boolean value');
}
return bool;
}
stringToBool('1'); // true
stringToBool('No'); // false
stringToBool('falsey'); // null ("falsey" is not a boolean value.)
stringToBool(''); // false
ここに私の 1 つのライナー提出があります: 文字列と出力を評価する必要がありました。「true」の場合は true、「false」の場合は false、「-12.35673」などの場合は数値です。
val = 'false';
val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );
簡単な解決策私はしばらくそれを使用してきました
function asBoolean(value) {
return (''+value) === 'true';
}
// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> false
if (String(a) == "true"){
//true block
} else {
//false block
}
ブール値を文字列に変換する他のコードがある場合は、そのコードが真/偽の値をどのように格納するかを正確に知る必要があります。それか、その変換を逆にする関数にアクセスする必要があります。
文字列でブール値を表現する方法は無限にあります (「true」、「Y」、「1」など)。したがって、Boolean(myValue) のような汎用の文字列からブール値へのコンバーターに依存するべきではありません。元のブール値から文字列への変換を逆にするルーチンを使用する必要があります。
真のブール値を「真の」文字列に変換することがわかっている場合、サンプル コードは問題ありません。== の代わりに === を使用する必要があることを除いて、自動型変換はありません。
URL/フォームまたはその他のソースから値を取得するときに、これを使用しています。
これは非常に普遍的な 1 行のコードです。
何百万回も実行する必要がある場合は、お知らせください。最適化する方法を確認できます。それ以外の場合は、非常に優れており、カスタマイズ可能です。
boolResult = !(['false', '0', '', 'undefined'].indexOf(String(myVar).toLowerCase().trim()) + 1);
結果：
myVar = true; // true
myVar = 'true'; // true
myVar = 'TRUE'; // true
myVar = '1'; // true
myVar = 'any other value not related to false'; // true
myVar = false; // false
myVar = 'false'; // false
myVar = 'FALSE'; // false
myVar = '0'; // false
私はあなたのケース (およびその他) を処理するヘルパー関数を作成しました。特定のニーズに合わせて自由に変更してください
/**
* @example
* <code>
* var pageRequestParams = {'enableFeatureX': 'true'};
* toBool(pageRequestParams.enableFeatureX); // returns true
*
* toBool(pageRequestParams.enableFeatureY, true, options.enableFeatureY)
* </code>
* @param {*}value
* @param {Boolean}[mapEmptyStringToTrue=false]
* @param {Boolean}[defaultVal=false] this is returned if value is undefined.
*
* @returns {Boolean}
* @example
* <code>
* toBool({'enableFeatureX': '' }.enableFeatureX); // false
* toBool({'enableFeatureX': '' }.enableFeatureX, true); // true
* toBool({ }.enableFeatureX, true); // false
* toBool({'enableFeatureX': 0 }.enableFeatureX); // false
* toBool({'enableFeatureX': '0' }.enableFeatureX); // false
* toBool({'enableFeatureX': '0 ' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'false' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'falsE ' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'no' }.enableFeatureX); // false
*
* toBool({'enableFeatureX': 1 }.enableFeatureX); // true
* toBool({'enableFeatureX': '-2' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'true' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'false_' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'john doe'}.enableFeatureX); // true
* </code>
*
*/
var toBool = function (value, mapEmptyStringToTrue, defaultVal) {
if (value === undefined) {return Boolean(defaultVal); }
mapEmptyStringToTrue = mapEmptyStringToTrue !== undefined ? mapEmptyStringToTrue : false; // default to false
var strFalseValues = ['0', 'false', 'no'].concat(!mapEmptyStringToTrue ? [''] : []);
if (typeof value === 'string') {
return (strFalseValues.indexOf(value.toLowerCase().trim()) === -1);
}
// value is likely null, boolean, or number
return Boolean(value);
};
Javascript でのコード実行を高速化するのに役立つ機能の 1 つにShort-Circuit Evaluationがあります。
論理式は左から右に評価されるため、次の規則を使用して「短絡」評価の可能性についてテストされます。
- false && (なんでも) は false に評価される短絡です。
- || 真 || (anything) は true に評価される短絡です。
そのため、文字列値がテストの邪魔になるかどうかをテストしtrue、falseパフォーマンスJSON.parseを強力に維持したい場合は、||演算子を使用して、テスト値がブール型の場合に遅いコードを実行から除外できます。
test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1
Array.prototype.indexOf()メソッドは第 5 版の ECMA-262 標準の一部であるため、古いブラウザーのサポートにはポリフィルが必要になる場合があります。
// Production steps of ECMA-262, Edition 5, 15.4.4.14
// Reference: http://es5.github.io/#x15.4.4.14
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function(searchElement, fromIndex) {
var k;
// 1. Let O be the result of calling ToObject passing
// the this value as the argument.
if (this == null) {
throw new TypeError('"this" is null or not defined');
}
var O = Object(this);
// 2. Let lenValue be the result of calling the Get
// internal method of O with the argument "length".
// 3. Let len be ToUint32(lenValue).
var len = O.length >>> 0;
// 4. If len is 0, return -1.
if (len === 0) {
return -1;
}
// 5. If argument fromIndex was passed let n be
// ToInteger(fromIndex); else let n be 0.
var n = +fromIndex || 0;
if (Math.abs(n) === Infinity) {
n = 0;
}
// 6. If n >= len, return -1.
if (n >= len) {
return -1;
}
// 7. If n >= 0, then Let k be n.
// 8. Else, n<0, Let k be len - abs(n).
// If k is less than 0, then let k be 0.
k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
// 9. Repeat, while k < len
while (k < len) {
// a. Let Pk be ToString(k).
// This is implicit for LHS operands of the in operator
// b. Let kPresent be the result of calling the
// HasProperty internal method of O with argument Pk.
// This step can be combined with c
// c. If kPresent is true, then
// i. Let elementK be the result of calling the Get
// internal method of O with the argument ToString(k).
// ii. Let same be the result of applying the
// Strict Equality Comparison Algorithm to
// searchElement and elementK.
// iii. If same is true, return k.
if (k in O && O[k] === searchElement) {
return k;
}
k++;
}
return -1;
};
}
私はこのスニペットを使用して数値とブール値を変換してきました：
var result = !isNaN(value) ? parseFloat(value) : /^\s*(true|false)\s*$/i.exec(value) ? RegExp.$1.toLowerCase() === "true" : value;
ブール値とブール値のような文字列の両方を評価するために、次の簡単な式を使用しました。
var trueOrStringTrue = (trueOrStringTrue === true) || (trueOrStringTrue === 'true');
明らかなように、true と 'true' の両方に対して true を返します。それ以外はすべて false を返します。
上記のスティーブンの答えに基づいて、この関数を文字列入力の汎用パーサーとして作成しました。
parse:
function (value) {
switch (value && value.toLowerCase()) {
case null: return null;
case "true": return true;
case "false": return false;
default: try { return parseFloat(value); } catch (e) { return value; }
}
}
MyLib.Convert.bool = function(param) {
var res = String(param).toLowerCase();
return !(!Boolean(res) || res === "false" || res === "0");
};
多くの既存の回答は似ていますが、ほとんどの場合、指定された引数がオブジェクトである可能性があるという事実を無視しています。
これが私がちょうど作り上げたものです：
Utils.parseBoolean = function(val){
if (typeof val === 'string' || val instanceof String){
return /true/i.test(val);
} else if (typeof val === 'boolean' || val instanceof Boolean){
return new Boolean(val).valueOf();
} else if (typeof val === 'number' || val instanceof Number){
return new Number(val).valueOf() !== 0;
}
return false;
};
...そしてその単体テスト
Utils.Tests = function(){
window.console.log('running unit tests');
var booleanTests = [
['true', true],
['false', false],
['True', true],
['False', false],
[, false],
[true, true],
[false, false],
['gibberish', false],
[0, false],
[1, true]
];
for (var i = 0; i < booleanTests.length; i++){
var lhs = Utils.parseBoolean(booleanTests[i][0]);
var rhs = booleanTests[i][1];
var result = lhs === rhs;
if (result){
console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tpass');
} else {
console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tfail');
}
}
};
これを短く書くと、var isTrueSet = (myValue === "true") ? true : false;「true」のみが true で、他の値が false であると仮定できます。
将来的にコードが変更され、現時点では 1 つの文字列ではなくブール値が返される可能性があります。
解決策は次のとおりです。
//Currently
var isTrue = 'true';
//In the future (Other developer change the code)
var isTrue = true;
//The solution to both cases
(isTrue).toString() == 'true'
const boolTrue = JSON.parse("true")
const boolFalse = JSON.parse("false")
console.log(boolTrue) // true
console.log(boolFalse) // false「true」のような文字列ブール値を実際のブール値に変換するには、JSON.parse()
例にラップするだけです：JSON.parse("true")
function returnBoolean(str){
str=str.toString().toLowerCase();
if(str=='true' || str=='1' || str=='yes' || str=='y' || str=='on' || str=='+'){
return(true);
}
else if(str=='false' || str=='0' || str=='no' || str=='n' || str=='off' || str=='-'){
return(false);
}else{
return(undefined);
}
}
Boolean.parse()一部のブラウザ実装には存在します。これは間違いなく普遍的なものではないため、それが必要な場合は、このメソッドを使用しないでください。しかし、たとえば Chrome では (私は v21 を使用しています)、正常に動作し、期待どおりに動作します。
文字列をブール値に変換する必要さえありません。以下を使用してください：
var yourstring = yourstringValue == 1 ? true : false;
文字列または数値からブール値を取得するには 良い解決策は次のとおりです。
var boolValue = Boolean(Number('0'));
var boolValue = Boolean(Number('1'));
最初は戻りfalse、2 番目は戻りtrueます。
var trueVals = ["y", "t", "yes", "true", "gimme"];
var isTrueSet = (trueVals.indexOf(myValue) > -1) ? true : false;
または単に
var trueVals = ["y", "t", "yes", "true", "gimme"];
var isTrueSet = (trueVals.indexOf(myValue) > -1);
一部の switch ステートメントに似ていますが、よりコンパクトです。返される値は、文字列が trueVals 文字列の 1 つである場合にのみ true になります。他のすべては偽です。もちろん、入力文字列を正規化して小文字にし、スペースを削除することもできます。
以下で十分でしょう
String.prototype.boolean = function() {
return "true" == this;
};
"true".boolean() // returns true "false".boolean() // returns false
文字列をブール値に変換する最も簡単な方法は次のとおりです。
Boolean(<stringVariable>)
完全にそして非常に簡単に動作します：
var boolean = "false";
boolean = (boolean === "true");
//boolean = JSON.parse(boolean); //or this way..
それをテストするには：
var boolean = "false";
boolean = (boolean === "true");
//boolean = JSON.parse(boolean); //or this way..
if(boolean == true){
alert("boolean = "+boolean);
}else{
alert("boolean = "+boolean);
}次のことを行うだけです。
var myBool = eval (yourString);
例:
alert (eval ("true") == true); // TRUE
alert (eval ("true") == false); // FALSE
alert (eval ("1") == true); // TRUE
alert (eval ("1") == false); // FALSE
alert (eval ("false") == true); // FALSE;
alert (eval ("false") == false); // TRUE
alert (eval ("0") == true); // FALSE
alert (eval ("0") == false); // TRUE
alert (eval ("") == undefined); // TRUE
alert (eval () == undefined); // TRUE
このメソッドは、値を割り当てずに変数を宣言したかのように、空の文字列と未定義の文字列を自然に処理します。