Делать:

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

Вы можете сделать его более строгим, используя оператор идентичности (===), который не выполняет никаких неявных преобразований типов, когда сравниваемые переменные имеют разные типы, вместо оператора равенства (==).

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

Не делайте этого:

Вам, вероятно, следует использовать будьте осторожны при использовании этих двух методов для ваших конкретных нужд:

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

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

Любая строка, которая не является пустой, будет оцениваться как true с их использованием. Хотя это самые чистые методы, которые я могу придумать для логического преобразования, я думаю, что это не то, что вы ищете.

Не забудьте указать регистр:

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

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

var isTrueSet = document.myForm.IS_TRUE.checked;

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

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

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

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

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

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

Если есть другой код, преобразующий логическое значение в строку, вам нужно точно знать, как этот код хранит истинные / ложные значения. Либо это, либо вам нужен доступ к функции, которая отменяет это преобразование.

Существует бесконечное множество способов представления логических значений в строках («истина», «Y», «1» и т. д.). Поэтому вам не следует полагаться на какой-то универсальный преобразователь строки в логическое значение, например Boolean (myValue). Вам нужно использовать процедуру, которая меняет исходное преобразование логического значения в строку, каким бы оно ни было.

Если вы знаете, что он преобразует истинные логические значения в «истинные» строки, тогда ваш пример кода в порядке. За исключением того, что вы должны использовать === вместо ==, поэтому нет автоматического преобразования типа.

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

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

Я думаю, это универсально:

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

if (String(a) == "true"){
  //true block
} else {
  //false block
}

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

Просто сделайте:

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

Этот метод обрабатывает пустую строку и неопределенную строку естественным образом, как если бы вы объявляли переменную без присвоения ей значения.

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

Достаточно следующего

String.prototype.boolean = function() {
    return "true" == this; 
};

"true".boolean() // returns true "false".boolean() // returns false

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

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

Самый простой способ (при условии, что ваша строка будет «истина» или «ложь»):

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

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

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

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

Этот устаревший ответ, получивший большое количество голосов, является технически правильным, но охватывает только очень конкретный сценарий, когда ваше строковое значение ИМЕННО "true" или "false".

В эти функции под БУДЕТ генерировать исключение передана недопустимая строка json.

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

Как насчет?

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

или с jQuery

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

Я обнаружил, что использование '1' и пустого значения '' для логических значений работает гораздо более предсказуемо, чем строковые значения 'true' или 'false' ... особенно с формами html, поскольку неинициализированные / пустые значения в элементах Dom будут последовательно оценивать значение false, тогда как значение Любые в них оценивается как true.

Например:

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

Мне показалось, что это более легкий путь, до сих пор он был очень последовательным / простым ... возможно, кто-то сможет найти способ сломать это?

Как сказал @ 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;
  }
}

@guinaps> Любая строка, которая не является пустой, будет оцениваться как истинная с их помощью.

Как насчет использования метода String.match ()

var str = "true";
var boolStr=Boolean(str.match(/^true$/i)); 

сам по себе он не получит 1/0 или да / нет, но он также поймает ИСТИНА / истину, он вернет ложь для любой строки, которая имеет подстроку «истина».

РЕДАКТИРОВАТЬ

Ниже приведена функция для обработки истинного / ложного, 1/0, да / нет (без учета регистра).

​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.info('"' + 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

Boolean.parse() существует в некоторых реализациях браузеров. Он определенно не универсален, поэтому, если вам это нужно, вам не следует использовать этот метод. Но, например, в Chrome (я использую v21) он работает нормально, как и следовало ожидать.

Я использовал этот фрагмент для преобразования чисел и логических значений:

var result = !isNaN(value) ? parseFloat(value) : /^\s*(true|false)\s*$/i.exec(value) ? RegExp.$1.toLowerCase() === "true" : value;

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

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

Я считаю, что этот вопрос преследует три цели:

• Возвращает истину / ложь для истинных и ложных значений, но также возвращает истину / ложь для нескольких строковых значений, которые были бы правдивыми или ложными, если бы они были логическими, а не строковыми.
• Во-вторых, предоставьте гибкий интерфейс, чтобы значения, отличные от указанных, не выходили из строя, а возвращали значение по умолчанию.
• В-третьих, делайте все это, используя как можно меньше кода.

Проблема с использованием JSON заключается в том, что он не работает, вызывая ошибку Javascript. Это решение не является устойчивым (хотя оно удовлетворяет 1 и 3):

JSON.parse("FALSE") // fails

Это решение недостаточно лаконично:

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

Я работаю над решением именно этой проблемы для Typecast.js. И лучшее решение для всех трех целей - это:

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

Он работает во многих случаях, не дает сбоев при передаче таких значений, как {}, и очень лаконичен. Также он возвращает false в качестве значения по умолчанию, а не undefined или выдает ошибку, что более полезно при разработке слабо типизированного Javascript. Браво другим ответам, которые предложили это!

Основываясь на ответе Стивена выше, я написал эту функцию как общий синтаксический анализатор для ввода строки:

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

Вам даже не нужно преобразовывать строку в логическое значение. просто используйте следующее: var yourstring = yourstringValue == 1 ? true : 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);
};

    MyLib.Convert.bool = function(param) {
         var res = String(param).toLowerCase();
         return !(!Boolean(res) || res === "false" || res === "0");
     }; 

