මට බූලියන් අගයක් නිරූපණය කරන නූලක් (උදා: 'සත්‍ය', 'අසත්‍ය') ජාවාස්ක්‍රිප්ට් හි සහජ වර්ගයක් බවට පරිවර්තනය කළ හැකිද?

මට 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භාවිතා කිරීමෙන් ඇගයීමට ලක් කෙරේ . බූලියන් පරිවර්තනය සම්බන්ධයෙන් මට සිතිය හැකි පිරිසිදුම ක්‍රම ඒවා වුවද, මම හිතන්නේ ඒවා ඔබ සොයන දේ නොවේ.

අවවාදයයි

මෙම ඉහළ උරුම උරුමය පිළිතුර තාක්‍ෂණිකව නිවැරදි නමුත් ආවරණය කරන්නේ ඔබේ සංගීත අගය හරියටම "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;

එය පරික්ෂා කළ හොත් එය සත්‍යයට සමාන “සකසා” ඇතැයි උපකල්පනය කරන්න. මෙය සත්‍ය / අසත්‍ය ලෙස තක්සේරු කරයි.

ඔබට සාමාන්‍ය ප්‍රකාශන භාවිතා කළ හැකිය:

/*
 * 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);
}

සංගීත පන්තිය දීර් ing කිරීමට ඔබ කැමති නම් ඔබට කළ හැක්කේ:

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

alert("true".bool());

මෙය ලබා ගැනීම සඳහා සංගීත වස්තුව දිගු කිරීමට කැමති නමුත් ගණන් කළ නොහැකි බව ගැන කනස්සල්ලට පත්වන සහ සංගීත වස්තුව දිගු කරන වෙනත් කේත සමඟ ගැටීම ගැන කනස්සල්ලට පත්වන අය සඳහා (අදහස් බලන්න):

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

(ඇත්ත වශයෙන්ම පැරණි බ්‍රව්සර්වල වැඩ නොකරන අතර ෆයර්ෆොක්ස් අසත්‍ය බව පෙන්වන අතර ඔපෙරා, ක්‍රෝම්, සෆාරි සහ අයිඊ සත්‍ය බව පෙන්වයි. දෝෂ 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]));}

ස්ටීවන්ගේ පිළිතුර හොඳම පිළිතුර යැයි මම සිතුවෙමි, එන අගය නිකම්ම නිකම් නූලකට වඩා බොහෝ අවස්ථා ගැන සැලකිලිමත් විය. මට එය ටිකක් දිගු කර පහත සඳහන් දෑ ඉදිරිපත් කිරීමට අවශ්‍ය විය:

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සැමවිටම a වන බැවින් භාවිතා කිරීම මෙම අවස්ථාවේ දී මෝඩ වනු ඇත 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')නැවත සත්‍ය වන බැවින් එය ක්‍රියාත්මක නොවේ. !!'false'එය ද නැවත ක්‍රියාත්මක trueවන බැවින් එය ද ක්‍රියා නොකරනු ඇත.

ඔබ string අවශ්ය නම් 'true'වීජ ආපසු trueසහ string 'false'ආපසු වීජ කිරීමට false, එවකට ඉතා සරළ විසඳුමක් භාවිතා කිරීමයි eval(). eval('true')සත්‍යය eval('false')වෙත ආපසු ගොස් අසත්‍යය ලබා දෙයි. භාවිතා කරන විට කාර්ය සාධනයේ ඇඟවුම් මතක තබා ගන්න eval().

මෙය පිළිගත් පිළිතුරෙන් ලබාගෙන ඇත, නමුත් ඇත්ත වශයෙන්ම එය ඉතා දුර්වල කරුණක් ඇති අතර, එය ඉහළ නැංවීම ගණනය කළ ආකාරය ගැන මම කම්පාවට පත් වෙමි.

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

මම පහත සඳහන් දෑ භාවිතා කරමි:

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

"ව්‍යාජ" (සිද්ධි සංවේදී නොවන) සහ "0" යන නූල් හැරුණු විට මෙම ශ්‍රිතය සුපුරුදු බූලියන් බලහත්කාරය සිදු කරයි.

පිළිතුරු ගොඩක් ඇති අතර එකක් තෝරා ගැනීම දුෂ්කර ය. මගේ නඩුවේදී, තෝරාගැනීමේදී මම කාර්ය සාධනයට ප්‍රමුඛතාවය දෙමි, එබැවින් මම මෙම jsPerf නිර්මාණය කරන්නේ මෙහි යම් ආලෝකයක් විසි කළ හැකි යැයි මම විශ්වාස කරමි.

ප්‍රති results ල කෙටියෙන් (වඩා හොඳ වඩා හොඳ):

1. කොන්දේසි සහිත ප්රකාශය : 2,826,922
2. බූල් වස්තුව මත නඩුව මාරු කරන්න : 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

නූල් දෙකම ("සත්‍ය", "අසත්‍ය") සහ බූලියන් බූලියන් බවට පරිවර්තනය කිරීම

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

නඩුව නොසලකා සත්‍ය හෝ අසත්‍යයට වඩා වෙනත් පා text යක් ලබා දුන් විට එය දෝෂයක් නැවත ලබා දෙන අතර එය සංඛ්‍යා ද ග්‍රහණය කරගනු ඇත

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

මෙම ශ්‍රිතයට නූල් මෙන්ම බූලියන් සත්‍ය / අසත්‍යය හැසිරවිය හැකිය.

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"

පහසුම ක්‍රමයට අත තබන්න (ඔබේ වචන 'සත්‍ය' හෝ 'අසත්‍ය' යැයි උපකල්පනය කරයි):

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

ඔබේ තේරීම්වල වටිනාකම සහ එම අගය නිරූපණය කිරීම (ඔබේ චින්තනයේ දී) වෙන් කළ යුතුය.

ජාවාස්ක්‍රිප්ට් තර්කනයේ ලක්ෂ්‍යයක් තෝරන්න, එහිදී ඔවුන්ට නූල් සෙන්ඩිනල්වල සිට ස්වදේශීය වර්ගයට මාරුවීමට අවශ්‍ය වන අතර එහි සැසඳීමක් කරන්න. සෙන්ටිනල් නූල ස්ක්‍රිප්ට් එකක් නොදන්නේ නම් සිදුවිය යුතු දේ ආමන්ත්‍රණය කිරීමට මතක තබා ගන්න (එනම් ඔබ පෙරනිමි සත්‍ය හෝ අසත්‍යද?)

වෙනත් වචන වලින් කිවහොත්, ඔව්, ඔබ නූල් වල වටිනාකම මත රඳා සිටිය යුතුය. :-)

මෙම ප්‍රශ්නය මා විසින් ගනු ලබන්නේ අරමුණු තුනක් සපුරාලීම අරමුණු කර ගෙන ය:

• සත්‍ය සහ අසත්‍ය අගයන් සඳහා සත්‍ය / අසත්‍යය ආපසු එවන්න, නමුත් නූල් වෙනුවට බූලියන් නම් සත්‍ය හෝ අසත්‍ය විය හැකි බහු නූල් අගයන් සඳහා සත්‍ය / අසත්‍යය ආපසු එවන්න.
• දෙවනුව, නිශ්චිත අගයන් හැර වෙනත් අගයන් අසමත් නොවී පෙරනිමි අගයක් ලබා දෙන පරිදි ඔරොත්තු දෙන අතුරු මුහුණතක් සපයන්න
• තෙවනුව, මේ සියල්ල හැකි තරම් කුඩා කේතයකින් කරන්න.

JSON භාවිතා කිරීමේ ගැටළුව වන්නේ එය ජාවාස්ක්‍රිප්ට් දෝෂයක් ඇතිවීමෙන් අසමත් වීමයි. මෙම විසඳුම ඔරොත්තු නොදේ (එය 1 සහ 3 තෘප්තිමත් වුවද):

JSON.parse("FALSE") // fails

මෙම විසඳුම ප්රමාණවත් නොවේ:

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

Typecast.js සඳහා මෙම නිශ්චිත ගැටළුව විසඳීමට මම කටයුතු කරමින් සිටිමි . අරමුණු තුනටම හොඳම විසඳුම මෙයයි:

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

එය බොහෝ අවස්ථාවන් සඳහා ක්‍රියා කරයි, {like වැනි අගයන් සම්මත වූ විට අසමත් නොවේ, ඉතා සංක්ෂිප්ත ය. ලිහිල්ව ටයිප් කළ ජාවාස්ක්‍රිප්ට් සංවර්ධනය සඳහා වඩාත් ප්‍රයෝජනවත් වන දෝෂයක් නිර්වචනය කිරීමට හෝ දෝෂයක් විසි කිරීමට වඩා එය පෙරනිමි අගය ලෙස අසත්‍ය වේ. එය යෝජනා කළ අනෙක් පිළිතුරු වලට බ්‍රාවෝ!

මම ටිකක් පරක්කුයි, නමුත් මට මෙය කිරීමට කුඩා ස්නිපටයක් ඇත, එය අත්‍යවශ්‍යයෙන්ම සියලුම JScripts truthey / falsey / අපිරිසිදු ලෙස නඩත්තු කරයි නමුත් "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
> 

ශුද්ධ වූ දෙවියනේ මෙම පිළිතුරු සමහරක් වල් ය. මම ජේඑස් සහ එහි අසීමිත ක්‍රමයට ආදරය කරමි.

දැනටමත් දැක නොගැනීම ගැන මම කම්පනයට පත් වූ මගේ මනාපය:

testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? 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