Как я могу преобразовать строку в логическое значение в JavaScript?

1881

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

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

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

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

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

  • 0
    Просто чтобы подчеркнуть странный пример избежания тройного сравнения: у меня есть функция currentSortDirection() которая возвращает 1 для сортировки по возрастанию, 0 для сортировки по убыванию и -1 для currentSortDirection() . Использование while (currentSortDirection() != desiredSortDirection) { sortColumn() } прекрасно работает, поскольку -1 != true и -1 != false while (Boolean(currentSortDirection) !== ...) {...} ... но меняя его на while (Boolean(currentSortDirection) !== ...) {...} вводит -1 в true , требуя дополнительных нескольких строк подготовки, просто чтобы сделать jshint счастливым.
  • 0
    Возможный дубликат stackoverflow.com/questions/263965
Показать ещё 7 комментариев
Теги:

70 ответов

2397
Лучший ответ

Делать:

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

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

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

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

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

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

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

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

  • 166
    myValue === 'true'; точно эквивалентно myValue == 'true'; , Там нет никакой пользы в использовании === над == здесь.
  • 474
    Я следую совету Крокфорда и использую === и !== всякий раз, когда это имеет смысл, что почти всегда.
Показать ещё 36 комментариев
527

Внимание!

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

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


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

Как насчет?

JSON.parse("true");

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

$.parseJSON("true");
  • 55
    Проблема в том, что многие потенциальные значения генерируют ошибку разбора, которая останавливает выполнение JS. Итак, запуск JSON.parse («ЛОЖЬ») бомбит Javascript. Суть вопроса, я думаю, заключается не в том, чтобы просто решить эти конкретные случаи, а в том, чтобы быть устойчивым к другим случаям.
  • 1
    Отличный момент BishopZ. Я проголосовал за ваше решение с помощью регулярного выражения: /^true$/i.test( myValue )
Показать ещё 9 комментариев
179
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);
    }
}
  • 40
    На самом деле это может быть упрощено. 1) Нет необходимости проверять "true" , "yes" и "1" . 2) toLowerCase не возвращает null . 3) Boolean(string) здесь то же самое, что и string!=="" . => switch(string.toLowerCase()) {case "false": case "no": case "0": case "": return false; default: return true;}
  • 11
    @ Роберт, хороший, но я бы предпочел вместо этого значение по умолчанию false .
Показать ещё 8 комментариев
122

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

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

Он идет:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false
  • 18
    Когда вы можете получить строку в верхнем регистре или логическое значение, тогда String(a).toLowerCase() === 'true'
  • 0
    String("what about input like this that isn't a bool?") == "true"
Показать ещё 7 комментариев
109

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

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

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

var isTrueSet = document.myForm.IS_TRUE.checked;

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

  • 2
    Это вызовет исключение, если myValue окажется null , true или каким-либо другим типом ...
100

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

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

  • 27
    Не очень хорошая идея модифицировать прототип встроенных объектов!
  • 10
    Вы всегда можете добавить префикс функции, если вы боитесь, что она помешает другому коду. Если какой-то код все еще ломается, этот код слишком хрупок и должен быть исправлен. Если ваша добавленная функция делает объект слишком тяжелым, если это вызывает проблемы с производительностью для другого кода, тогда, очевидно, вы не хотите этого делать. Но я не думаю, что вообще плохая идея расширять встроенные объекты. Они также не были бы общедоступными, если бы это было так.
Показать ещё 9 комментариев
40

Древесные глаза должны быть осторожны. После просмотра последствий после применения верхнего ответа с 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]));}
  • 0
    Просто помните, что старым браузерам может понадобиться полифил JSON, если вы используете первый метод.
  • 1
    Насколько быстро приводить "ложную" строку к false логическому значению с помощью JSON.parse ? С точки зрения процессора, производительность памяти
Показать ещё 1 комментарий
28

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

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

  • 17
    Почему вы думаете, что было бы глупо использовать === ? С точки зрения производительности было бы точно так же, если оба типа являются строками. В любом случае, я скорее использую === так как я всегда избегаю использования == и != . Обоснования: stackoverflow.com/questions/359494/…
  • 3
    Поскольку value всегда будет string ни == ни === являются глупыми. Оба являются правильным инструментом для этой работы. Они отличаются только тогда, когда типы не равны. В этом случае === просто возвращает false то время как == выполняет алгоритм приведения сложного типа перед сравнением.
24

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

  • 0
    Я использую этот, поскольку он охватывает вещи, которые вы получаете из атрибутов XML / HTML ElementNodes, таких как autocomplete autocomplete="on"
  • 2
    Я бы добавил .trim () перед toLowerCase ()
