Cum pot să convertesc un șir de caractere într-un boolean în JavaScript?
Pot să convertesc un șir de caractere care reprezintă o valoare booleană (de exemplu, 'true', 'false') într-un tip intrinsic în JavaScript?
Am un formular ascuns în HTML care este actualizat pe baza selecției unui utilizator într-o listă. Acest formular conține câmpuri care reprezintă valori booleene și sunt populate dinamic cu o valoare booleană intrinsecă. Totuși, odată ce această valoare este introdusă în câmpul de input ascuns, ea devine un șir de caractere.
Singura modalitate pe care am putut-o găsi pentru a determina valoarea booleană a câmpului, odată ce a fost convertit într-un șir, a fost să mă bazez pe valoarea literală a reprezentării sale sub formă de șir.
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
Există o modalitate mai bună de a realiza asta?
Răspuns #1
Fă :
var isTrueSet = (myValue === 'true');
Folosește operatorul de egalitate strictă (===), care nu efectuează conversii implicite de tip atunci când variabilele comparate au tipuri diferite.
Acest lucru va seta isTrueSet la un boolean true dacă șirul este „true” și la un boolean false dacă este șirul „false” sau nu este setat deloc.
Pentru a-l face insensibil la majuscule/minuscule, încercați:
var isTrueSet = /^true$/i.test(myValue);
// or
var isTrueSet = (myValue?.toLowerCase?.() === 'true');
// or
var isTrueSet = (String(myValue).toLowerCase() === 'true');
Nu:
Ar trebui să fii precaut în folosirea acestor două metode pentru nevoile tale specifice.
var myBool = Boolean("false"); // evaluates to true
var myBool = !!"false"; // evaluates to true
Orice șir care nu este șirul gol va fi evaluat ca true prin utilizarea lor. Deși sunt cele mai curate metode la care mă pot gândi în ceea ce privește conversia în boolean, cred că nu sunt ceea ce cauți.
Răspunsul #2
Atenție
Acest răspuns vechi, foarte votat, este tehnic corect, dar acoperă doar un scenariu foarte specific, când valoarea șirului tău este EXACT "true" sau "false".
Un șir JSON nevalid transmis în aceste funcții de mai jos VA genera o excepție.
Răspuns original:
Ce zici?
JSON.parse("True".toLowerCase());
sau cu jQuery
$.parseJSON("TRUE".toLowerCase());
Răspunsul #3
const stringToBoolean = (stringValue) => {
switch(stringValue?.toLowerCase()?.trim()){
case "true":
case "yes":
case "1":
return true;
case "false":
case "no":
case "0":
case null:
case undefined:
return false;
default:
return JSON.parse(stringValue);
}
}
Răspunsul #4
Cred că acesta este mult mai universal:
dacă (String(a).toLowerCase() == "true") ...
Merge așa:
String(true) == "true" //returns true
String(false) == "true" //returns false
String("true") == "true" //returns true
String("false") == "true" //returns false
Răspunsul #5
Amintește-ți să potrivești majusculele:
var isTrueSet = (myValue.toLowerCase() === 'true');
De asemenea, dacă este un element de formular tip checkbox, poți detecta și dacă checkbox-ul este bifat:
var isTrueSet = document.myForm.IS_TRUE.checked;
Presupunând că dacă este bifat, este „setat” egal cu adevărat. Aceasta se evaluează ca adevărat/fals.
Răspunsul #6
Aceasta este cea mai ușoară metodă de a face conversia în boolean pe care am întâlnit-o recent. M-am gândit să o adaug.
JSON.parse('true');
let trueResponse = JSON.parse('true');
let falseResponse = JSON.parse('false');
console.log(trueResponse);
console.log(falseResponse);Răspunsul #7
Poți folosi expresii regulate:
/*
* 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' regardless
// of capitalization and regardless of surrounding white-space.
//
regex=/^\s*(true|1|on)\s*$/i
return regex.test(s);
}
Dacă îți place să extinzi clasa String poți să faci:
String.prototype.bool = function() {
return strToBool(this);
};
alert("true".bool());
Pentru cei (vedeți comentariile) care ar dori să extindă obiectul String pentru a obține acest lucru, dar care sunt îngrijorați de enumerabilitate și se tem de coliziuni cu alte coduri care extind obiectul String:
Object.defineProperty(String.prototype, "com_example_bool", {
get : function() {
return (/^(true|1)$/i).test(this);
}
});
alert("true".com_example_bool);
(Desigur, nu va funcționa în browserele mai vechi și Firefox afișează false, în timp ce Opera, Chrome, Safari și IE afișează true. Bug 720760)
Răspunsul #8
Wood-eye, fii atent. După ce am văzut consecințele aplicării răspunsului de top cu peste 500 de voturi pozitive, mă simt obligat să postez ceva care este cu adevărat util:
Să începem cu cea mai scurtă, dar foarte strictă metodă:
var str = "true";
var mybool = JSON.parse(str);
Și încheie într-un mod potrivit, mai tolerant:
var parseBool = function(str, strict)
{
// console.log(typeof str);
// strict: JSON.parse(str)
if (str == null)
{
if (strict)
throw new Error("Parameter 'str' is null or undefined.");
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;
}
Testare :
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]));}
Răspunsul #9
Am crezut că răspunsul lui @Steven a fost cel mai bun și a acoperit mult mai multe cazuri decât dacă valoarea primită ar fi fost doar un șir. Am vrut să îl extind puțin și să ofer următoarele:
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;
}
}
Nu este necesar să acoperi toate cazurile false dacă deja cunoști toate cazurile true pentru care ar trebui să ții cont. Poți trimite orice în această metodă care ar putea fi considerat o valoare true (sau poți adăuga altele, este destul de simplu), iar toate celelalte vor fi considerate false
Răspuns #10
Soluție universală cu 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
ACTUALIZARE (fără JSON):
function getBool(val){
var num = +val;
return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}
Am creat și un fiddle pentru a-l testa http://jsfiddle.net/remunda/2GRhG/
Răspuns #11
Soluția ta este bună.
Folosirea === ar fi doar ridicolă în acest caz, deoarece value al câmpului va fi întotdeauna un String.
Răspunsul #12
Obiectul Boolean nu are o metodă 'parse'. Boolean('false') returnează true, deci asta nu va funcționa. !!'false' returnează de asemenea true, deci nici asta nu va funcționa.
Dacă vrei ca șirul 'true' să returneze booleanul true și șirul 'false' să returneze booleanul false, atunci cea mai simplă soluție este să folosești eval(). eval('true') returnează true și eval('false') returnează false.
Țineți cont însă de implicațiile asupra performanței și securității atunci când folosiți eval().
Răspunsul #13
var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) {
return !falsy.test(val) && !!val;
};
Aceasta returnează false pentru fiecare valoare falsă și true pentru fiecare valoare adevărată, cu excepția 'false', 'f', 'no', 'n' și '0' (insensibil la majuscule).
// 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());
Răspuns #14
Există multe răspunsuri și este greu să alegi unul. În cazul meu, acord prioritate performanței când aleg, așa că am creat acest jsPerf pe care sper să îl poată lămuri puțin aici.
Rezumatul rezultatelor (cu cât mai mare, cu atât mai bine):
- Instrucțiune condițională: 2.826.922
- Caz switch pe obiect Bool: 2.825.469
- Convertire la JSON: 1.867.774
- !! conversii: 805.322
- Prototipul șirului: 713.637
Sunt legate de răspunsul aferent unde poți găsi mai multe informații (avantaje și dezavantaje) despre fiecare; în special în comentarii.
Răspuns #15
Acesta a fost preluat din răspunsul acceptat, dar are într-adevăr un punct foarte slab și sunt șocat cum a obținut acest număr de voturi pozitive, problema cu el este că trebuie să iei în considerare cazul stringului pentru că acesta face diferență între majuscule și minuscule
var isTrueSet = (myValue.toLowerCase() === 'true');
Răspuns #16
Folosesc următoarele:
function parseBool(b) {
return !(/^(false|0)$/i).test(b) && !!b;
}
Această funcție efectuează conversia obișnuită în Boolean, cu excepția șirurilor „false” (nu contează literele mari sau mici) și „0”.
Răspunsul #17
Cea mai simplă soluție 🙌🏽
cu ES6+
folosește NOT logic de două ori [ !! ] pentru a obține conversia în șir
Doar lipește această expresie...
const stringToBoolean = (string) => string === 'false' ? false : !!string
Și trece-i șirul tău!
stringToBoolean('') // false
stringToBoolean('false') // false
stringToBoolean('true') // true
stringToBoolean('hello my friend!') // true
const betterStringToBoolean = (string) =>
string === 'false' || string === 'undefined' || string === 'null' || string === '0' ?
false : !!string
Poți include alte șiruri după bunul plac pentru a extinde ușor utilizarea acestei expresii...:
betterStringToBoolean('undefined') // false
betterStringToBoolean('null') // false
betterStringToBoolean('0') // false
betterStringToBoolean('false') // false
betterStringToBoolean('') // false
betterStringToBoolean('true') // true
betterStringToBoolean('anything else') // true
Răspunsul #18
Expresia pe care o cauți este pur și simplu
/^true$/i.test(myValue)
ca în
var isTrueSet = /^true$/i.test(myValue);
Acesta testează myValue împotriva unei expresii regulate, fără a ține cont de majuscule și minuscule, și nu modifică prototipul.
Exemple:
/^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
Răspunsul #19
poți folosi JSON.parse astfel:
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
alert('this is true');
else
alert('this is false');în acest caz .toLowerCase este important
Răspuns #20
Sunt surprins că includes nu a fost sugerat
let bool = "false"
bool = !["false", "0", 0].includes(bool)
Poți modifica verificarea pentru adevărat sau să incluzi mai multe condiții (de exemplu null, '').
Răspuns #21
Există deja atât de multe răspunsuri disponibile. Dar următorul poate fi util în anumite scenarii.
// 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;
});
}
Acest lucru poate fi util în cazul în care un exemplu are valori non-booleene.
getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false
getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true
Răspunsul #22
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.");
}
};
Răspunsul #23
Pentru a converti atât șirul („true”, „false”), cât și booleanul în boolean
('' + flag) === "true"
Unde flag poate fi
var flag = true
var flag = "true"
var flag = false
var flag = "false"
Răspuns #24
Această funcție poate gestiona șiruri de caractere, precum și valorile Booleene true/false.
function stringToBoolean(val){
var a = {
'true':true,
'false':false
};
return a[val];
}
Demonstrație mai jos:
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)));Răspunsul #25
O linie
Trebuie doar să luăm în considerare șirul „false”, deoarece orice alt șir (inclusiv „true”) este deja true.
function b(v){ return v==="false" ? false : !!v; }
Test
b(true) //true
b('true') //true
b(false) //false
b('false') //false
O versiune mai exhaustivă
function bool(v){ return v==="false" || v==="null" || v==="NaN" || v==="undefined" || v==="0" ? false : !!v; }
Test
bool(true) //true
bool("true") //true
bool(1) //true
bool("1") //true
bool("hello") //true
bool(false) //false
bool("false") //false
bool(0) //false
bool("0") //false
bool(null) //false
bool("null") //false
bool(NaN) //false
bool("NaN") //false
bool(undefined) //false
bool("undefined") //false
bool("") //false
bool([]) //true
bool({}) //true
bool(alert) //true
bool(window) //true
Răspuns #26
Folosesc acesta
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"
Răspunsul #27
de ce nu încerci ceva de genul acesta
Boolean(JSON.parse((yourString.toString()).toLowerCase()));
Va returna o eroare atunci când este dat un alt text în afară de true sau false, indiferent de majuscule sau minuscule, și va captura de asemenea și numerele ca
// 0-> false
// any other number -> true