Aviso

Esta resposta altamente ascendente é tecnicamente correcta, mas apenas cobre um cenário muito específico, quando o seu valor de cadeia de caracteres é exactamente "true" ou "false" (deve ser minúscula também).

Uma cadeia JSON inválida passou para estas funções abaixo irá abrir uma excepção .

Resposta Original:

JSON.parse("true");

Ou com 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") ...

Diz:

String(true) == "true"     //returns true
String(false) == "true"    //returns false
String("true") == "true"   //returns true
String("false") == "true"  //returns false

Pode usar expressões regulares:

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

Se gosta de alargar a classe de texto, pode fazer:

String.prototype.bool = function() {
    return strToBool(this);
};

alert("true".bool());

Para aqueles (ver comentários) que gostariam de estender o objeto de Cadeia de caracteres para obter isso, mas estão preocupados sobre enumerability e estão preocupados em confronto com outro código que estende o objeto de Cadeia de caracteres:

Object.defineProperty(String.prototype, "com_example_bool", {
    get : function() {
        return (/^(true|1)$/i).test(this);
    }
});
alert("true".com_example_bool);

Lembre-se de combinar o caso:

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

Também, se for uma opção do elemento form, Poderá também detectar se a opção estiver assinalada:

var isTrueSet = document.myForm.IS_TRUE.checked;

Assumindo que se estiver assinalado, é "definido" igual a verdadeiro. Isto é considerado verdadeiro / falso.

Wood-eye tem cuidado. Depois de ver as consequências depois de aplicar a resposta superior com 500 + upvotes, sinto-me obrigado a postar algo que é realmente útil:

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

E terminar com uma maneira adequada e mais tolerante:

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

Teste:

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

Usar {[[0]} seria uma tolice neste caso, pois o campo value será sempre um String.

Solução Universal com JSON parse:

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

Actualização (sem JSON):

function getBool(val){ 
    var num = +val;
    return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}

Eu pensei que a resposta de @Steven era a melhor, e cuidava de muito mais casos do que se o valor recebido fosse apenas uma corda. Eu queria estendê-lo um pouco e oferecer o seguinte:

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

Não é necessário cobrir todos os casos false se já conheces todos os casos true pelos quais terias de contar. Você pode passar qualquer coisa para este método que poderia passar por um valor true (ou adicionar outros, é bastante simples), e tudo o resto seria considerado false

var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) { 
    return !falsy.test(val) && !!val;
};

Isto devolve false por cada valor falso e true por cada valor verdadeiro, excepto para 'false', 'f', 'no', 'n', e '0' (insensível a maiúsculas).

// 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());

O objecto booleano não tem um método' parse'. Boolean('false') retorna verdadeiro, então isso não vai funcionar. !!'false' também devolve true, por isso isso também não vai funcionar.

Se quiser que o texto 'true' devolva o booleano true e o texto 'false' devolvam o booleano false, então a solução mais simples é usar eval(). eval('true') devolve verdadeiro e eval('false') devolve falso. Tenha em mente as implicações de desempenho ao usar eval() no entanto.

Uso o seguinte:

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

Esta função executa a coerção booleana habitual, com excepção das cadeias "false" (insensível a maiúsculas) e "0".

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.");
  }
};

Breve dos resultados (quanto maior melhor):

1. declaração condicional: 2,826,922
2. mudar de capitalização no objecto Bool: 2,825,469
3. elenco para JSON: 1,867,774
4. !! conversões: 805,322
5. protótipo do texto: 713,637

Eles estão ligados à resposta relacionada onde você pode encontrar mais informações (prós e contras) sobre cada um; especialmente nos comentários.

A expressão que procuras é simplesmente

/^true$/i.test(myValue)

Como em

var isTrueSet = /^true$/i.test(myValue);

Este teste myValue contra uma expressão regular , insensível a maiúsculas, e não modifica o protótipo.

Exemplos:

/^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

