JavaScript: Parsing a string Boolean value? [duplicate]

Question

This question already has answers here:

How can I convert a string to boolean in JavaScript? (111 answers)

Closed 7 years ago.

JavaScript has parseInt() and parseFloat(), but there's no parseBool or parseBoolean method in the global scope, as far as I'm aware.

I need a method that takes strings with values like "true" or "false" and returns a JavaScript Boolean.

Here's my implementation:

function parseBool(value) {
 return (typeof value === "undefined") ? 
 false : 
 // trim using jQuery.trim()'s source 
 value.replace(/^\s+|\s+$/g, "").toLowerCase() === "true";
}

Is this a good function? Please give me your feedback.

Thanks!

• peirix: and you can also post your code on codereview.stackexchange.com if you're only looking for code reviews...
• Alex Pacurar: see stackoverflow.com/questions/263965/…

Answer 1

I would be inclined to do a one liner with a ternary if.

var bool_value = value == "true" ? true : false

Edit: Even quicker would be to simply avoid using the a logical statement and instead just use the expression itself:

var bool_value = value == 'true';

This works because value == 'true' is evaluated based on whether the value variable is a string of 'true'. If it is, that whole expression becomes true and if not, it becomes false, then that result gets assigned to bool_value after evaluation.

• Jakob: Why not shorten it a bit further? var bool_value = value == "true" does the same thing :)
• parsifal: A ternary expression could be useful here, to handle the case where you're passed null/undefined/empty: bool_value = value ? (value.toLowerCase() == "true") : false
• Ifch0o1: Shorter way: var bool = !!value
• Michael Lang: @Ifch0o1 I wouldn't use var bool = !!value. The string containing "false" is a truthy value so !!'false' === true
• Michael Lang: I typically expect that when someone says they want to "parse a string into a boolean" they mean that they want to map the string "false" to the boolean value false. However in javascript, !!'false' yields the boolean value true. If you don't believe me, open the javascript console in your favorite browser or a nodeJS repl and try it yourself. If the original poster is ok with this "parsing" taking "false" to true then I suppose !! is just fine, but that's certainly not the behavior I'd expect from a parser.

Answer 2

You can use JSON.parse for that:

JSON.parse("true"); //returns boolean true

• AndrewL: Doesn't handle mixed case JSON.parse("True") or non-JSON syntax e.g. JSON.parse("x")
• johnny peter: This needs to be the accepted answer
• Jacques: @AndrewL you could potentially do JSON.parse("True".toLowerCase()) replacing "True" with your variable

Answer 3

It depends how you wish the function to work.

If all you wish to do is test for the word 'true' inside the string, and define any string (or nonstring) that doesn't have it as false, the easiest way is probably this:

function parseBoolean(str) {
 return /true/i.test(str);
}

If you wish to assure that the entire string is the word true you could do this:

function parseBoolean(str) {
 return /^true$/i.test(str);
}

• The Muffin Man: The way this natively works is absolutely stupid. The Boolean function should do the latter of your examples. If one needs to see if a string contains the word true or false then you should check if the index is > 0.
• Soviut: This has a huge amount of overhead matching with regex, instead of simply checking if the string contains 'true' or not.
• Martin Jespersen: @Soviut: quite right, RGBs solution is much prfered

Answer 4

You can try the following:

function parseBool(val)
{
 if ((typeof val === 'string' && (val.toLowerCase() === 'true' || val.toLowerCase() === 'yes')) || val === 1)
 return true;
 else if ((typeof val === 'string' && (val.toLowerCase() === 'false' || val.toLowerCase() === 'no')) || val === 0)
 return false;
 return null;
}

If it's a valid value, it returns the equivalent bool value otherwise it returns null.

• delliottg: This almost worked, I tweaked it a bit to get it to work properly (single quotes around 'string'): function parseBool(val) { if ((typeof val == 'string' && (val.toLowerCase() === 'true' || val.toLowerCase() === 'yes')) || val === 1) return true; else if ((typeof val === 'string' && (val.toLowerCase() === 'false' || val.toLowerCase() === 'no')) || val === 0) return false; return null; }
• Paul Fleming: @delliottg Updated with quotes on string.

Answer 5

You can use JSON.parse or jQuery.parseJSON and see if it returns true using something like this:

function test (input) {
 try {
 return !!$.parseJSON(input.toLowerCase());
 } catch (e) { }
}

