Как я могу преобразовать строку в логическое значение в JavaScript?
Могу ли я преобразовать строку, представляющую логическое значение (например, 'true', 'false') во внутренний тип в JavaScript?
У меня есть скрытая форма в HTML, которая обновляется на основе выбора пользователя в списке. Эта форма содержит некоторые поля, которые представляют логические значения и динамически заполняются внутренним логическим значением. Однако, как только это значение помещается в скрытое поле ввода, оно становится строкой.
Единственный способ определить логическое значение поля после его преобразования в строку - это зависеть от литерального значения его строкового представления.
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
Есть ли лучший способ сделать это?
107 ответов
Делать:
var isTrueSet = (myValue == 'true');
Вы можете сделать его более строгим, используя оператор идентификации (===), который не делает никаких неявных преобразований типов, когда сравниваемые переменные имеют разные типы, вместо оператора равенства (==).
var isTrueSet = (myValue === 'true');
Не рекомендуется:
Вы, вероятно, должны быть осторожны при использовании этих двух методов для ваших конкретных потребностей:
var myBool = Boolean("false"); // == true
var myBool = !!"false"; // == true
Любая строка, которая не является пустой строкой, оценивается как true используя их. Хотя это самые чистые методы, которые я могу придумать в отношении логического преобразования, я думаю, что они не то, что вы ищете.
Предупреждение
Этот устаревший ответ с большим количеством голосов является технически правильным, но охватывает только очень специфический сценарий, когда строковое значение ТОЧНО "true" или же "false" (ДОЛЖЕН быть также в нижнем регистре).
Недопустимая строка json, переданная в эти функции ниже, БУДЕТ генерировать исключение.
Оригинальный ответ:
Как насчет?
JSON.parse("true");
или с помощью jQuery
$.parseJSON("true");
stringToBoolean: function(string){
switch(string.toLowerCase().trim()){
case "true": case "yes": case "1": return true;
case "false": case "no": case "0": case null: return false;
default: return Boolean(string);
}
}
Я думаю, что это очень универсально:
if (String(a) == "true")...
Идет:
String(true) == "true" //returns true
String(false) == "true" //returns false
String("true") == "true" //returns true
String("false") == "true" //returns false
Не забудьте сопоставить регистр:
var isTrueSet = (myValue.toLowerCase() === 'true');
Кроме того, если это флажок элемента формы, вы также можете определить, установлен ли флажок:
var isTrueSet = document.myForm.IS_TRUE.checked;
Предполагая, что, если это проверено, это "установлено" равным true. Это оценивается как истина / ложь.
Это самый простой способ логического преобразования, с которым я столкнулся недавно. Думал добавить.
JSON.parse('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/
Ваше решение в порядке.
С помощью === would just be silly in this case, as the field's value всегда будет String,
У логического объекта нет метода parse. Boolean('false') возвращает true, так что это не сработает. !!'false' также возвращает true, так что это тоже не сработает.
Если вы хотите строку 'true' вернуть логическое значение true и строка 'false' вернуть логическое значение falseто самое простое решение - использовать eval(), eval('true') возвращает истину и eval('false') возвращает ложь Помните о влиянии на производительность при использовании eval() хоть.
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());
Есть много ответов, и трудно выбрать один. В моем случае при выборе приоритетов я выбираю производительность, поэтому я создаю этот jsPerf, который, я надеюсь, сможет пролить немного света здесь.
Краткое описание результатов (чем выше, тем лучше):
- Условное заявление: 2 826 922
- Корпус переключателя на объекте Bool: 2 825 469
- Кастинг в JSON: 1,867,774
- !! конверсии: 805,322
- Прототип строки: 713 637
Они связаны с соответствующим ответом, где вы можете найти больше информации (плюсы и минусы) о каждом; особенно в комментариях.
Это было взято из принятого ответа, но на самом деле у него есть очень слабое место, и я шокирован тем, как он получил это количество голосов, проблема с ним в том, что вы должны рассмотреть случай строки, потому что она чувствительна к регистру
var isTrueSet = (myValue.toLowerCase() === 'true');
Самое простое решение 🙌🏽
с 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
Я использую следующее:
function parseBool(b) {
return !(/^(false|0)$/i).test(b) && !!b;
}
Эта функция выполняет обычное логическое приведение, за исключением строк "false" (без учета регистра) и "0".
Выражение, которое вы ищете, просто
/^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
Ты можешь использовать:
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
alert('this is ture');
else
('this is false');в этом случае.toLowerCase важен
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.");
}
};
Уже есть так много доступных ответов. Но в некоторых случаях может быть полезно следующее.
// 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
Я удивлен, что
includes не было предложено
let bool = "false"
bool = !["false", "0", 0].includes(bool)
Вы можете изменить проверку на истинность или включить дополнительные условия (например,
null,
'').
Чтобы преобразовать как строку ("истина", "ложь"), так и логическое значение в логическое значение
('' + flag) === "true"
куда flag может быть
var flag = true
var flag = "true"
var flag = false
var flag = "false"
Эта функция может обрабатывать как строки, так и логические значения 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)));Один лайнер
Нам просто нужно учесть "ложную" строку, так как любая другая строка (включая "истину") уже 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
Почему бы тебе не попробовать что-то подобное
Boolean(JSON.parse((yourString.toString()).toLowerCase()));
Он вернет ошибку, когда задан какой-то другой текст, а не истина или ложь, независимо от регистра, и будет также записывать числа в виде
// 0-> false
// any other number -> true
Я использую этот
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"
Другое решение. 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, где им нужно перейти от строковых сторожей к нативному типу, и проведите там сравнение, предпочтительно, когда это делается только один раз для каждого значения, которое необходимо преобразовать. Не забудьте указать, что должно произойти, если строка sentinel не та, которую знает сценарий (т. Е. Используется ли по умолчанию значение true или false?)
Другими словами, да, вам нужно зависеть от значения строки.:-)
Руки вниз самым простым способом (при условии, что ваша строка будет 'true' или 'false') это:
var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false
Всегда используйте оператор === вместо оператора == для этих типов преобразований!