JavaScript: анализ строкового логического значения?

Я был бы склонен сделать однострочник с тройным if.

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

Изменить: Еще быстрее было бы просто избежать использования логического оператора и вместо этого просто использовать само выражение:

var bool_value = value == 'true';

Это работает, потому что value == 'true' оценивается на основе того, является ли переменная value строкой 'true'. Если это так, все выражение становится true, а если нет, становится false, тогда этот результат присваивается bool_value после оценки.

Для этого вы можете использовать JSON.parse:

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

Это зависит от того, как вы хотите, чтобы эта функция работала.

Если все, что вы хотите сделать, это проверить наличие слова «истина» внутри строки и определить любую строку (или не строку), в которой оно отсутствует, как ложь, возможно, самый простой способ:

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

Если вы хотите убедиться, что вся строка является словом true, вы можете сделать это:

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

Вы можете попробовать следующее:

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

Если это допустимое значение, оно возвращает эквивалентное значение типа bool, в противном случае возвращает null.

Вы можете использовать JSON.parse или jQuery.parseJSON и посмотреть, вернет ли он истину, используя что-то вроде этого:

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

Лично я думаю, что это нехорошо, что ваша функция «скрывает» недопустимые значения как false и - в зависимости от ваших вариантов использования - не возвращает true для "1".

Другая проблема может заключаться в том, что он блокирует все, что не является строкой.

Я бы использовал что-то вроде этого:

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
}

И в зависимости от вариантов использования расширьте его, чтобы различать "0" и "1".

(Может быть, есть способ сравнить только один раз с "true", но сейчас я ничего не мог придумать.)

Вы можете добавить этот код:

function parseBool(str) {

  if (str.length == null) {
    return str == 1 ? true : false;
  } else {
    return str == "true" ? true : false;
  }

}

Работает так:

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

Почему бы не сделать это простым?

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

    return (parseInt(str) > 0);
}

Wood-eye будьте осторожны. Посмотрев весь этот код, я чувствую себя обязанным опубликовать:

Начнем с самого короткого, но очень строгого способа:

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')
    {
        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;
}

Тестирование:

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

И последнее, но не менее важное: простой и эффективный способ сделать это со значением по умолчанию:

ES5

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

ES6, более короткий лайнер

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

JSON.parse эффективен для анализа логических значений

Мне нравится решение, предоставленное RoToRa (попробуйте проанализировать данное значение, если оно имеет какое-либо логическое значение, в противном случае - нет). Тем не менее я хотел бы внести небольшую модификацию, чтобы она работала более или менее как Boolean.TryParse в C #, который поддерживает out параметры. В JavaScript это можно реализовать следующим образом:

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.' }
    }
}

Использование:

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

stringjs имеет метод toBoolean ():

http://stringjs.com/#methods/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

Я беззастенчиво преобразовал Apache Common's toBoolean в JavaScript:

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

Код:

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.

Достаточно использовать функцию eval javascript для преобразования строки в логическое значение

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