24

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

  • 1
    Версия без JSON имеет некоторые недостатки: val = "0"; console.log (!! (+ val || String (val) .toLowerCase (). replace (!! 0, ''))); производит правду
  • 0
    Хорошо спасибо. Я отремонтировал его и создал скрипку jsfiddle.net/remunda/2GRhG
Показать ещё 2 комментария
22
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());
17

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

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

  • 8
    eval () представляет риск для безопасности и выполнения вредоносного кода. Не.
  • 0
    Чтобы понять, что является «неправильным» (или правильным) в eval, ознакомьтесь со статьями, такими как javascriptweblog.wordpress.com/2010/04/19/how-evil-is-eval, или выполните поиск по стеку для поиска «Javascript eval malware»
Показать ещё 4 комментария
15

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

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

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

13
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.");
  }
};
  • 1
    Вы можете использовать true.toString () вместо «true», чтобы быть еще более чистым :-)
  • 0
    Не меняйте глобальные переменные, старайтесь держать ваши изменения изолированными, возможно, вместо этого создайте новую function parseBoolean
12

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

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

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

  • 0
    "что-то пошло не так" при попытке просмотреть тест jsPerf
11

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

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

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

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

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

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

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

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"
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"
  • 0
    Это хорошо, но работает только со строковым типом. Представьте, что это нужно использовать переменной, которая может быть "true" или true . Если придет второй, это не будет работать. Можно ли сделать document.prototype чтобы использовать это там, где мы хотим?
  • 0
    Это выглядит элегантно. Прекрасная работа! Однако я заметил, что перегрузка базовых прототипов в больших JS-приложениях (которые также требуют модульного тестирования) может привести к некоторому неожиданному поведению (а именно, когда вы захотите выполнить итерацию с помощью for для массива с перегруженным прототипом, вы получите некоторые свойства, которые вы обычно не ожидаете). Вы были предупреждены. ;)
Показать ещё 1 комментарий
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

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

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

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

  • 3
    О каком обращении вы говорили? :-)
  • 1
    При сравнении строк в JavaScript нет разницы между использованием операторов == или ===, когда не используются преобразования. Здесь вы сравниваете со строками, поэтому нет преобразования типов. См. Stackoverflow.com/questions/359494/…
7

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

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

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

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

  • 0
    Если вернуться к вашим целям, единственная проблема вашего третьего и лучшего решения состоит в том, что оно не соответствует Цели # 1 - оно вернет true только для значения 'true' , но не для любого достоверного ввода. Для того, чтобы оно соответствовало Задаче № 1, оно лишь немногим более кратко, чем Решение № 2, и гораздо менее читабельно.
  • 0
    return /^(true|yes|1|t|y)$/i.test(str);
6

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

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

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

5

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

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

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

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

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

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

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

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

5
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;
}
  • 0
    Для строки я лично вернул бы true для «true», как вы, но false для «false», а в противном случае undefined бы. Вроде того, что вы ранее сделали с целочисленным регистром.
4

Один вкладыш

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

function b(v){ return v==="false" ? false : !!v; }

Test

b(true)    //true
b('true')  //true
b(false)   //false
b('false') //false

Более exaustive версия

function bool(v){ return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v; }

Test

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
4

Я обнаружил, что использование "1" и пустого значения "для логических значений работает гораздо более предсказуемо, чем" истинные "или" ложные" строковые значения... в частности, с форматами html, поскольку значения uninitialized/empty в элементах 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>

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

3

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

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/

3

Я делаю это, которое будет обрабатывать 1 = TRUE = yes = YES = true, 0 = FALSE = no = NO = false:

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

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

Если это не null, числовое значение или одна из следующих строк: "true", "TRUE", "false", "FALSE", "yes", "YES", "no", "NO" Это вызовет ошибку (намеренно.)

  • 0
    JSON.parse может обрабатывать «true» и «false» для логических значений, поэтому вам не нужно переносить их в Boolean() .
  • 0
    Хороший звонок. Обновлено.
3

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

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

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

это само по себе не получит 1/0 или yes/no, но он поймает TRUE/true, а также вернет false для любой строки, которая имеет "true" в качестве подстроки.

ИЗМЕНИТЬ

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

