How to Convert a String to Boolean in JavaScript

By the end of this page, you will understand how boolean-like strings work in JavaScript, why form inputs always return strings, and how to safely convert values like 'true' and 'false' into real booleans. You will also learn common mistakes, practical patterns, and when a direct string comparison is actually the correct solution.

In JavaScript, a boolean is a real primitive value: true or false.

A string is text, even if that text looks like a boolean:

true      // boolean
' true '  // string
'false'   // string

This matters because HTML form fields return their values as strings. So if an input contains true, JavaScript usually reads it as 'true', not the boolean true.

A very important detail is that JavaScript's built-in truthiness rules are not the same as converting 'true' / 'false' text into booleans.

For example:

Boolean('true');  // true
Boolean('false'); // also true

Why? Because any non-empty string is truthy in JavaScript.

So if your goal is:

• 'true' ->

Think of a form input like a label printer that turns everything into text.

Even if you put a real boolean into it, when you read it back, you get a text label:

• true becomes 'true'
• false becomes 'false'

Your job is to read the label and decide what it means.

A good mental model is:

• Boolean value = the actual on/off switch
• Boolean string = a note stuck onto the switch saying 'true' or 'false'

You should not ask, "Is this note non-empty?" because both 'true' and 'false' are non-empty strings.

Instead, ask, "Does the note exactly say 'true'?"

The safest beginner-friendly approach is explicit comparison.

Basic conversion

const value = 'true';
const boolValue = value === 'true';

console.log(boolValue); // true

const value = 'false';
const boolValue = value === 'true';

console.log(boolValue); // false

Reading from a form field

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

This is better than using == because === checks both value and type without coercion.

Handling different capitalizations

If your input might contain values like 'True' or 'TRUE', normalize it first:

Consider this example:

const inputValue = 'false';
const result = inputValue === 'true';
console.log(result);

Step by step:

1. inputValue is assigned the string 'false'.
2. JavaScript evaluates inputValue === 'true'.
3. It compares:
   • left side: 'false'
   • right side: 'true'
4. The two strings are not equal.
5. The expression returns the boolean false.
6. result now stores the real boolean false.
7. console.log(result) prints false.

Now compare with this broken approach:

const inputValue = 'false';
const result = Boolean(inputValue);
.(result);

Boolean string conversion appears often in everyday JavaScript work.

Form handling

Hidden inputs, text inputs, and select values are returned as strings:

const isAdmin = document.querySelector('#isAdmin').value === 'true';

Query parameters

A URL may contain values like ?debug=true:

const params = new URLSearchParams(window.location.search);
const debug = params.get('debug') === 'true';

localStorage

Values in localStorage are always stored as strings:

localStorage.setItem('darkMode', 'false');
const darkMode = localStorage.getItem() === ;

In real projects, developers usually avoid "magic conversion" and use explicit parsing.

Common pattern: strict comparison

const isPublished = formData.status === 'true';

This is readable and predictable.

Common pattern: helper function

If parsing happens in many places, teams often create a utility:

function parseBoolean(value) {
  return String(value).trim().toLowerCase() === 'true';
}

This centralizes the rule and makes behavior consistent.

Validation before conversion

In larger codebases, values may be validated first:

function parseBoolean(value) {
  const normalized = String(value).trim().toLowerCase();

  if (normalized !== 'true' && normalized !== 'false') {
    throw new Error();
  }

   normalized === ;
}

1. Using Boolean() to parse 'false'

Broken code:

const value = 'false';
const result = Boolean(value);
console.log(result); // true

Why it fails:

• Boolean() checks truthiness
• any non-empty string is truthy

Use this instead:

const result = value === 'true';

2. Using loose equality ==

const isTrueSet = myValue == 'true';

This may work here, but strict equality is better practice:

const isTrueSet = myValue === 'true';

3. Forgetting about capitalization

Broken code:

// Best simple conversion
const boolValue = value === 'true';

// Safer when case/spacing may vary
const boolValue = String(value).trim().toLowerCase() === 'true';

Key rules

• Form input values are strings.
• 'true' and 'false' are not booleans.
• Boolean('false') is true because it is a non-empty string.
• Use === 'true' for explicit conversion.
• Use trim() and toLowerCase() if input format may vary.

Useful helper

function parseBoolean(value) {
  return String(value).trim().toLowerCase() === 'true';
}

Strict validating helper

Why does 'false' become true with Boolean()?

Because 'false' is a non-empty string, and all non-empty strings are truthy in JavaScript.

Is value === 'true' a valid way to convert a string to boolean?

Yes. If your input is expected to be 'true' or 'false', this is often the clearest solution.

Should I use == or === for boolean string comparison?

Use ===. It avoids type coercion and is more predictable.

Can I use JSON.parse() to convert 'true' and 'false'?

Yes, but only if the string is guaranteed to be valid JSON like 'true' or 'false'. It is less forgiving and may throw errors for invalid input.

Why do HTML input values always come back as strings?

Form fields represent text values in the DOM API, so .value returns a string.

• JavaScript booleans — Understanding the real true and false primitive values is the foundation.
• Truthy and falsy values — Important because non-empty strings like 'false' are still truthy.
• Strict equality (===) — Useful for safe and predictable comparisons.
• HTML form input values — Relevant because form fields always return strings.
• Type coercion in JavaScript — Helps explain why some conversions behave unexpectedly.
• JSON.parse and JSON.stringify — Useful when data should preserve real booleans across serialization.
• localStorage data conversion — Important because stored values are always strings.
• URLSearchParams — Query string values are strings and often need parsing.