Comment puis-je convertir une chaîne en booléen en JavaScript?
Puis-je convertir une chaîne représentant une valeur booléenne (par exemple, 'true', 'false') en un type intrinsèque en JavaScript?
J'ai un formulaire HTML masqué qui est mis à jour en fonction de la sélection d'un utilisateur dans une liste. Ce formulaire contient des champs qui représentent des valeurs booléennes et sont dynamiquement renseignés avec une valeur booléenne intrinsèque. Cependant, une fois que cette valeur est placée dans le champ de saisie masqué, elle devient une chaîne.
La seule façon pour moi de déterminer la valeur booléenne du champ, une fois celui-ci converti en chaîne, était de dépendre de la valeur littérale de sa représentation sous forme de chaîne.
var myValue = document.myForm.IS_TRUE.value;
var isTrueSet = myValue == 'true';
Y a-t-il une meilleure façon d'accomplir cela?
Faire:
var isTrueSet = (myValue == 'true');
Vous pouvez le rendre plus strict en utilisant l'opérateur d'identité (===), qui n'effectue aucune conversion de type implicite lorsque les variables comparées ont des types différents, au lieu de l'opérateur d'égalité (==).
var isTrueSet = (myValue === 'true');
Ne pas:
Vous devriez probablement soyez prudent lorsque vous utilisez ces deux méthodes pour vos besoins spécifiques:
var myBool = Boolean("false"); // == true
var myBool = !!"false"; // == true
Toute chaîne qui n'est pas la chaîne vide sera évaluée à true en les utilisant. Bien que ce soient les méthodes les plus propres auxquelles je puisse penser en ce qui concerne la conversion booléenne, je pense qu'elles ne sont pas ce que vous recherchez.
Attention
Cette réponse ancienne, hautement votée, est techniquement correcte mais ne couvre qu'un scénario très spécifique, lorsque votre valeur de chaîne est EXACTEMENT "true" ou "false" (DOIT également être en minuscule).
Une chaîne json non valide passée dans ces fonctions ci-dessous Lève une exception.
Réponse originale:
Que diriez-vous?
JSON.parse("true");
ou avec 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);
}
}
Je pense que c'est beaucoup universel:
if (String(a) == "true") ...
Ça va:
String(true) == "true" //returns true
String(false) == "true" //returns false
String("true") == "true" //returns true
String("false") == "true" //returns false
N'oubliez pas de faire correspondre le cas:
var isTrueSet = (myValue.toLowerCase() === 'true');
De plus, s'il s'agit d'une case à cocher d'élément de formulaire, vous pouvez également détecter si elle est cochée:
var isTrueSet = document.myForm.IS_TRUE.checked;
En supposant que s'il est coché, il est "défini" égal à true. Ceci évalue comme vrai/faux.
Vous pouvez utiliser des expressions régulières:
/*
* 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);
}
Si vous aimez étendre la classe String, vous pouvez faire:
String.prototype.bool = function() {
return strToBool(this);
};
alert("true".bool());
Pour ceux (voir les commentaires) qui souhaitent étendre l'objet String pour obtenir cela, mais s'inquiètent de l'énumérabilité et s'inquiètent du conflit avec un autre code qui étend l'objet String:
Object.defineProperty(String.prototype, "com_example_bool", {
get : function() {
return (/^(true|1)$/i).test(this);
}
});
alert("true".com_example_bool);
(Cela ne fonctionnera évidemment pas dans les anciens navigateurs et Firefox indique false tandis qu'Opera, Chrome, Safari et IE indiquent true. Bogue 72076 )
Oeil de bois soyez prudent. Après avoir constaté les conséquences après avoir appliqué la première réponse avec plus de 500 votes positifs, je me sens obligé de publier quelque chose qui est réellement utile:
Commençons par le chemin le plus court, mais très strict:
var str = "true";
var mybool = JSON.parse(str);
Et terminez avec une manière plus tolérante:
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;
}
Essai:
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]));}
Solution universelle avec analyse JSON:
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
UPDATE (sans JSON):
function getBool(val){
var num = +val;
return !isNaN(num) ? !!num : !!String(val).toLowerCase().replace(!!0,'');
}
J'ai également créé fiddle pour le tester http://jsfiddle.net/remunda/2GRhG/
Votre solution est bien.
Utiliser === serait simplement idiot dans ce cas, car le champ value sera toujours un String.
Je pensais que la réponse de @Steven était la meilleure, et traitait beaucoup plus de cas que si la valeur entrante était juste une chaîne. Je voulais l'étendre un peu et offrir ce qui suit:
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;
}
}
Il n'est pas nécessaire de couvrir tous les cas false si vous connaissez déjà tous les cas true dont vous devez tenir compte. Vous pouvez passer n'importe quoi dans cette méthode qui pourrait passer pour une valeur true (ou en ajouter d'autres, c'est assez simple), et tout le reste serait considéré comme false
var falsy = /^(?:f(?:alse)?|no?|0+)$/i;
Boolean.parse = function(val) {
return !falsy.test(val) && !!val;
};
Ceci retourne false pour chaque valeur de fausseté et true pour toute valeur de vérité, à l'exception de 'false', 'f', 'no', 'n' et '0' (insensible à la casse).
// 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());
L'objet booléen n'a pas de méthode d'analyse. Boolean('false') renvoie true, donc cela ne fonctionnera pas. !!'false' renvoie également true, donc cela ne fonctionnera pas aussi.
Si vous voulez que la chaîne 'true' renvoie le booléen true et que la chaîne 'false' renvoie le booléen false, la solution la plus simple consiste à utiliser eval(). eval('true') renvoie true et eval('false') renvoie false. Gardez toutefois à l’esprit les conséquences sur les performances lors de l’utilisation de eval().
Il y a beaucoup de réponses et il est difficile d'en choisir une. Dans mon cas, je priorise la performance lors du choix, alors je crée this jsPerf que j’espère pouvoir jeter un peu de lumière ici.
Bref des résultats (le plus haut possible):
- Instruction conditionnelle : 2 826 922
- Basculer la casse sur l'objet Bool : 2 825 469
- Conversion en JSON : 1 867 774
- !! conversions : 805 322
- Prototype de chaîne : 713,637
Ils sont liés à la réponse associée où vous pouvez trouver plus d’informations (avantages et inconvénients) sur chacune d’elles; spécialement dans les commentaires.
J'utilise les éléments suivants:
function parseBool(b) {
return !(/^(false|0)$/i).test(b) && !!b;
}
Cette fonction exécute la contrainte booléenne habituelle à l'exception des chaînes "false" (insensible à la casse) et "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.");
}
};
L’expression que vous recherchez est simplement
/^true$/i.test(myValue)
un péché
var isTrueSet = /^true$/i.test(myValue);
Ceci teste myValue par rapport à une expression régulière, ne respecte pas la casse, et ne modifie pas le prototype.
Exemples:
/^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
Il y a déjà tellement de réponses disponibles. Mais suivre peut être utile dans certains scénarios.
// 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;
});
}
Cela peut être utile là où on a des exemples avec des valeurs non booléennes.
getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false
getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true
Cela a été pris de la réponse acceptée, mais en réalité, il a un point très faible, et je suis choqué de voir comment il a obtenu ce nombre de votes positifs, le problème étant que vous devez tenir compte du cas de la chaîne car elle est sensible à la casse.
var isTrueSet = (myValue.toLowerCase() === 'true');
Pour convertir les chaînes ("true", "false") et booléen en booléen
('' + flag) === "true"
Où flag peut être
var flag = true
var flag = "true"
var flag = false
var flag = "false"
pourquoi ne pas essayer quelque chose comme ça
Boolean(JSON.parse((yourString.toString()).toLowerCase()));
Il renverra une erreur si un autre texte est donné plutôt que vrai ou faux quel que soit le cas et il capturera également les nombres
// 0-> false
// any other number -> true
La manière la plus simple de procéder (en supposant que votre chaîne sera 'true' ou 'false') est:
var z = 'true';
var y = 'false';
var b = (z === 'true'); // will evaluate to true
var c = (y === 'true'); // will evaluate to false
toujours utilisez l'opérateur === au lieu de l'opérateur == pour ces types de conversions!
Cette fonction peut gérer les chaînes aussi bien que les booléens true/false.
function stringToBoolean(val){
var a = {
'true':true,
'false':false
};
return a[val];
}
Démonstration ci-dessous:
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)));Comme @ Shadow2531 l'a dit, vous ne pouvez pas le convertir directement. Je suggèrerais également que vous considériez des entrées de chaîne autres que "true" et "false" qui sont "véracité" et "falsey" si votre code doit être réutilisé/utilisé par d'autres. C'est ce que j'utilise:
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;
}
}
J'utilise celui-ci
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"
une autre solution. 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
};
cas de test exécutés dans le noeud
> 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
>
Mon point de vue sur cette question est qu’il vise à satisfaire trois objectifs:
- Renvoie vrai/faux pour les valeurs de vérité et de falsey, mais également vrai/faux pour plusieurs valeurs de chaîne qui seraient vérité et falsey si elles étaient booléennes au lieu de chaînes.
- Deuxièmement, fournissez une interface résiliente pour que les valeurs autres que celles spécifiées n'échouent pas, mais renvoient plutôt une valeur par défaut
- Troisièmement, faites tout cela avec le moins de code possible.
Le problème avec l'utilisation de JSON est qu'il échoue en provoquant une erreur Javascript. Cette solution n'est pas résiliente (bien qu'elle satisfasse aux critères 1 et 3):
JSON.parse("FALSE") // fails
Cette solution n'est pas assez concise:
if(value === "TRUE" || value === "yes" || ...) { return true; }
Je travaille sur la résolution de ce problème exact pour Typecast.js . Et la meilleure solution aux trois objectifs est celle-ci:
return /^true$/i.test(v);
Cela fonctionne dans de nombreux cas, n'échoue pas lorsque des valeurs telles que {} sont transmises et est très concis. En outre, elle renvoie false comme valeur par défaut plutôt que non définie ou en générant une erreur, ce qui est plus utile dans le développement Javascript mal typé. Bravo aux autres réponses qui l'ont suggéré!
Je suis un peu en retard, mais j’ai un petit bout de code à faire. Il conserve essentiellement tous les scripts JSututh/falsey/crasseux - mais inclut "false" comme valeur acceptable pour faux .
Je préfère cette méthode à celles mentionnées car elle ne repose pas sur un tiers pour analyser le code (par exemple: eval/JSON.parse), ce qui est excessif dans mon esprit, il est suffisamment court pour ne pas nécessiter de fonction utilitaire et tient à jour. autres conventions de vérité/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..
Vous devez séparer (dans votre pensée) la valeur de vos sélections et la représentation de cette valeur.
Choisissez un point dans la logique JavaScript où ils doivent passer de la sentinelle de chaîne au type natif et faites une comparaison là-bas, de préférence là où cela ne se fait qu'une fois pour chaque valeur devant être convertie. N'oubliez pas de préciser ce qui doit se passer si la chaîne sentinel n'est pas une chaîne connue du script (c.-à-d. Utilisez-vous par défaut la valeur true ou false?)
En d'autres termes, oui, vous devez dépendre de la valeur de la chaîne. :-)
J'ai écrit une fonction pour correspondre à filter_var de PHP qui le fait très bien. Disponible dans un 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;
};
Bon mot
Nous devons juste tenir compte de la chaîne "false" car toute autre chaîne (y compris "true") est déjà true.
function b(v){ return v==="false" ? false : !!v; }
Test
b(true) //true
b('true') //true
b(false) //false
b('false') //false
Une version plus exaustive
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
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;
}
Dieu Saint, certaines de ces réponses ne sont que sauvages. J'adore JS et son nombre infini de façons de peler un booléen.
Ma préférence, que je n’étais pas choquée de voir déjà, est:
testVar = testVar.toString().match(/^(true|[1-9][0-9]*|[0-9]*[1-9]+|yes)$/i) ? true : false;
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
Si vous n'êtes pas sûr de l'entrée, ce qui précède fonctionne pour les valeurs booléennes et toutes les chaînes.
J'ai constaté que l'utilisation de '1' et d'une valeur vide '' pour les valeurs booléennes fonctionnait bien mieux que les valeurs 'true' ou 'false' ... to false tandis que any la valeur en leur sein est évaluée à true.
Par exemple:
<input type='button' onclick='this.value = tog(this.value);' />
<script type="text/javascript">
function tog(off) {
if(off) {
alert('true, toggle to false');
return '';
} else {
alert('false, toggle to true');
return '1';
}
}
</script>
Cela semblait être une route plus facile, jusqu'à présent, cela a été très cohérent/facile ... peut-être que quelqu'un peut déterminer un moyen de résoudre ce problème?
@guinaps> Toute chaîne qui n'est pas la chaîne vide sera évaluée à true en les utilisant.
Comment utiliser la méthode String.match ()
var str="true";
var boolStr=Boolean(str.match(/^true$/i));
cela seul ne recevra pas le 1/0 ni le oui/non, mais il attrapera le VRAI/vrai, ainsi, il retournera faux pour toute chaîne ayant la valeur "vrai" comme sous-chaîne.
EDIT
Vous trouverez ci-dessous une fonction permettant de gérer true/false, 1/0, yes/no (insensible à la casse)
function stringToBool(str) {
var bool;
if (str.match(/^(true|1|yes)$/i) !== null) {
bool = true;
} else if (str.match(/^(false|0|no)*$/i) !== null) {
bool = false;
} else {
bool = null;
if (console) console.log('"' + str + '" is not a boolean value');
}
return bool;
}
stringToBool('1'); // true
stringToBool('No'); // false
stringToBool('falsey'); // null ("falsey" is not a boolean value.)
stringToBool(''); // false
Je fais cela, qui va gérer 1 = VRAI = oui = OUI = vrai, 0 = FAUX = non = NON = faux:
BOOL=false
if (STRING)
BOOL=JSON.parse(STRING.toLowerCase().replace('no','false').replace('yes','true'));
Remplacez STRING par le nom de votre variable chaîne.
Si ce n'est pas nul, une valeur numérique ou l'une de ces chaînes: "vrai", "vrai", "faux", "faux", "oui", "oui", "non", "non" (intentionnellement.)
Si vous êtes certain que le sujet du test est toujours une chaîne, alors vérifier explicitement qu'il est égal à true est votre meilleur choix.
Vous voudrez peut-être envisager d'inclure un peu de code au cas où le sujet pourrait réellement être un booléen.
var isTrueSet =
myValue === true ||
myValue != null &&
myValue.toString().toLowerCase() === 'true';
Cela pourrait vous épargner un peu de travail à l'avenir si le code était amélioré/modifié pour utiliser des valeurs booléennes réelles au lieu de chaînes.
J'utilise une méthode personnelle qui inclut une vérification de l'existence de l'objet en premier et une conversion plus intuitive en booléen:
function str2bool(strvalue){
return (strvalue && typeof strvalue == 'string') ? (strvalue.toLowerCase() == 'true' || strvalue == '1') : (strvalue == true);
}
Les résultats sont:
var test; // false
var test2 = null; // false
var test3 = 'undefined'; // false
var test4 = 'true'; // true
var test5 = 'false'; // false
var test6 = true; // true
var test7 = false; // false
var test8 = 1; // true
var test9 = 0; // false
var test10 = '1'; // true
var test11 = '0'; // false
Violon: http://jsfiddle.net/av5xcj6s/
j'ai écrit une fonction d'assistance qui gère vos cas (et d'autres encore). N'hésitez pas à le modifier selon vos besoins spécifiques
/**
* @example
* <code>
* var pageRequestParams = {'enableFeatureX': 'true'};
* toBool(pageRequestParams.enableFeatureX); // returns true
*
* toBool(pageRequestParams.enableFeatureY, true, options.enableFeatureY)
* </code>
* @param {*}value
* @param {Boolean}[mapEmptyStringToTrue=false]
* @param {Boolean}[defaultVal=false] this is returned if value is undefined.
*
* @returns {Boolean}
* @example
* <code>
* toBool({'enableFeatureX': '' }.enableFeatureX); // false
* toBool({'enableFeatureX': '' }.enableFeatureX, true); // true
* toBool({ }.enableFeatureX, true); // false
* toBool({'enableFeatureX': 0 }.enableFeatureX); // false
* toBool({'enableFeatureX': '0' }.enableFeatureX); // false
* toBool({'enableFeatureX': '0 ' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'false' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'falsE ' }.enableFeatureX); // false
* toBool({'enableFeatureX': 'no' }.enableFeatureX); // false
*
* toBool({'enableFeatureX': 1 }.enableFeatureX); // true
* toBool({'enableFeatureX': '-2' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'true' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'false_' }.enableFeatureX); // true
* toBool({'enableFeatureX': 'john doe'}.enableFeatureX); // true
* </code>
*
*/
var toBool = function (value, mapEmptyStringToTrue, defaultVal) {
if (value === undefined) {return Boolean(defaultVal); }
mapEmptyStringToTrue = mapEmptyStringToTrue !== undefined ? mapEmptyStringToTrue : false; // default to false
var strFalseValues = ['0', 'false', 'no'].concat(!mapEmptyStringToTrue ? [''] : []);
if (typeof value === 'string') {
return (strFalseValues.indexOf(value.toLowerCase().trim()) === -1);
}
// value is likely null, boolean, or number
return Boolean(value);
};
Voici une fonction simple qui fera l'affaire,
function convertStringToBool(str){
return ((str === "True") || (str === "true")) ? true:false;
}
Cela donnera le résultat suivant
convertStringToBool("false") //returns false
convertStringToBool("true") // returns true
convertStringToBool("False") // returns false
convertStringToBool("True") // returns true
Voici ma soumission 1 liner: je devais évaluer une chaîne et une sortie, true si "true", false si "false" et un nombre similaire à "-12.35673".
val = 'false';
val = /^false$/i.test(val) ? false : ( /^true$/i.test(val) ? true : val*1 ? val*1 : val );
J'utilise cette approche simple (en utilisant "myVarToTest"):
var trueValuesRange = ['1', 1, 'true', true];
myVarToTest = (trueValuesRange.indexOf(myVarToTest) >= 0);
function isTrue(val) {
try {
return !!JSON.parse(val);
} catch (e) {
return false;
}
}
if (String(a) == "true"){
//true block
} else {
//false block
}
vous pouvez utiliser :
var trueOrFalse='True';
result =JSON.parse(trueOrFalse.toLowerCase());
if(result==true)
alert('this is ture');
else
('this is false');dans ce cas, le .toLowerCase est important
Beaucoup de réponses sophistiquées ici. Vraiment surpris que personne n'ait posté cette solution:
var booleanVal = toCast > '';
Cela se traduit par true dans la plupart des cas autres que bool false, nombre zéro et chaîne vide (évidemment). Vous pouvez facilement rechercher d'autres valeurs de chaîne Falsey après coup, par exemple:
var booleanVal = toCast > '' && toCast != 'false' && toCast != '0';
Beaucoup de réponses existantes sont similaires, mais la plupart ignorent le fait que l'argument donné pourrait également être un objet.
Voici quelque chose que je viens de fouetter:
Utils.parseBoolean = function(val){
if (typeof val === 'string' || val instanceof String){
return /true/i.test(val);
} else if (typeof val === 'boolean' || val instanceof Boolean){
return new Boolean(val).valueOf();
} else if (typeof val === 'number' || val instanceof Number){
return new Number(val).valueOf() !== 0;
}
return false;
};
... et le test unitaire pour cela
Utils.Tests = function(){
window.console.log('running unit tests');
var booleanTests = [
['true', true],
['false', false],
['True', true],
['False', false],
[, false],
[true, true],
[false, false],
['gibberish', false],
[0, false],
[1, true]
];
for (var i = 0; i < booleanTests.length; i++){
var lhs = Utils.parseBoolean(booleanTests[i][0]);
var rhs = booleanTests[i][1];
var result = lhs === rhs;
if (result){
console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tpass');
} else {
console.log('Utils.parseBoolean('+booleanTests[i][0]+') === '+booleanTests[i][1]+'\t : \tfail');
}
}
};
S'appuyant sur la réponse de Steven ci-dessus, j'ai écrit cette fonction en tant qu'analyseur générique pour l'entrée de chaîne:
parse:
function (value) {
switch (value && value.toLowerCase()) {
case null: return null;
case "true": return true;
case "false": return false;
default: try { return parseFloat(value); } catch (e) { return value; }
}
}
Boolean.parse() existe dans certaines implémentations de navigateur. Ce n'est certainement pas universel, donc si c'est quelque chose dont vous avez besoin, vous ne devriez pas utiliser cette méthode. Mais dans Chrome, par exemple (j'utilise v21), cela fonctionne très bien et comme on pourrait s'y attendre.
Solution simple, je l'utilise depuis un moment
function asBoolean(value) {
return (''+value) === 'true';
}
// asBoolean(true) ==> true
// asBoolean(false) ==> false
// asBoolean('true') ==> true
// asBoolean('false') ==> false
Le moyen le plus rapide et sûr de convertir une chaîne en un booléen dans une ligne de code
Une des fonctionnalités qui aident à accélérer l'exécution du code en Javascript est Evaluation du court-circuit :
Comme les expressions logiques sont évaluées de gauche à droite, elles sont testées pour une éventuelle évaluation "en court-circuit" en utilisant les règles suivantes:
- false && (n'importe quoi) est évalué par court-circuit à false.
- vrai || (n'importe quoi) est évalué en court-circuit à vrai.
Ainsi, si vous voulez tester une valeur de chaîne comme étant true sur false dans JSON.parse comme moyen de test et de conserver une performance solide, vous pouvez utiliser l'opérateur || pour exclure le code lent de l'exécution dans le cas où la valeur de test est de type booléen.
test === true || ['true','yes','1'].indexOf(test.toString().toLowerCase()) > -1
Comme la méthode Array.prototype.indexOf() fait partie de la norme ECMA-262 de la 5ème édition, vous aurez peut-être besoin de polyfill = pour le support des anciens navigateurs.
// Production steps of ECMA-262, Edition 5, 15.4.4.14
// Reference: http://es5.github.io/#x15.4.4.14
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function(searchElement, fromIndex) {
var k;
// 1. Let O be the result of calling ToObject passing
// the this value as the argument.
if (this == null) {
throw new TypeError('"this" is null or not defined');
}
var O = Object(this);
// 2. Let lenValue be the result of calling the Get
// internal method of O with the argument "length".
// 3. Let len be ToUint32(lenValue).
var len = O.length >>> 0;
// 4. If len is 0, return -1.
if (len === 0) {
return -1;
}
// 5. If argument fromIndex was passed let n be
// ToInteger(fromIndex); else let n be 0.
var n = +fromIndex || 0;
if (Math.abs(n) === Infinity) {
n = 0;
}
// 6. If n >= len, return -1.
if (n >= len) {
return -1;
}
// 7. If n >= 0, then Let k be n.
// 8. Else, n<0, Let k be len - abs(n).
// If k is less than 0, then let k be 0.
k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
// 9. Repeat, while k < len
while (k < len) {
// a. Let Pk be ToString(k).
// This is implicit for LHS operands of the in operator
// b. Let kPresent be the result of calling the
// HasProperty internal method of O with argument Pk.
// This step can be combined with c
// c. If kPresent is true, then
// i. Let elementK be the result of calling the Get
// internal method of O with the argument ToString(k).
// ii. Let same be the result of applying the
// Strict Equality Comparison Algorithm to
// searchElement and elementK.
// iii. If same is true, return k.
if (k in O && O[k] === searchElement) {
return k;
}
k++;
}
return -1;
};
}
Ce qui suit suffirait
String.prototype.boolean = function() {
return "true" == this;
};
"true".boolean() // returns true "false".boolean() // returns false
Une façon plus courte d'écrire ceci pourrait être var isTrueSet = (myValue === "true") ? true : false; En supposant que "vrai" est vrai et que les autres valeurs sont fausses.
Pour évaluer à la fois les chaînes booléennes et booléennes, j'ai utilisé cette formule simple:
var trueOrStringTrue = (trueOrStringTrue === true) || (trueOrStringTrue === 'true');
Comme il est évident, cela deviendra vrai à la fois vrai et "vrai". Tout le reste retourne faux.
Pour TypeScript, nous pouvons utiliser la fonction:
export function stringToBoolean(s: string, valueDefault: boolean = false): boolean {
switch(s.toLowerCase())
{
case "true":
case "1":
case "on":
case "yes":
case "y":
return true;
case "false":
case "0":
case "off":
case "no":
case "n":
return false;
}
return valueDefault;
}
Vous n'avez même pas besoin de convertir la chaîne en booléen. utilisez simplement ce qui suit: var yourstring = yourstringValue == 1 ? true : false;
Si un autre code convertit la valeur booléenne en chaîne, vous devez savoir exactement comment ce code stocke les valeurs true/false. Ou alors vous devez avoir accès à une fonction qui inverse cette conversion.
Il existe une infinité de façons de représenter des valeurs booléennes dans des chaînes ("true", "Y", "1", etc.). Donc, vous ne devriez pas vous fier à un convertisseur généraliste de chaîne à booléen, comme Boolean (myValue). Vous devez utiliser une routine qui inverse la conversion booléenne en chaîne d'origine, quelle qu'elle soit.
Si vous savez qu'il convertit les vrais booléens en "vraies" chaînes, votre exemple de code suffit. Sauf que vous devriez utiliser === au lieu de ==, il n'y a donc pas de conversion de type automatique.
MyLib.Convert.bool = function(param) {
var res = String(param).toLowerCase();
return !(!Boolean(res) || res === "false" || res === "0");
};
function returnBoolean(str){
str=str.toString().toLowerCase();
if(str=='true' || str=='1' || str=='yes' || str=='y' || str=='on' || str=='+'){
return(true);
}
else if(str=='false' || str=='0' || str=='no' || str=='n' || str=='off' || str=='-'){
return(false);
}else{
return(undefined);
}
}
Attention, peut-être qu'à l'avenir le code changera et renverra un booléen au lieu d'une chaîne pour le moment.
La solution serait:
//Currently
var isTrue = 'true';
//In the future (Other developer change the code)
var isTrue = true;
//The solution to both cases
(isTrue).toString() == 'true'
Prenez votre temps en utilisant cette librairie.
https://github.com/rohmanhm/force-boolean
il vous suffit d'écrire une seule ligne
const ForceBoolean = require('force-boolean')
const YOUR_VAR = 'false'
console.log(ForceBoolean(YOUR_VAR)) // it's return boolean false
C'est aussi un support pour suivre
return false if value is number 0
return false if value is string '0'
return false if value is string 'false'
return false if value is boolean false
return true if value is number 1
return true if value is string '1'
return true if value is string 'true'
return true if value is boolean true
J'utilise cet extrait pour convertir des nombres et des booléens:
var result = !isNaN(value) ? parseFloat(value) : /^\s*(true|false)\s*$/i.exec(value) ? RegExp.$1.toLowerCase() === "true" : value;
J'utilise celui-ci lorsque j'obtiens de la valeur d'URL/Form ou d'une autre source.
C'est un code assez universel.
Peut-être pas le meilleur pour la performance, si vous avez besoin de l'exécuter des millions de fois, faites-le-moi savoir, nous pouvons vérifier comment l'optimiser, sinon c'est plutôt bon et personnalisable.
boolResult = !(['false', '0', '', 'undefined'].indexOf(String(myVar).toLowerCase().trim()) + 1);
Résultat:
myVar = true; // true
myVar = 'true'; // true
myVar = 'TRUE'; // true
myVar = '1'; // true
myVar = 'any other value not related to false'; // true
myVar = false; // false
myVar = 'false'; // false
myVar = 'FALSE'; // false
myVar = '0'; // false
Le moyen le plus simple que j'utilise toujours est l'opérateur ternaire:
let value = 'true';
let output = value === 'true' ? true : false;
var trueVals = ["y", "t", "yes", "true", "gimme"];
var isTrueSet = (trueVals.indexOf(myValue) > -1) ? true : false;
ou même juste
var trueVals = ["y", "t", "yes", "true", "gimme"];
var isTrueSet = (trueVals.indexOf(myValue) > -1);
Semblable à certaines des déclarations de commutateur, mais plus compact. La valeur renvoyée ne sera vraie que si la chaîne est l'une des chaînes trueVals. Tout le reste est faux. Naturellement, vous voudrez peut-être normaliser la chaîne d'entrée pour la mettre en minuscule et réduire les espaces.
Pour obtenir des valeurs booléennes à partir d'une chaîne ou d'un nombre Voici une bonne solution:
var boolValue = Boolean(Number('0'));
var boolValue = Boolean(Number('1'));
Le premier retournera false et le second retournera true.
Vous pouvez utiliser Function pour renvoyer une valeur Boolean à partir de la chaîne "true" ou "false"
const TRUE_OR_FALSE = str => new Function(`return ${str}`)();
const [TRUE, FALSE] = ["true", "false"];
const [T, F] = [TRUE_OR_FALSE(TRUE), TRUE_OR_FALSE(FALSE)];
console.log(T, typeof T); // `true` `"boolean"`
console.log(F, typeof F); // `false` `"boolean"`Dans nodejs en utilisant node-boolify c'est possible
Résultats de la conversion booléenne
Boolify(true); //true
Boolify('true'); //true
Boolify('TRUE'); //null
Boolify(1); //true
Boolify(2); //null
Boolify(false); //false
Boolify('false'); //false
Boolify('FALSE'); //null
Boolify(0); //false
Boolify(null); //null
Boolify(undefined); //null
Boolify(); //null
Boolify(''); //null
Convertir une chaîne en booléen
var vIn = "true";
var vOut = vIn.toLowerCase()=="true"?1:0;
Convertir une chaîne en nombre
var vIn = 0;
var vOut = parseInt(vIn,10/*base*/);
La fonction `toBoolean 'retourne false pour null, undefined,' ',' false '. Il retourne true pour toute autre chaîne:
const toBoolean = (bool) => {
if (bool === 'false') bool = false
return !!bool
}
toBoolean('false') // returns false