Как преобразовать строку в boolean в JavaScript?

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

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

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

var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';

Есть ли лучший способ сделать это?

+2288
источник поделиться
76 ответов
  • 1
  • 2
  • 3

Делать:

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

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

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

Не рекомендуется:

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

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

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

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

+3094
источник

Внимание!

Этот высокоприоритетный унаследованный ответ технически корректен, но охватывает только очень специфический сценарий, когда ваше строковое значение ТОЧНО "true" или "false" (ДОЛЖНО также быть строчным).

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


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

Как насчет?

JSON.parse("true");

или с помощью jQuery

$.parseJSON("true");
+635
источник
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);
    }
}
+208
источник

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

if (String(a) == "true")...

Он идет:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false
+162
источник

Не забудьте указать случай:

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

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

var isTrueSet = document.myForm.IS_TRUE.checked;

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

+122
источник

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

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

+113
источник

Древесные глаза должны быть осторожны. После просмотра последствий после применения верхнего ответа с 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]));}
+46
источник

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

+33
источник

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

+31
источник

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

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

+30
источник
var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

Это возвращает false для каждого значения falsy и 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());
+21
источник

Объект Boolean не имеет метода "parse". Boolean('false') возвращает true, так что это не сработает. !!'false' также возвращает true, поэтому это тоже не сработает.

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

+18
источник

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

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

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

+15
источник

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

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

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

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

+15
источник
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.");
  }
};
+13
источник

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

/^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
+13
источник

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

var isTrueSet = (myValue.toLowerCase() === 'true');
+12
источник

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

// 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
+11
источник

Для преобразования обеих строк ( "true", "false" ) и boolean в boolean

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

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

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"
+10
источник

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

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

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

// 0-> false
// any other number -> true
+9
источник

Эта функция может обрабатывать строку, а также Boolean 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)));
+9
источник

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

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

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

+8
источник

Как и @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;
  }
}
+8
источник

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

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"
+8
источник

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

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

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

+7
источник

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

  • Возвращает true/false для правды и значений 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 как значение по умолчанию, а не undefined или бросает ошибку, которая более полезна при разработке Javascript в слабо типизированной форме. Браво к другим ответам, которые это предложили!

+7
источник

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

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

тестовые примеры выполняются в node

> 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
> 
+7
источник
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;
}
+5
источник

Я написал функцию для соответствия 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;
};
+5
источник
  • 1
  • 2
  • 3

Посмотрите другие вопросы по метке или Задайте вопрос