предупреждение

этот сильно поддержанный ответ на наследие технически корректен, но охватывает только очень конкретный сценарий, когда ваше строковое значение точно "true" или "false" (должно быть также в нижнем регистре).

недопустимая строка json, переданная в эти функции ниже исключение.

---

оригинальный ответ:

как насчет?

JSON.parse("true");

или с jQuery

$.parseJSON("true");

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

вы можете использовать регулярные выражения:

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

Не забудьте сопоставить случай:

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

кроме того, если это флажок элемента формы, вы также можете определить, установлен ли флажок:

var isTrueSet = document.myForm.IS_TRUE.checked;

предполагая, что если он проверен, он "установлен" равным true. Это оценивается как true / false.

дерево-глаз будьте осторожны. Увидев последствия после применения верхнего ответа С 500 + upvotes, я чувствую себя обязанным опубликовать что-то действительно полезное:

начнем с самого короткого, но очень строгого пути:

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

ваше решение в порядке.

используя === было бы просто глупо в этом случае, как поля value всегда будет String.

универсальное решение с JSON parse:

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/

Я думал, что ответ @ 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

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

логический объект не имеет метода 'parse'. Boolean('false') возвращает true, так что это не будет работать. !!'false' возвращает true, Так что это тоже не сработает.

если вы хотите строку 'true' чтобы вернуть boolean true и в строке 'false' чтобы вернуть boolean false, то самое простое решение-использовать eval(). eval('true') возвращает true eval('false') возвращает false. Имейте в виду последствия для производительности при использовании eval() хотя.

Я использую следующий:

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.");
  }
};

есть много ответов, и трудно выбрать один. В моем случае, я отдаю приоритет производительности при выборе, поэтому я создаю см. Этот тест jsperf что я надеюсь, может пролить свет здесь.

краткое изложение результатов (чем выше, тем лучше):

1. условный оператор: 2,826,922
2. переключатель case on bool object: 2,825,469
3. отливки JSON: 1,867,774
4. !! конверсии: 805,322
5. прототип строку: 713,637

Они связаны с соответствующим ответом, где вы можете найти более подробную информацию (плюсы и минусы) о каждом из них; особенно в комментариях.

выражение, которое вы ищете просто

/^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

уже есть так много ответов. Но следующее Может быть полезно в некоторых сценариях.

// 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

Это было взято из принятого ответа, но на самом деле у него есть очень слабое место, и я потрясен, как он получил это количество голосов, проблема с ним, что вы должны рассмотреть случай строки, потому что это чувствительно к регистру

var isTrueSet = (myValue.toLowerCase() === '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

всегда используйте оператор = = = вместо оператора == для этих типов преобразований!

Как сказал @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") и 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"

мой взгляд на этот вопрос заключается в том, что он призван удовлетворять трем критериям:

• возвращает 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. Браво другим ответам, которые предлагали это!

Я немного опоздал, но у меня есть небольшой фрагмент, чтобы сделать это, он по существу поддерживает все JScripts truthey/falsey/грязный-Несс, но включает в себя "false" как приемлемое значение для false.

Я предпочитаю этот метод упомянутым, потому что он не зависит от третьей стороны для разбора кода (т. е.: eval/JSON.parse), который является излишним в моем уме, он достаточно короткий, чтобы не требовать функции полезности и поддерживает другие соглашения truthey/falsey.

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
> 

эта функция может обрабатывать строку, а также логическое значение 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)));

вам нужно отделить (в вашем мышлении) значение ваших выборов и представление этого значения.

Выберите точку в логике JavaScript, где им нужно перейти от string sentinels к native type и сделать сравнение там, предпочтительно, где это делается только один раз для каждого значения, которое необходимо преобразовать. Не забудьте обратиться к тому, что должно произойти, если string sentinel не является тем, что знает скрипт (т. е. вы по умолчанию используете true или to ложь?)

иными словами, Да, вы должны зависеть от значения строки. : -)

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

Я написал функцию, чтобы соответствовать 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;
};

String(true).toLowerCase() == 'true'; // true
String("true").toLowerCase() == 'true'; // true
String("True").toLowerCase() == 'true'; // true
String("TRUE").toLowerCase() == 'true'; // true

String(false).toLowerCase() == 'true'; // false

Если вы не уверены в вводе, вышеизложенное работает для boolean, а также для любой строки.