3611

Can I convert a string representing a boolean value (e.g., 'true', 'false') into an intrinsic type in JavaScript?

I have a hidden form in HTML that is updated based on a user's selection within a list. This form contains some fields which represent boolean values and are dynamically populated with an intrinsic boolean value. However, once this value is placed into the hidden input field it becomes a string.

The only way I could find to determine the field's boolean value, once it was converted into a string, was to depend upon the literal value of its string representation.

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

Is there a better way to accomplish this?

Improve this question
17
  • 112
    "Is there a better way to accomplish this?" - there is certainly a worse way :D string=(string==String(string?true:false))?(string?true:false):(!string?true:fa‌​lse); Commented Apr 16, 2015 at 10:25
  • 14
    Easily handle strings and bools: function parseBool(val) { return val === true || val === "true" } Commented Sep 10, 2015 at 14:24
  • 3
    @Mark function checkBool(x) { if(x) {return true;} else {return false;} } Commented Nov 29, 2016 at 15:10
  • 4
    @Sebi: You forgot to document it: if (checkBool(x) != false) { ... } else { ... } Commented Nov 29, 2016 at 18:21
  • 9
    !!(parseInt(value) || value === "true") Commented Feb 22, 2017 at 3:58

111 Answers 111

Reset to default
1 2 3
4
1

I think it can be done in 1 liner with a use arrow function

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;

You guys can run and test various cases with following code snippet

const convertStringToBoolean = (value) => value ? String(value).toLowerCase() === 'true' : false;

console.log(convertStringToBoolean("a"));
console.log(convertStringToBoolean(null));
console.log(convertStringToBoolean(undefined));
console.log(convertStringToBoolean("undefined"));
console.log(convertStringToBoolean(true));
console.log(convertStringToBoolean(false));
console.log(convertStringToBoolean(0));
console.log(convertStringToBoolean(1)); // only case which will not work

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

if you are sure the input is anything only within 'true' and 'false' why not :

let x = 'true' ;
//let x = 'false';
let y = x === 'true' ? true : false;
console.log(typeof(y), y);

Improve this answer

1 Comment

same as y= (x=='true');
1

ES6+

const string = "false"
const string2 = "true"

const test = (val) => (val === "true" || val === "True")
console.log(test(string))
console.log(test(string2))

Improve this answer

3 Comments

Pass "True" to this and it returns false
@opticyclic ok, i minded this and created a fix.
val.toLowerCase() === "true"
1

The easiest way of doing this, especially if you're getting the 'true' or 'false' from an input type of radio ie

     <input type='radio' name='IsAllowedToWork' value={true} onChange{handleChange} />

     <input type='radio' name='IsAllowedToWork' value={false} onChange{handleChange} />

is this

    const handleChange = (e) => {
      let { value ,type} = e.target;
      if (type==='radio') {
       value = JSON.parse(value);
      } else if (type === 'file') {
       value = e.target.files[0];
      }  
     setValues({ ...values, [e.target.name]: value });
    };
Improve this answer

1 Comment

For radio buttons, you should use .checked
1

If you have no shame:

String.prototype.toTruth = function () {
    const value = this.valueOf();
    return value === 'true' ? true : value === 'false' ? false : undefined;
};

'true'.toTruth()    // true
'false'.toTruth()   // false
'falsest'.toTruth() // undefined
''.toTruth()        // undefined

