Могу ли я преобразовать строку, представляющую логическое значение (например, 'true', 'false') во внутренний тип в JavaScript?

У меня есть скрытая форма в 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;

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

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

/*
 * Converts a string to a bool.
 *
 * This conversion will:
 *
 *  - match 'true', 'on', or '1' as true.
 *  - ignore all white-space padding
 *  - ignore capitalization (case).
 *
 * '  tRue  ','ON', and '1   ' will all evaluate as true.
 *
 */
function strToBool(s)
{
    // will match one and only one of the string 'true','1', or 'on' rerardless
    // of capitalization and regardless off surrounding white-space.
    //
    regex=/^\s*(true|1|on)\s*$/i

    return regex.test(s);
}

Если вам нравится расширять класс String, вы можете сделать:

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

alert("true".bool());

Для тех (см. Комментарии), которые хотели бы расширить объект String, чтобы получить это, но беспокоятся о перечисляемости и беспокоятся о конфликте с другим кодом, который расширяет объект String:

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

(Конечно, не будет работать в старых браузерах, и Firefox показывает false, в то время как Opera, Chrome, Safari и IE показывают true. Ошибка 720760 )

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

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

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

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

var parseBool = function(str) 
{
    // console.log(typeof str);
    // strict: JSON.parse(str)

    if(str == null)
        return false;

    if (typeof str === 'boolean')
    {
        return (str === true);
    } 

    if(typeof str === 'string')
    {
        if(str == "")
            return false;

        str = str.replace(/^\s+|\s+$/g, '');
        if(str.toLowerCase() == 'true' || str.toLowerCase() == 'yes')
            return true;

        str = str.replace(/,/g, '.');
        str = str.replace(/^\s*\-\s*/g, '-');
    }

    // var isNum = string.match(/^[0-9]+$/) != null;
    // var isNum = /^\d+$/.test(str);
    if(!isNaN(str))
        return (parseFloat(str) != 0);

    return false;
}

Тестирование:

var array_1 = new Array(true, 1, "1",-1, "-1", " - 1", "true", "TrUe", "  true  ", "  TrUe", 1/0, "1.5", "1,5", 1.5, 5, -3, -0.1, 0.1, " - 0.1", Infinity, "Infinity", -Infinity, "-Infinity"," - Infinity", " yEs");

var array_2 = new Array(null, "", false, "false", "   false   ", " f alse", "FaLsE", 0, "00", "1/0", 0.0, "0.0", "0,0", "100a", "1 00", " 0 ", 0.0, "0.0", -0.0, "-0.0", " -1a ", "abc");


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

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

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

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

function isTrue(value){
    if (typeof(value) === 'string'){
        value = value.trim().toLowerCase();
    }
    switch(value){
        case true:
        case "true":
        case 1:
        case "1":
        case "on":
        case "yes":
            return true;
        default: 
            return false;
    }
}

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

Универсальное решение с анализом JSON:

function getBool(val) {
    return !!JSON.parse(String(val).toLowerCase());
}

getBool("1"); //true
getBool("0"); //false
getBool("true"); //true
getBool("false"); //false
getBool("TRUE"); //true
getBool("FALSE"); //false

ОБНОВЛЕНИЕ (без JSON):

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

Я также создал скрипку, чтобы проверить ее http://jsfiddle.net/remunda/2GRhG/

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

Использование ===в этом случае будет просто глупым, так как поле valueвсегда будет 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());

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

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

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

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

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

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

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

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

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

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

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

Boolean.parse = function (str) {
  switch (str.toLowerCase ()) {
    case "true":
      return true;
    case "false":
      return false;
    default:
      throw new Error ("Boolean.parse: Cannot convert string to boolean.");
  }
};

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

/^true$/i.test(myValue)

как в

var isTrueSet = /^true$/i.test(myValue);

Это проверяет myValueрегулярное выражение без учета регистра и не изменяет прототип.

Примеры:

/^true$/i.test("true"); // true
/^true$/i.test("TRUE"); // true
/^true$/i.test("tRuE"); // true
/^true$/i.test(" tRuE"); // false (notice the space at the beginning)
/^true$/i.test("untrue"); // false (some other solutions here will incorrectly return true
/^true$/i.test("false");// returns false
/^true$/i.test("xyz");  // returns false

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

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

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

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

Эта функция может обрабатывать как строки, так и логические значения true / false.

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

Демонстрация ниже:

function stringToBoolean(val) {
  var a = {
    'true': true,
    'false': false
  };
  return a[val];
}

console.log(stringToBoolean("true"));

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

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

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

console.log(stringToBoolean(true));

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

console.log(stringToBoolean(false));

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

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

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

String.prototype.maybeBool = function(){

    if ( ["yes", "true", "1", "on"].indexOf( this.toLowerCase() ) !== -1 ) return true;
    if ( ["no", "false", "0", "off"].indexOf( this.toLowerCase() ) !== -1 ) return false;

    return this;

}

"on".maybeBool(); //returns true;
"off".maybeBool(); //returns false;
"I like js".maybeBool(); //returns "I like js"

Руки вниз самым простым способом (при условии, что ваша строка будет 'true' или 'false') это:

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

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

Как сказал @ Shadow2531, вы не можете просто конвертировать его напрямую. Я бы также предложил, чтобы вы рассматривали строковые входы помимо «true» и «false», которые являются «truey» и «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;
  }
}

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

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

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

Мой взгляд на этот вопрос заключается в том, что он направлен на достижение трех целей:

• Вернуть true / false для значений truey и falsey, но также вернуть 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 / нечисто -ness , но включает в себя "false"как acceptible значение для ложных.

Я предпочитаю этот метод упомянутым, потому что он не полагается на стороннюю программу для анализа кода (то есть: 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
> 

Боже мой, некоторые из этих ответов просто дикие. Я люблю JS и его бесконечное количество способов снять шкуру.

Мое предпочтение, которое я был потрясен, чтобы не видеть, уже:

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