JavaScript: Разбор строки Логическое значение?

JavaScript имеет parseInt() и parseFloat(), но там нет метода parseBool или parseBoolean в глобальной области действия, насколько мне известно.

Мне нужен метод, который принимает строки со значениями, такими как "true" или "false", и возвращает JavaScript Boolean.

Здесь моя реализация:

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

Является ли это хорошей функцией? Пожалуйста, дайте мне свои отзывы.

Спасибо!

Ответы

Ответ 1

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

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

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

var bool_value = value == 'true';

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

Ответ 2

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

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

Ответ 3

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

Если все, что вы хотите сделать, это проверить слово "истина" внутри строки и определить любую строку (или nonstring), которая не имеет ее как false, самый простой способ, вероятно, таков:

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

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

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

Ответ 4

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

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.

Ответ 5

Лично я думаю, что это нехорошо, что ваша функция "скрывает" недопустимые значения как 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", но я не мог придумать что-то прямо сейчас.)

Ответ 6

Почему бы не сохранить его простым?

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

    return (parseInt(str) > 0);
}

Ответ 7

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

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

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

Ответ 8

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

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

Ответ 9

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

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

Ответ 10

Мне нравится решение, предоставленное RoToRa (попробуйте проанализировать данное значение, если оно имеет какое-либо логическое значение, в противном случае - нет). Тем не менее я хотел бы предоставить небольшую модификацию, чтобы она работала более или менее как Boolean.TryParse в С#, которая поддерживает параметры 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);

Ответ 11

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

Ответ 12

Я бесстыдно преобразовал Apache Common 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.

Ответ 13

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

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