(Disclaimer: For the love of ECMA, don't do this.)

It's an interesting question, though, with more repercussions than one might expect.

I called it toTruth and not toBoolean because its return value can't always be a Boolean. One could argue that '' should return false, but what about other strings? Is it true or false?

Unless you use strict typing everywhere, with a 'true' | 'false' union, there's no guarantee that your string is going to contain either true or false (or nothing). So logically, you have to allow for a third value, undefined. (Or throw an error? No thanks.)

This means it actually becomes ternary logic, where undefined is similar to SQL's NULL (neither true nor false). That makes it much more complicated than a simple true/false predicate. Especially when you add JavaScript's truthiness to the equation, where an undefined value might be evaluated as false (falsy).

If you have no shame and actually want to use this (dear god), you should explicitly check against the value you want with === and not use negation (unless you know what you're doing, keep in mind that it's ternary logic):

const input = 'foo'; // or anything else but 'true' or 'false'

input.toTruth()                // undefined

!input.toTruth()               // true (misleading, it's not false)
input.toTruth() !== true       // true (misleading, it's not false)

input.toTruth() === false      // false (correct)
input.toTruth() === true       // false (correct)
input.toTruth() === undefined  // true (correct)

I like JavaScript and I like ternary logic. But carelessly combining the two is a recipe for disaster.

A statically typed language like TypeScript does make it a lot easier. However, the same caveats apply when your code is exposed to code or input you don't control.

type BooleanString = 'true' | 'false'

function toBoolean(predicate: BooleanString): boolean {
    return predicate === 'true';
}

function toTruth(predicate: string): boolean | undefined {
    return predicate === 'true' ? true : predicate === 'false' ? false : undefined;
}
Improve this answer

Comments

1

Using Node.js REPL:

> t = 'true' 
'true'
> JSON.parse(t)
true
> typeof JSON.parse(t)
'boolean'
>
Improve this answer

Comments

0

The following would be enough

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

"true".boolean() // returns true "false".boolean() // returns false
Improve this answer

3 Comments

Modifying the prototype is very bad idea
@SzymonWygnański: i disagree. I do not see any other reason apart from for--in loop and native support for the same functionality by browsers. Reg for-inloop: i cannot think of a case, where for-in loops are really needed in string. Reg native support: we can definitely add a proto prop until native browsers support, if we are not building a framework like - prototype or jquery, etc... More about this by @Kangax(Perfection kills) is here. webcache.googleusercontent.com/…
Consider: we can go even farther: "true".checkbox() would convert to checkbox, or "true".application() would convert to app:D Not only for-in loops fail but the style is wrong here. Where would you look for the code of this "boolean/checkbox/application" definition in a big app? Imagine world where every library would do thinks like that. Isn't it much better to define a class or function: checkbox("true") - it's just cleaner and almost the same amount of letters. You never know IF browsers will support your custom function until it's defined as a standard (like Object.create etc...).
0

The `toBoolean' function returns false for null, undefined, '', 'false'. It returns true for any other string:

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

toBoolean('false') // returns false
Improve this answer

3 Comments

So it would return true for "False", would it not?
@OskarBerggren It wouldn't. Look at the code, if (bool === 'false') bool = false then, when it runs return !!bool it's returning !!false which is false.
@JustinLiu jsfiddle certainly evaluates toBoolean('False') to true which I think is probably not a good idea. With respect to the actual question, which was about a string representing a boolean value, I frankly think it's a bad idea to return true for "any "other" "random" "string" - it should raise an error instead of assuming that a caller that sent an erroneous string is happy with having that interpreted as true.
0

If you are using Environment Variables, use the following. Works on Heroku. Environment variables are string values that has to be converted to boolean values.

// Create the database connection
    this.connection = new Sequelize({
      username: process.env.PG_USERNAME,
      password: process.env.PG_PASSWORD,
      database: process.env.PG_DATABASE,
      host: process.env.PG_HOST,
      port: process.env.PG_PORT,
      dialect: process.env.PG_DIALECT,
      dialectOptions: {
        ssl: {
          require: process.env.PG_DIALECT_OPTION_SSL_REQUIRED === 'true', // <<< convert from string to bool
          rejectUnauthorized:
            process.env.PG_DIALECT_OPTION_SSL_REJECT_UNAUTHORIZED === 'true', // <<< convert from string to bool
        },
      },
      logging: true,
    });

env file

# PostgreSQL Config
PG_USERNAME=ttubkcug
PG_PASSWORD=ea59cee2883e73c602e6c05b674cf16950d6a9f05ab
PG_DATABASE=d67potesdliv25
PG_HOST=ec2-23-333-45-192.compute-1.amazonaws.com
PG_PORT=5432
PG_DIALECT=postgres
PG_DIALECT_OPTION_SSL_REQUIRED=true
PG_DIALECT_OPTION_SSL_REJECT_UNAUTHORIZED=false
Improve this answer

1 Comment

This answer does not seem to address the original question in any way.
0

Using lodash:

import _ from 'lodash';

const toBoolean = (val) => _.isEqual(_.toLower(val), 'true');

const values = [0, 1, '', undefined, null, [], {}, new Date(), true, false, 'true', 'false', 'True', 'False'];

_.forEach(values, (value) => {
    console.log(`${value} : ${toBoolean(value)}`);
});

https://replit.com/@tokra1/toBoolean-w-Lodash?v=1

enter image description here

Improve this answer

Comments

0 
const booleanOfsomeVal = someVal == "1" || someVal == "true";

This should work in typescript & javascript both

considering someVal could have possible values

0/1/"0"/"1"/true/false/"true"/"false"/undefined/null/NaN

Improve this answer

Comments

0

I had a wild idea to use JSON to evaluate the string, and if it fails, pass me false. With a Promise to catch errors.

const str = 'true'; // 'True', 'TRUE', '', '1', '0' ... 
const val = await Promise.resolve(str.toLowerCase()).then(JSON.parse).then<boolean>(r => !!r).catch(_ => false);

This works surprisingly well ... but does not handle 'on' / 'off'. Non-empty string is always true.

(If you are not using typescript, remove the <boolean>.)

I usually just do

const str = 'true';
const val = {'yes': true, 'on': true, 'no': false, 'off': false}[str.toLowerCase()] ?? false;

?? false is the fallback if undefined.

Improve this answer

Comments

-1

You can use Function to return a Boolean value from string "true" or "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"`

Improve this answer

7 Comments

That has the same issues (with security and performance) as eval
There's no issues using eval(), it's part of the JavaScript programming language specified in ECMA-262.
That's just ignorant/naive. Bad performance and content security policy restrictions are definitely issues with this solution.
I am neither ignorant nor naive. I know what I'm doing when I use Function() and/or eval(). You are talking about imaginary issues that don't exist. I'm my own browser I can get around any and all CSP, COEP, COOP, CORP, CORS to achieve my aims.
@Bergi When you use Ecmascript import you are literally executing code that you have no idea what is contained therein unless you wrote the code. So if you are going to be talking about Function() and eval() understand you are talking about Ecmascript import in the same way - that further remains a two-way binding after initial execution.
|
-1

Simple one line operation if you need Boolean false and true from the string values:

storeBooleanHere = stringVariable=="true"?true:false;
  • storeBooleanHere - This variable will hold the boolean value
  • stringVariable - Variable that has boolean stored as string
Improve this answer

1 Comment

simplified version: storeBooleanHere = stringVariable.toLowerCase() !== 'false' ;
-1

I needed a code that converts any variable type into Boolean. Here's what I came up with:

const toBoolean = (x) => {
    if (typeof x === 'object') {
      for (var i in x) return true
      return false
    }
    return (x !== null) && (x !== undefined) && !['false', '', '0', 'no', 'off'].includes(x.toString().toLowerCase())
  }

Let's test it!

const toBoolean = (x) => {
    if (typeof x === 'object') {
      for (var i in x) return true
      return false
    }
    return (x !== null) && (x !== undefined) && !['false', '', '0', 'no', 'off'].includes(x.toString().toLowerCase())
  }
  

  // Let's test it!
  let falseValues = [false, 'False', 0, '', 'off', 'no', [], {}, null, undefined]
  let trueValues = [  true, 'true', 'True', 1, -1, 'Any thing', ['filled array'], {'object with any key': null}]
  
  falseValues.forEach((value, index) => console.log(`False value ${index} of type ${typeof value}: ${value} -> ${toBoolean(value)}`))
  trueValues.forEach((value, index) => console.log(`True value ${index} of type ${typeof value}: ${value} -> ${toBoolean(value)}`))

You can remove words like "off" and "no" from the array if they don't match your case.

Improve this answer

Comments

-3

The simplest way to convert a string to a boolean is the following:

Boolean(<stringVariable>)
Improve this answer

1 Comment

Boolean("false") === true // output true
-3

var isTrueSet = eval(myValue);

Improve this answer

Comments

-5

works perfectly and very simple: 

var boolean = "false";
boolean = (boolean === "true");

//boolean = JSON.parse(boolean); //or this way..

to test it: 

var boolean = "false";
boolean = (boolean === "true");

//boolean = JSON.parse(boolean); //or this way.. 

if(boolean == true){
    alert("boolean = "+boolean);
}else{
    alert("boolean = "+boolean);
}

Improve this answer

5 Comments

my bad i have fixed the above snippet - works now. not sure how those inverted commas "" got in there! ;/ @HugoZapata
But the question is, how to convert a string to boolean. new Boolean("false") doesn't work, so your answer is not correct.
@HugoZapata updated the answer, yes was incorrect (but strangely was working before) updated answer works correctly now.
What is the point of the if/else? You are alert'ing the same thing in both branches.
@foxdonut because if boolean == false, then you can do something different in the else statement - the alert is just an example. even though its the same it outputs something different if the boolean var = true/false.
-6

// Try this in two ways convert a string to boolean

    const checkBoolean = Boolean("false"); 
    const checkBoolean1 = !!"false";  
    
    console.log({checkBoolean, checkBoolean1});
Improve this answer

1 Comment

Isn't Boolean("false") returns true
-7

Possible ways to convert String to Boolean I recommend you to create a function like the third option in the image and place it in a helper class as export, and reuse this function when you need.

Improve this answer

2 Comments

Downvoted because you posted an image of the code rather than the code itself.
@Wyck you failed to mention that presentation is nice.
-24

Just do a:

var myBool = eval (yourString);

Examples:

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

This method handles the empty string and undefined string naturally as if you declare a variable without assigning it a value.

Improve this answer

2 Comments

-1: Please don't advocate the use of eval (except perhaps for clever hacks and necessity).
that's a really bad and insecure use of eval. and it's not even clever. -1
1 2 3
4

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.