• RoToRa: Looks a bit dangerous to me. For example, test("\"false\"") will return true for being a non-empty string. It's unlikely, but a very unobvious source for bugs.
• PleaseStand: If the input is invalid JSON, this function will return undefined.
• RoToRa: @idealmaschine: Which seems to be a Good Thing to me. Is that what you wanted to say, or was that a criticism?
• rsp: @RoToRa: Good point. But not knowing the data it's hard to know if "\"false\"" should be true or false – and what about "\"not true\"" or "\"no\"" or "yes"? One possibility would be to return undefined for everything other than explicit true or false, or use the usual JavaScript or JSON semantics, or use some custom logic that is suitable for a given application. It's hard to make a universal solution if it is even hard to find two programming languages that would agree on what is true and what is false.
• rsp: @idealmaschine: You can add return false; in the catch block if you want to get false for invalid JSON, but keep in mind that undefined is also falsy in JavaScript so it may not really matter, depending on how you use it.

Answer 6

last but not least, a simple and efficient way to do it with a default value :

ES5

function parseBool(value, defaultValue) {
 return (value == 'true' || value == 'false' || value === true || value === false) && JSON.parse(value) || defaultValue;
}

ES6 , a shorter one liner

const parseBool = (value, defaultValue) => ['true', 'false', true, false].includes(value) && JSON.parse(value) || defaultValue

JSON.parse is efficient to parse booleans

Answer 7

Personally I think it's not good, that your function "hides" invalid values as false and - depending on your use cases - doesn't return true for "1".

Another problem could be that it barfs on anything that's not a string.

I would use something like this:

function parseBool(value) {
 if (typeof value === "string") {
 value = value.replace(/^\s+|\s+$/g, "").toLowerCase();
 if (value === "true" || value === "false")
 return value === "true";
 }
 return; // returns undefined
}

And depending on the use cases extend it to distinguish between "0" and "1".