​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.log('"' + 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
  • 0
    Как написано (19 декабря 2018 года в 16:00 Z), /^(false|0|no)*$/i будет соответствовать пустой строке (которая может быть намерением), но также будет соответствовать любому числу false , 0 или no Например, "0falseno0nofalse0" также будет иметь значение false но должно принимать значение null и выводить консольное сообщение о том, что оно не является логическим значением.
2

вы можете использовать:

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

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

2

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

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

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

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

var booleanVal = toCast > '';

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

var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';  
2
function isTrue(val) {
    try {
        return !!JSON.parse(val);
    } catch (e) {
        return false;
    }
}
2

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

Вот что я просто взбивал:

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

... и unit test для него

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

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

val = 'false';

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

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

/**
 * @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);
};
2
if (String(a) == "true"){
  //true block
} else {
  //false block
}
1

Вот простая функция, которая сделает трюк,

   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
1

Успокойтесь с помощью этой библиотеки.

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

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

const ForceBoolean = require('force-boolean')

const YOUR_VAR = 'false'
console.log(ForceBoolean(YOUR_VAR)) // it 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
1

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

Решение:

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

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

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

Поскольку логические выражения оцениваются слева направо, они проверяются на возможную оценку "короткого замыкания", используя следующие правила:

  • false && & (что-либо) - это короткое замыкание, которое вычисляется как false.
  • true || (что-либо) имеет короткое замыкание, рассчитанное на значение true.

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

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

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

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

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

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

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

1

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

function asBoolean(value) {

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

}


// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> false
1

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

  • 3
    Если вы хотите коротко, почему бы не написать просто var isTrueSet = myValue === "true"; ?
1
    MyLib.Convert.bool = function(param) {
         var res = String(param).toLowerCase();
         return !(!Boolean(res) || res === "false" || res === "0");
     }; 
1

Вам даже не нужно преобразовывать строку в boolean. просто используйте следующее: var yourstring = yourstringValue == 1 ? true : false;

1

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

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

Я использовал этот фрагмент для преобразования Numbers и Booleans:

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

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

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

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

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

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

0

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

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

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

toBoolean('false') // returns false
  • 2
    Таким образом, это вернуло бы истину для «Ложь», не так ли?
0

Вы можете использовать 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.log(T, typeof T); // `true` `"boolean"`

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

Преобразование String в Boolean

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

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

var vIn = 0;
var vOut = parseInt(vIn,10/*base*/);
0
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. Все остальное ложно. Конечно, вам может потребоваться нормализовать входную строку, чтобы сделать ее более строчной и обрезать любые пробелы.

0
Boolean(Number(value));
var value = 1;  //true
var value = "1" //true
var value = 0;  //false
var value = "0" //false`
  • 3
    var value = "true"; // ложь
0

Получить логические значения из строки или числа. Это хорошее решение:

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

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

Сначала вернется false, а вторая вернет true.

0

Достаточно было бы

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

"true".boolean() // returns true "false".boolean() // returns false
  • 10
    Модификация прототипа - очень плохая идея
  • 0
    @ SzymonWygnański: я не согласен. Я не вижу никакой другой причины, кроме петли for-in и встроенной поддержки той же функциональности браузерами. Reg for-inloop: я не могу вспомнить случай, когда циклы for-in действительно нужны в строке. Регулярная поддержка: мы можем определенно добавить протопроп до тех пор, пока не поддерживаются нативные браузеры, если мы не создаем фреймворк, такой как - prototype или jquery и т. Д. Подробнее об этом @Kangax (Perfection kills) здесь. webcache.googleusercontent.com/...
Показать ещё 1 комментарий
-3

Самый простой метод может быть методом eval.

var a = "0";
a = eval(a);

Эта строка кода преобразует логическое значение;

-4

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

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);
}
  • 1
    Не работает для "ложных"
  • 0
    мой плохой, я исправил вышеупомянутый фрагмент - работает сейчас. не уверен, как эти кавычки "" попали туда! ; / @HugoZapata
Показать ещё 4 комментария
-20

Просто выполните:

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

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

  • 11
    -1: Пожалуйста, не защищайте использование eval (за исключением, возможно, умных хаков и необходимости).
  • 0
    это действительно плохое и небезопасное использование eval. и это даже не умно. -1
Показать ещё 1 комментарий
-20
 var myBool = Boolean.parse("true");

или

var myBool = Boolean("true");

или

var myBool = !!"true";

Не уверен, что первый из них специфичен для IE.

  • 11
    Вот что происходит с использованием Boolean («true»). Это немного вводит в заблуждение, потому что Boolean («false») и Boolean («wtf») также оценивают как true. Ваш третий ответ очень похож на мой.
  • 0
    @FlySwat: я знаю, что это старый ответ, но он все еще отображается в верхних результатах поиска, так что другие пользователи увидят его. Третий пример, который использует !! также ненадежен. !!"true"; вернет true но так и будет !!"false"; и !!"abc"; , Когда JavaScript обрабатывает строку с 'true' или 'false' он не различает эти значения. Он просто видит их как строки со значением. Поэтому с помощью ! оператор в строке !'anyValue' и даже !' ' всегда будет false и только !'' будет true .

Ещё вопросы

Сообщество Overcoder
Наверх
Меню