Вот мой 1 лайнер: мне нужно было оценить строку и результат: истина, если «истина», ложь, если «ложь», и число, если что-то вроде «-12.35673».

val = 'false';

val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );

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

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

Эта функция выполняет обычное логическое приведение, за исключением строк «false» (без учета регистра) и «0».

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

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, которая прекрасно с этим справляется. Доступен в виде: 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;
};

Универсальное решение с парсингом 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/

Многие из существующих ответов похожи, но большинство игнорирует тот факт, что данный аргумент также может быть объектом.

Вот кое-что, что я только что придумал:

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.info('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.info('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tpass');
        } else {
            console.info('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tfail');
        }
    }
};

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

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

Начнем с самого короткого, но очень строгого способа:

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

И закончить правильным, более терпимым путем:

var parseBool = function(str) 
{
    // console.info(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.info("array_1["+i+"] ("+array_1[i]+"): " + parseBool(array_1[i]));}

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

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

Более короткий способ записать это, мог бы быть var isTrueSet = (myValue === "true") ? true : false; Предполагая, что только «истина» истинна, а другие значения ложны.

Простое решение, которое я использую некоторое время

function asBoolean(value) {

    return (''+value) === 'true'; 

}


// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> 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());

Я делаю это, что будет обрабатывать 1 = ИСТИНА = да = ДА = истина, 0 = ЛОЖЬ = нет = НЕТ = ложь:

BOOL=false
if (STRING)
  BOOL=JSON.parse(STRING.toLowerCase().replace('no','false').replace('yes','true'));

Замените STRING именем своей строковой переменной.

Если это не null, числовое значение или одна из этих строк: «истина», «ИСТИНА», «ложь», «ЛОЖЬ», «да», «ДА», «нет», «НЕТ» Это вызовет ошибку (намеренно).

Я использую собственный метод, который включает сначала проверку, существует ли объект, и более интуитивное преобразование в логическое значение:

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

Рабочий пример: http://jsfiddle.net/av5xcj6s/

Я использую это

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"

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

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

1. Условный оператор: 2,826,922
2. Переключить регистр на объект Bool: 2,825,469
3. Трансляция в JSON: 1,867,774
4. !! конверсии: 805 322
5. Прототип строки: 713 637

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

Чтобы оценить как логические, так и логические строки, такие как boolean, я использовал эту простую формулу:

var trueOrStringTrue = (trueOrStringTrue === true) || (trueOrStringTrue === 'true');

Очевидно, что он вернет true как для true, так и для true. Все остальное возвращает false.

Чтобы преобразовать как строку («истина», «ложь»), так и логическое значение в логическое

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

Где может быть flag

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

работает отлично и очень просто:

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

другое решение. 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
> 

Самый быстрый и безопасный способ преобразовать строку в логическое значение в одной строке кода

Одна из функций, которые помогают ускорить выполнение кода в Javascript, - это Оценка короткого замыкания:

As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:

• false && (anything) is short-circuit evaluated to false.
• true || (anything) is short-circuit evaluated to true.

Таким образом, если вы хотите проверить строковое значение на предмет true или false в способе тестирования JSON.parse и сохранить высокую производительность, вы можете использовать оператор ||, чтобы исключить медленный код из выполнения в случае, если тестовое значение имеет логический тип.

test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1

Поскольку метод Array.prototype.indexOf() является частью стандарта ECMA-262 в 5-й редакции, вам может потребоваться полифил для поддержки старых браузеров.

// 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 boolValue = Boolean(Number('0'));

var boolValue = Boolean(Number('1'));

Первый вернет false, а второй вернет true.

function isTrue(val) {
    try {
        return !!JSON.parse(val);
    } catch (e) {
        return false;
    }
}

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

Решение было бы таким:

//Currently
var isTrue = 'true';
//In the future (Other developer change the code)
var isTrue = true;
//The solution to both cases
(isTrue).toString() == 'true'

Здесь много причудливых ответов. Действительно удивлен, что никто не опубликовал это решение:

var booleanVal = toCast > '';

Это разрешается в true в большинстве случаев, кроме bool false, number zero и пустой строки (очевидно). Вы можете легко найти другие ложные строковые значения постфактум, например:

var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';  

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

// 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');

Я использую этот простой подход (с помощью myVarToTest):

var trueValuesRange = ['1', 1, 'true', true];

myVarToTest = (trueValuesRange.indexOf(myVarToTest) >= 0);

Успокойтесь, используя эту библиотеку.

https://github.com/rohmanhm/force-boolean

вам просто нужно написать одну строку

const ForceBoolean = require('force-boolean')

const YOUR_VAR = 'false'
console.info(ForceBoolean(YOUR_VAR)) // it's return boolean false

Это также поддержка для следующих

 return false if value is number 0
 return false if value is string '0'
 return false if value is string 'false'
 return false if value is boolean false
 return true if value is number 1
 return true if value is string '1'
 return true if value is string 'true'
 return true if value is boolean 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. Все остальное ложно. Конечно, вы можете нормализовать входную строку, чтобы сделать ее строчными и обрезать любые пробелы.

Преобразовать строку в логическое значение

var vIn = "true";
var vOut = vIn.toLowerCase()= = "true"?1:0;

Преобразовать строку в число

var vIn = 0;
var vOut = parseInt(vIn,10/*base*/);

Вот простая функция, которая поможет:

   function convertStringToBool(str){
        return ((str === "True") || (str === "true")) ? true:false;
    }

Это даст следующий результат

convertStringToBool("false") //returns false
convertStringToBool("true") // returns true
convertStringToBool("False") // returns false
convertStringToBool("True") // returns 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

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

Если вы не уверены в вводе, приведенное выше работает как для логического, так и для любой строки.

Вы можете использовать Function для возврата значения Boolean из строки "true" или "false"

const TRUE_OR_FALSE = str => new Function(`return ${str}`)();

const [TRUE, FALSE] = ["true", "false"];

const [T, F] = [TRUE_OR_FALSE(TRUE), TRUE_OR_FALSE(FALSE)];

console.info(T, typeof T); // `true` `"boolean"`

console.info(F, typeof F); // `false` `"boolean"`

вы можете использовать JSON.parse следующим образом:

   
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if (result==true)
  alert('this is true');
else 
  alert('this is false');

в этом случае важен .toLowerCase

Функция toBoolean возвращает false для null, undefined, ',' false '. Он возвращает истину для любой другой строки:

const toBoolean = (bool) => {
  if (bool === 'false') bool = false
  return !!bool
}

toBoolean('false') // returns false

Я использую его, когда получаю значение из URL / формы или другого источника.

Это довольно универсальный однострочный фрагмент кода.

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

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

Боже, некоторые из этих ответов просто дикие. Мне нравится JS и его бесконечное количество способов избавиться от bool.

Мое предпочтение, которое я был шокирован, чтобы не заметить, это:

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

почему бы тебе не попробовать что-то подобное

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

Он вернет ошибку, если будет указан какой-либо другой текст, а не истина или ложь, независимо от случая, и он будет фиксировать числа также как

// 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.info(stringToBoolean("true"));

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

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

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

console.info(stringToBoolean(true));

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

console.info(stringToBoolean(false));

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

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

В nodejs с использованием узел-boolify возможно

Результаты логического преобразования

Boolify(true); //true
Boolify('true'); //true
Boolify('TRUE'); //null
Boolify(1); //true
Boolify(2); //null
Boolify(false); //false
Boolify('false'); //false
Boolify('FALSE'); //null
Boolify(0); //false
Boolify(null); //null
Boolify(undefined); //null
Boolify(); //null
Boolify(''); //null

Для TypeScript мы можем использовать функцию:

export function stringToBoolean(s: string, valueDefault: boolean = false): boolean {
    switch(s.toLowerCase())
    {
        case "true":
        case "1":
        case "on":
        case "yes":
        case "y":
            return true;

        case "false":
        case "0":
        case "off":
        case "no":
        case "n":
            return false;
    }

    return valueDefault;
}

Если вы уверены, что испытуемый всегда является строкой, то лучше всего явно проверить, что он равен true.

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

var isTrueSet =
    myValue === true ||
    myValue != null &&
    myValue.toString().toLowerCase() === 'true';

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

Самый простой способ, которым я всегда пользуюсь:

let value = 'true';
let output = value === 'true';

Я надеюсь, что это наиболее полный вариант использования

function parseBoolean(token) {
  if (typeof token === 'string') {
    switch (token.toLowerCase()) {
      case 'on':
      case 'yes':
      case 'ok':
      case 'ja':
      case 'да':
      // case '':
      // case '':
        token = true;
        break;
      default:
        token = false;
    }
  }
  let ret = false;
  try {
    ret = Boolean(JSON.parse(token));
  } catch (e) {
    // do nothing or make a notification
  }
  return ret;
}

Попробуйте это решение (работает как шарм!):

function convertStrToBool(str)
    {
        switch(String(str).toLowerCase())
            {
                case 'undefined': case 'null': case 'nan': case 'false': case 'no': case 'f': case 'n': case '0': case 'off': case '':
                    return false;
                    break;
                default:
                    return true;
            };
    };

В HTML значения атрибутов в конечном итоге становятся строками. Чтобы смягчить это в нежелательных ситуациях, вы можете использовать функцию для условного синтаксического анализа их в значения, которые они представляют в JavaScript или любом другом интересующем языке программирования.

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

В дополнение к этому JSON.parse имеет оживить параметр, который является функцией. Его также можно использовать для достижения того же.

Давайте назовем строку, имеющую вид логический, «истина», логическая строка. Подобным образом мы можем назвать строку, подобную числу, «1», числовая строка. Затем мы можем определить, является ли строка логическая строка:

const isBooleanString = (string) => ['true', 'false'].some(item => item === string);

После этого нам нужно разобрать логическая строка как JSON методом JSON.parse:

JSON.parse(aBooleanString);

Однако любая строка, которая не является логическая строка, числовая строка или любым строковым объектом или массивом (любой недопустимый JSON), приведет к тому, что метод JSON.parse выдаст SyntaxError.

Итак, вам нужно знать, как его называть, то есть логическая строка. Вы можете добиться этого, написав функцию, которая заставляет вышеуказанный defiend логическая строка проверять и вызывать JSON.parse:

function parse(string){
  return isBooleanString(string) ? JSON.parse(string)
    : string;
}

Можно дополнительно обобщить утилиту isBooleanString, чтобы иметь более широкую перспективу того, что квалифицируется как логическая строка, путем дальнейшей параметризации ее для принятия необязательного массива принятых строк логический:

const isBooleanString = (string, spec = ['true', 'false', 'True', 'False']) => spec.some(item => item === string);

Самый простой способ

a = 'True';
a = !!a && ['1', 'true', 1, true].indexOf(a.toLowerCase()) > -1;

const result: Boolean = strValue === "true" ? true : false

Многие из существующих ответов используют подход, семантически похожий на этот: но я думаю, что есть смысл упомянуть, что следующего «однострочного» часто бывает достаточно. Например, в дополнение к случаю OP (строки в форме) часто требуется прочитать переменные среды из process.env в NodeJS (значения которых, насколько мне известно, всегда являются строками), чтобы включить или отключить определенное поведение, и обычно они имеют форму SOME_ENV_VAR=1.

const toBooleanSimple = (input) => 
  ['t', 'y', '1'].some(truePrefix => truePrefix === input[0].toLowerCase());

Чуть более надежная и выразительная реализация может выглядеть так:

/**
 * Converts strings to booleans in a manner that is less surprising
 * to the non-JS world (e.g. returns true for "1", "yes", "True", etc.
 * and false for "0", "No", "false", etc.)
 * @param input
 * @returns {boolean}
 */
function toBoolean(input) {
  if (typeof input !== 'string') {
    return Boolean(input);
  }
  const s = input.toLowerCase();
  return ['t', 'y', '1'].some(prefix => s.startsWith(prefix));
}

Юнит-тест (шутка) для этого может выглядеть так:

describe(`toBoolean`, function() {
  const groups = [{
    inputs: ['y', 'Yes', 'true', '1', true, 1],
    expectedOutput: true
  }, {
    inputs: ['n', 'No', 'false', '0', false, 0],
    expectedOutput: false
  }]
  for (let group of groups) {
    for (let input of group.inputs) {
      it(`should return ${group.expectedOutput} for ${JSON.stringify(input)}`, function() {
        expect(toBoolean(input)).toEqual(group.expectedOutput);
      });
    }      
  }
});

Используйте статус if:

function parseBool(str) {
  if (str.toLowerCase() == 'true') {
    var val = true;
  } else if (str.toLowerCase() == 'false') {
    var val = false;
  } else {
    //If it is not true of false it returns undefined.//
    var val = undefined;
  }
  return val;
}
console.info(parseBool(''), typeof parseBool(''));
console.info(parseBool('TrUe'), typeof parseBool('TrUe'));
console.info(parseBool('false'), typeof parseBool('false'));

ПРЕДУПРЕЖДЕНИЕ:Никогда использует этот метод для ненадежного ввода, такого как параметры URL.

Вы можете использовать функцию eval(). Непосредственно передайте вашу строку в функцию eval().

console.info(eval('true'), typeof eval('true'))
console.info(eval('false'), typeof eval('false'))

Вам даже не нужно использовать переменную, если вы знаете, что 'true' всегда будет в нижнем регистре, вы можете использовать это, которое вернет true или false:

(eval(yourBooleanString == 'true'))

Я думаю, что это можно сделать в 1 лайнере с помощью функции стрелки использования

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;

Вы, ребята, можете запускать и тестировать различные случаи с помощью следующего фрагмента кода

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;

console.info(convertStringToBoolean("a"));
console.info(convertStringToBoolean(null));
console.info(convertStringToBoolean(undefined));
console.info(convertStringToBoolean("undefined"));
console.info(convertStringToBoolean(true));
console.info(convertStringToBoolean(false));
console.info(convertStringToBoolean(0));
console.info(convertStringToBoolean(1)); // only case which will not work

Самый простой способ преобразовать строку в логическое значение:

Boolean(<stringVariable>)

Простая однострочная операция, если вам нужны логические false и true из строковых значений:

storeBooleanHere = stringVariable= = "true"?true:false;

• storeBooleanHere - эта переменная будет содержать логическое значение
• stringVariable - переменная, логическое значение которой хранится как строка

Я рекомендую вам создать функцию, подобную третьему варианту на изображении, и поместить ее во вспомогательный класс в качестве экспорта и повторно использовать эту функцию, когда вам нужно.

/// Convert something to boolean
function toBoolean( o ) {
    if ( null !== o ) {
        let t = typeof o;
        if ( "undefined" !== typeof o ) {
            if ( "string" !== t ) return !!o;
            o = o.toLowerCase().trim();
            return "true" === o || "1" === o;
        }
    }
    return false;
}

toBoolean(false) --> false
toBoolean(true) --> true
toBoolean("false") --> false
toBoolean("true") --> true
toBoolean("TRue") --> true
toBoolean("1") --> true
toBoolean("0") --> false
toBoolean(1) --> true
toBoolean(0) --> false
toBoolean(123.456) --> true
toBoolean(0.0) --> false
toBoolean("") --> false
toBoolean(null) --> false
toBoolean() --> false

Самый надежный способ - следующий, потому что он также обрабатывает неопределенный случай:

    ({'true': true, 'false': false})[myValue];

    ({'true': true, 'false': false})[undefined] // => undefined
    ({'true': true, 'false': false})['true'] // => true
    ({'true': true, 'false': false})['false] // => false

если вы уверены, что введены какие-либо значения только в пределах "истина" и "ложь" почему нет :

let x = 'true' ;
//let x= 'false';
let y = x==='true'?true:false;
console.info(typeof(y), y);

function convertBoolean(value): boolean {
    if (typeof value == 'string') {
        value = value.toLowerCase();
    }
    switch (value) {
        case true:
        case "true":
        case "evet": // Locale
        case "t":
        case "e": // Locale
        case "1":
        case "on":
        case "yes":
        case 1:
            return true;
        case false:
        case "false":
        case "hayır": // Locale
        case "f":
        case "h": // Locale
        case "0":
        case "off":
        case "no":
        case 0:
            return false;
        default:
            return null;
    }
}

Самое простое решение ??

с ES6 +

используйте логическое НЕ дважды [!! ], чтобы преобразовать строку

Просто вставьте это выражение ...

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