(Maybe there is a way to compare only once against "true", but I couldn't think of something right now.)

• Metagrapher: Sorry to dredge up really old code, but why not just return true;? why return value === "true";? I mean, you already checked if it's valid, right?
• RoToRa: @Metagrapher If I just return true, it will return true, if the value is "false", too.
• Metagrapher: I don't know what was wrong with me when I read that code. Sorry. haha thanks for the clarity.

Answer 8

Why not keep it simple?

var parseBool = function(str) {
 if (typeof str === 'string' && str.toLowerCase() == 'true')
 return true;
 return (parseInt(str) > 0);
}

Answer 9

You can add this code:

function parseBool(str) {
 
 if (str.length == null) {
 return str == 1;
 } else {
 return str == "true";
 }
 
}

Works like this:

parseBool(1) //true
parseBool(0) //false
parseBool("true") //true
parseBool("false") //false

• Hexodus: I see ternarys used a lot like this but they aren't needed. You can just do return (str === 1)

Answer 10

Wood-eye be careful. After looking at all this code, I feel obligated to post:

Let's start with the shortest, but very strict way:

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

And end with a proper, more tolerant way:

var parseBool = function(str) 
{
 // console.log(typeof str);
 // strict: JSON.parse(str)
 if(str == null)
 return false;
 if (typeof str === 'boolean')
 {
 if(str === true)
 return true;
 return false;
 } 
 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;
}

Testing:

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

Answer 11

I like the solution provided by RoToRa (try to parse given value, if it has any boolean meaning, otherwise - don't). Nevertheless I'd like to provide small modification, to have it working more or less like Boolean.TryParse in C#, which supports out params. In JavaScript it can be implemented in the following manner:

var BoolHelpers = {
 tryParse: function (value) {
 if (typeof value == 'boolean' || value instanceof Boolean)
 return value;
 if (typeof value == 'string' || value instanceof String) {
 value = value.trim().toLowerCase();
 if (value === 'true' || value === 'false')
 return value === 'true';
 }
 return { error: true, msg: 'Parsing error. Given value has no boolean meaning.' }
 }
}

The usage:

var result = BoolHelpers.tryParse("false");
if (result.error) alert(result.msg);

Answer 12

I shamelessly converted Apache Common's toBoolean to JavaScript:

JSFiddle: https://jsfiddle.net/m2efvxLm/1/

Code:

function toBoolean(str) {
 if (str == "true") {
 return true;
 }
 if (!str) {
 return false;
 }
 switch (str.length) {
 case 1: {
 var ch0 = str.charAt(0);
 if (ch0 == 'y' || ch0 == 'Y' ||
 ch0 == 't' || ch0 == 'T' ||
 ch0 == '1') {
 return true;
 }
 if (ch0 == 'n' || ch0 == 'N' ||
 ch0 == 'f' || ch0 == 'F' ||
 ch0 == '0') {
 return false;
 }
 break;
 }
 case 2: {
 var ch0 = str.charAt(0);
 var ch1 = str.charAt(1);
 if ((ch0 == 'o' || ch0 == 'O') &&
 (ch1 == 'n' || ch1 == 'N') ) {
 return true;
 }
 if ((ch0 == 'n' || ch0 == 'N') &&
 (ch1 == 'o' || ch1 == 'O') ) {
 return false;
 }
 break;
 }
 case 3: {
 var ch0 = str.charAt(0);
 var ch1 = str.charAt(1);
 var ch2 = str.charAt(2);
 if ((ch0 == 'y' || ch0 == 'Y') &&
 (ch1 == 'e' || ch1 == 'E') &&
 (ch2 == 's' || ch2 == 'S') ) {
 return true;
 }
 if ((ch0 == 'o' || ch0 == 'O') &&
 (ch1 == 'f' || ch1 == 'F') &&
 (ch2 == 'f' || ch2 == 'F') ) {
 return false;
 }
 break;
 }
 case 4: {
 var ch0 = str.charAt(0);
 var ch1 = str.charAt(1);
 var ch2 = str.charAt(2);
 var ch3 = str.charAt(3);
 if ((ch0 == 't' || ch0 == 'T') &&
 (ch1 == 'r' || ch1 == 'R') &&
 (ch2 == 'u' || ch2 == 'U') &&
 (ch3 == 'e' || ch3 == 'E') ) {
 return true;
 }
 break;
 }
 case 5: {
 var ch0 = str.charAt(0);
 var ch1 = str.charAt(1);
 var ch2 = str.charAt(2);
 var ch3 = str.charAt(3);
 var ch4 = str.charAt(4);
 if ((ch0 == 'f' || ch0 == 'F') &&
 (ch1 == 'a' || ch1 == 'A') &&
 (ch2 == 'l' || ch2 == 'L') &&
 (ch3 == 's' || ch3 == 'S') &&
 (ch4 == 'e' || ch4 == 'E') ) {
 return false;
 }
 break;
 }
 default:
 break;
 }
 return false;
}
console.log(toBoolean("yEs")); // true
console.log(toBoolean("yES")); // true
console.log(toBoolean("no")); // false
console.log(toBoolean("NO")); // false
console.log(toBoolean("on")); // true
console.log(toBoolean("oFf")); // false

Inspect this element, and view the console output.

• Nicholas Hamilton: Seems absurd to me why they wouldn't include a case for: typeof === 'boolean', in case someone literally passes true or false.
• Xaero Degreaz: There's no need, as Java is a strongly-typed language.
• laszlo: @XaeroDegreaz it's JavaScript, not Java. Aside from that, this example looks absurdly verbose and unnecessary

Answer 13

stringjs has a toBoolean() method:

https://www.npmjs.com/package/string#--toboolean--tobool

S('true').toBoolean() //true
S('false').toBoolean() //false
S('hello').toBoolean() //false
S(true).toBoolean() //true
S('on').toBoolean() //true
S('yes').toBoolean() //true
S('TRUE').toBoolean() //true
S('TrUe').toBoolean() //true
S('YES').toBoolean() //true
S('ON').toBoolean() //true
S('').toBoolean() //false
S(undefined).toBoolean() //false
S('undefined').toBoolean() //false
S(null).toBoolean() //false
S(false).toBoolean() //false
S({}).toBoolean() //false
S(1).toBoolean() //true
S(-1).toBoolean() //false
S(0).toBoolean() //false

• FF_Dev: The link leads to the landing page of a chinese web agency
• prule: Thanks, I've corrected the URL (linked to NPM now).

Answer 14

Enough to using eval javascript function to convert string to boolean

eval('true') 
eval('false')

• Jens Erat: Eval breaks lots of optimizations, results in slow code, is hard to debug and bad to maintain. If you can, never use it - there are much better ways to solve this problem, see the other answers.
• MKD: In this case, none of your listed is not critical and applicable.
• Benja: Jens everything you mention doesn't apply in this case, but the actually important problem with this is not mentioned, security. eval can lead to js injection, so don't use it if you can't trust the input source, and if you're on a browser you can hardly trust in that ever. JSON.parse is the safe way (not sure if the fastest).