Já existem tantas respostas disponíveis. Mas seguir pode ser útil em alguns cenários.

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

Isto pode ser útil quando um exemplo com valores não-booleanos.

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true

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

Baixa a maneira mais fácil (assumindo que o texto será 'verdadeiro' ou' falso') é:

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

sempre use o = = = operador em vez do = = operador para estes tipos de conversões!

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

Para converter ambas as cadeias ("verdadeiro"," falso") E booleanas para booleanas

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

Onde {[2] } pode ser

 var flag = true
 var flag = "true"
 var flag = false
 var flag = "false"

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"

• Devolve verdadeiro / falso para os valores truthy e falsey, mas também devolve verdadeiro / falso para vários valores de string que seriam truthy ou falsey se fossem booleanos em vez de strings.
• Em segundo lugar, fornecer uma interface resistente de modo a que os valores diferentes dos especificados não falhem, mas devolvam um valor por omissão
Em terceiro lugar, faz tudo isto com o menor Código possível.

A o problema com o uso de JSON é que ele falha ao causar um erro de Javascript. Esta solução não é resistente (embora satisfaça 1 e 3):

JSON.parse("FALSE") // fails

Esta solução não é suficientemente concisa:

if(value === "TRUE" || value === "yes" || ...) { return true; }

Estou a trabalhar para resolver este problema EXACTO para Typecast.js . E a melhor solução para os três objectivos é esta:

return /^true$/i.test(v);

Funciona em muitos casos, não falha quando valores como {} são passados, e é muito conciso. Também devolve false como o valor por omissão ao invés de indefinido ou lançar um erro, que é mais útil no desenvolvimento de Javascript vagamente digitado. Bravo para as outras respostas que o sugeriram!

Eu sou um pouco tarde, mas eu tenho um pequeno trecho para fazer isso, é, essencialmente, mantém todos os JScripts truthey/falsey/imundo-ness, mas inclui "false" como um aceitáveis de valor para false.

Prefiro este método aos mencionados porque não depende de uma terceira parte para analisar o código (I. E.: eval/JSON.parse), que é exagero na minha mente, é curta o suficiente para não exigir uma função de utilidade e mantém outras convenções 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..

Outra solução. 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
};

Os Casos de ensaio são executados no nó

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

Esta função pode manipular o texto, assim como o verdadeiro booleano/falso.

function stringToBoolean(val){
    var a = {
        'true':true,
        'false':false
    };
    return a[val];
}

Demonstração abaixo:

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

Você precisa separar (no seu pensamento) o valor de suas seleções e a representação desse valor.

Escolha um ponto na lógica JavaScript onde eles precisam de transição de texto sentinelas para o tipo nativo e faça uma comparação lá, de preferência onde ele só é feito uma vez para cada valor que precisa ser convertido. Lembre-se de abordar o que precisa de acontecer se o texto Sentinela não é um que o script conhece (isto é, por omissão é verdadeiro ou falso?)

Em outras palavras, sim, você precisa depender do valor da string. :-)

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

Escrevi uma função para corresponder ao filter_var do PHP, o que faz isto muito bem. Disponível em um gist: https://gist.github.com/CMCDragonkai/7389368

/**
 * Parses mixed type values into booleans. This is the same function as filter_var in PHP using boolean validation
 * @param  {Mixed}        value 
 * @param  {Boolean}      nullOnFailure = false
 * @return {Boolean|Null}
 */
var parseBooleanStyle = function(value, nullOnFailure = false){
    switch(value){
        case true:
        case 'true':
        case 1:
        case '1':
        case 'on':
        case 'yes':
            value = true;
            break;
        case false:
        case 'false':
        case 0:
        case '0':
        case 'off':
        case 'no':
            value = false;
            break;
        default:
            if(nullOnFailure){
                value = null;
            }else{
                value = false;
            }
            break;
    }
    return value;
};

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

Se não tiver a certeza da entrada, a informação acima funciona para booleano e também para qualquer cadeia de caracteres.