Convertir le résultat booléen dans nombre de/nombre entier

J'ai une variable qui stocke false ou true, mais j'ai besoin de 0 ou 1 au lieu de cela, respectivement. Comment puis-je faire cela?

Voici une comparaison des performances de certains de ses techniques: jsperf.com/conversion-from-boolean-to-number.
Node.JS les utilisateurs souhaitent utiliser bool === true ? 1 : 0, comme il est de loin le plus rapide en V8.
ou tout simplement bool ? 1 : 0;

InformationsquelleAutor hd. | 2011-10-19

291

Javascript est un opérateur ternaire, vous pouvez utiliser:
```
var i = result ? 1 : 0;
```
- Meilleure réponse. Pourquoi? Cela fonctionne sur truthiness qui est plus général et accepte tout type (chaîne, nombre, etc.) Unaire réponse est intelligent, certes, mais si je le passe une chaîne, il retourne NaN. Donc, si vous voulez 3LL3 et la garantie de l'entrée, allez urary, sinon il me semble que le ternaire + truthy test est le meilleur.
InformationsquelleAutor Andy Rose
384

Utiliser le unaire + de l'opérateur, qui convertit son opérande dans un certain nombre.
```
+ true; //1
+ false; //0
```
Note, bien sûr, que vous devriez toujours nettoyer les données sur le côté serveur, car un utilisateur peut envoyer des données à votre serveur, n'importe ce que le code côté client dit.
- Quoique cool (je n'avais jamais pensé à cela), c'est incroyablement lent (97% plus lent en Chrome, pour être exact). Méfiez-vous!
- Merci: c'est fascinant. En fait, non, c'est étonnant. Si une comparaison avec le Nombre constructeur serait aussi intéressant...
- Découvrez cette révision. Number() est encore plus lente.
- Il semble bool === true ? 1 : 0 est le plus rapide, avec une seconde près de bool | 0.
- En multipliant (par exemple 3*false) se sent si mal, mais il fonctionne. 🙂 Merci!
- Étrange, méthode plus rapide ici, dans mon chrome... testé avec des performances.maintenant() dans cette fonction,function timeit(a, b, c, d) {c = performance.now(); for(d = 0; d < b; d++) a(); return performance.now()-c}. Passer de la fonction et le nombre de boucles.
InformationsquelleAutor lonesomeday
97

À mon humble avis, la meilleure solution est:
```
fooBar | 0
```
Il est utilisé dans les asm.js à force de type entier.
- L'un des plus rapides; +1.
- Une belle. Aussi, vous pourriez utiliser "Boolean ^ 0". OU ou exclusif (XOR), œuvres.
- Ou fooBar & 1.
- Il est le plus rapide: jsPerf (par @Gal Talmor)
- Il est le plus rapide: jsPerf
- Cela ne renvoie pas une 1 nombre entier si fooBar n'est pas?
- que voulez-vous dire? Je ne comprends pas la question...
InformationsquelleAutor kralyk
48

Je préfère utiliser le Numéro de la fonction. Il prend un objet et le convertit en un nombre.

Exemple:
```
var myFalseBool = false;
var myTrueBool = true;

var myFalseInt = Number(myFalseBool);
console.log(myFalseInt == 0);

var myTrueInt = Number(myTrueBool);
console.log(myTrueInt == 1);
```
Ou de l'exécuter dans jsFiddle.
- C'est la meilleure réponse, et de loin. Au fond de la cours. Seul "il prend un objet" n'est pas de droit.
- Lien vers mdn est beaucoup mieux que w3schools(eeek !): developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
- Je pense que c'est le meilleur moyen, car il est facile à lire et l'intention d'en révéler.
- Il est également le plus lent.
InformationsquelleAutor René
36

J'ai créé un JSperf comparaison de toutes les réponses suggérées.

TL;DR - la meilleure option pour tous les navigateurs actuels est:
```
val | 0;
```
.

Mise à jour:

Il semble que ces jours, ils sont tous assez identiques, sauf que la Number() de la fonction est le plus lent, tandis que le mieux étant val === true ? 1 : 0;.
- Fait intéressant, le ternaire est maintenant plus rapide en Chrome 64.0.3282 sur macOS 10.13.3.
InformationsquelleAutor Gal Talmor
31

Tapé la façon de le faire serait:
```
Number(true) //1
Number(false) //0
```
InformationsquelleAutor Philip Miglinci
28

Je viens de tomber sur ce raccourci aujourd'hui.

~~(vrai)

~~(faux)

Des gens beaucoup plus intelligents que ce que je peux expliquer:

http://james.padolsey.com/javascript/double-bitwise-not/
- Intéressant. J'ai appris quelque chose de nouveau aujourd'hui. Je ne vais pas utiliser cette technique dans tout projet, même si, en raison de son potentiel de confondre l'avenir-moi ou coéquipiers.
- hacky js est ma fav. sérieusement, +1
InformationsquelleAutor tonyjcamp
15

Quand le JavaScript s'attend à un nombre de valeur, mais reçoit un booléen plutôt elle qui convertit booléen dans un certain nombre: le vrai et le faux convertir en 1 et 0 respectivement. De sorte que vous pouvez prendre avantage de cela;

JS:
```
var t = true;
var f = false;

console.log(t*1); //t*1 === 1
console.log(f*1); //f*1 === 0 

console.log(+t); //0+t === 1 or shortened to +t === 1
console.log(+f); //0+f === 0 or shortened to +f === 0
```
Lecture des Conversions de Type Chapitre 3.8 de The Definitive Guide to Javascript.

InformationsquelleAutor Charlie Lynch
12

Je viens de régler cette question dans la partie du code que j'écrivais. Ma solution a été d'utiliser un bit à bit et.
```
var j = bool & 1;
```
Un moyen plus rapide pour traiter un problème constant serait de créer une fonction. C'est plus lisible par d'autres personnes, mieux pour la compréhension lors de la phase d'entretien, et de se débarrasser de il est possible d'écrire quelque chose de mal.
```
function toInt( val ) {
    return val & 1;
}

var j = toInt(bool);
```
Édition - septembre 10th, 2014

Pas de conversion à l'aide d'un opérateur ternaire à l'identique de l'opérateur est plus rapide en Chrome pour une raison quelconque. N'a pas de sens pour expliquer pourquoi il est plus rapide, mais je suppose que c'est une sorte de bas niveau de l'optimisation qui a du sens, quelque part le long du chemin.
```
var j = boolValue === true ? 1 : 0;
```
Test pour vous-même: http://jsperf.com/boolean-int-conversion/2

Dans FireFox et Internet Explorer, à l'aide de la version que j'ai posté est plus rapide en général.

Édition - 14 juillet 2017

Bon, je ne vais pas vous dire que vous devriez ou ne devriez pas les utiliser. Chaque flipper navigateur a été de monter et descendre dans comment rapide ils peuvent faire l'opération avec chaque méthode. Chrome à un point réellement eu le bit-à-bit & version faire mieux que les autres, mais tout à coup, était bien pire. Je ne sais pas ce qu'ils font, donc je vais juste le laisser à qui s'en soucie. Il y a rarement une raison pour se soucier de la façon rapide d'une opération de ce genre est fait. Même sur mobile c'est un rien de fonctionnement.

Aussi, voici une nouvelle méthode pour l'ajout d'un "toInt' prototype qui ne peuvent être remplacés.
```
Object.defineProperty(Boolean.prototype, "toInt", { value: function()
{
    return this & 1;
}});
```
- J'ai eu deux downvotes pour ce poste. Pourquoi ne pas vous expliquer pourquoi vous downvoted il. Sinon, c'est juste un downvote sans justification.
- 99 fois les résultats de jsperf juste vous conduire jusqu'à l'optimisation prématurée chemin, l'optimisation de nanosecondes hors d'une boucle lorsque vous devrait être concentré sur ce vilain instruction SQL à la place. merci de me donner quelques différentes façons d'aborder cette
- Quelle instruction SQL? Il n'y a pas une seule requête ici. Si vous faites allusion à l'JSPerf, j'ai été liaison de quelqu'un d'autre test. Ce n'est pas mon propre. Honnêtement, je ne se soucient pas de l'aspect performance, car c'est un rien de fonctionnement. J'ai créé ma propre langue, qui était près de fonctionnalités identiques à celles de JS et je me souviens que la conversion en int a été bêtement un fonctionnement rapide. L'escalade prototype chaînes ne l'était pas. C'est pourquoi je voudrais encore vous recommandons de le premier que j'ai fait, avec une fonction simple qui peut être incorporé par le compilateur.
- le SQL chose 'twas une généralisation. merci pour l'aperçu
InformationsquelleAutor Nicholas R. Grant
11

Unaire + opérateur prendra soin de cela:
```
var test = true;
//+test === 1
test = false;
//+test === 0
```
Vous souhaiterez tout naturellement à la santé mentale-le vérifier sur le serveur avant de les stocker, de sorte que peut-être un plus raisonnable pour ce faire, de toute façon, si.
- J'ai changé les commentaires de ===, parce que true == 1 est vrai même sans la "conversion explicite 🙂 true === 1 au lieu de cela est faux.
InformationsquelleAutor Gustav Barkefors
9

Vous pouvez également ajouter 0, l'utilisation d'opérateurs de décalage ou xor:
```
val + 0;
val ^ 0;
val >> 0;
val >>> 0;
val << 0;
```
Ces ont les mêmes débits que ceux des autres réponses.

InformationsquelleAutor REMqb
4

Vous pouvez le faire par une simple extension de la boolean prototype
```
Boolean.prototype.intval = function(){return ~~this}
```
Il n'est pas trop facile de comprendre ce qui se passe il y a donc une version alternative serait
```
Boolean.prototype.intval = function(){return (this == true)?1:0}
```
avoir fait ce que vous pouvez faire des trucs comme
```
document.write(true.intval());
```
Quand j'ai utiliser des booléens pour stocker des conditions souvent, je les convertir en bitfields auquel cas j'ai fini par utiliser une version étendue de la fonction prototype
```
Boolean.prototype.intval = function(places)
{
 places = ('undefined' == typeof(places))?0:places; 
 return (~~this) << places
}
```
avec lequel vous pouvez faire
```
document.write(true.intval(2))
```
qui produit 4 comme sa sortie.

InformationsquelleAutor DroidOS

let integerVariable = booleanVariable * 1;

InformationsquelleAutor Esger

J'ai testé tous ces exemples, j'ai fait un test, et enfin je vous recommande de choisir la plus courte, il n'affecte pas les performances.

Gérée sous Ubuntu server 14.04, nodejs v8.12.0 - 26/10/18

    let i = 0;
console.time("TRUE test1")
i=0;
for(;i<100000000;i=i+1){
true ? 1 : 0;
}
console.timeEnd("TRUE test1")
console.time("FALSE test2")
i=0;
for(;i<100000000;i=i+1){
false ? 1 : 0;
}
console.timeEnd("FALSE test2")
console.log("----------------------------")
console.time("TRUE test1.1")
i=0;
for(;i<100000000;i=i+1){
true === true ? 1 : 0;
}
console.timeEnd("TRUE test1.1")
console.time("FALSE test2.1")
i=0;
for(;i<100000000;i=i+1){
false === true ? 1 : 0;
}
console.timeEnd("FALSE test2.1")
console.log("----------------------------")
console.time("TRUE test3")
i=0;
for(;i<100000000;i=i+1){
true | 0;
}
console.timeEnd("TRUE test3")
console.time("FALSE test4")
i=0;
for(;i<100000000;i=i+1){
false | 0;
}
console.timeEnd("FALSE test4")
console.log("----------------------------")
console.time("TRUE test5")
i=0;
for(;i<100000000;i=i+1){
true * 1;
}
console.timeEnd("TRUE test5")
console.time("FALSE test6")
i=0;
for(;i<100000000;i=i+1){
false * 1;
}
console.timeEnd("FALSE test6")
console.log("----------------------------")
console.time("TRUE test7")
i=0;
for(;i<100000000;i=i+1){
true & 1;
}
console.timeEnd("TRUE test7")
console.time("FALSE test8")
i=0;
for(;i<100000000;i=i+1){
false & 1;
}
console.timeEnd("FALSE test8")
console.log("----------------------------")
console.time("TRUE test9")
i=0;
for(;i<100000000;i=i+1){
+true;
}
console.timeEnd("TRUE test9")
console.time("FALSE test10")
i=0;
for(;i<100000000;i=i+1){
+false;
}
console.timeEnd("FALSE test10")
console.log("----------------------------")
console.time("TRUE test9.1")
i=0;
for(;i<100000000;i=i+1){
0+true;
}
console.timeEnd("TRUE test9.1")
console.time("FALSE test10.1")
i=0;
for(;i<100000000;i=i+1){
0+false;
}
console.timeEnd("FALSE test10.1")
console.log("----------------------------")
console.time("TRUE test9.2")
i=0;
for(;i<100000000;i=i+1){
-true*-1;
}
console.timeEnd("TRUE test9.2")
console.time("FALSE test10.2")
i=0;
for(;i<100000000;i=i+1){
-false*-1;
}
console.timeEnd("FALSE test10.2")
console.log("----------------------------")
console.time("TRUE test9.3")
i=0;
for(;i<100000000;i=i+1){
true-0;
}
console.timeEnd("TRUE test9.3")
console.time("FALSE test10.3")
i=0;
for(;i<100000000;i=i+1){
false-0;
}
console.timeEnd("FALSE test10.3")
console.log("----------------------------")
console.time("TRUE test11")
i=0;
for(;i<100000000;i=i+1){
Number(true);
}
console.timeEnd("TRUE test11")
console.time("FALSE test12")
i=0;
for(;i<100000000;i=i+1){
Number(false);
}
console.timeEnd("FALSE test12")
console.log("----------------------------")
console.time("TRUE test13")
i=0;
for(;i<100000000;i=i+1){
true + 0;
}
console.timeEnd("TRUE test13")
console.time("FALSE test14")
i=0;
for(;i<100000000;i=i+1){
false + 0;
}
console.timeEnd("FALSE test14")
console.log("----------------------------")
console.time("TRUE test15")
i=0;
for(;i<100000000;i=i+1){
true ^ 0;
}
console.timeEnd("TRUE test15")
console.time("FALSE test16")
i=0;
for(;i<100000000;i=i+1){
false ^ 0;
}
console.timeEnd("FALSE test16")
console.log("----------------------------")
console.time("TRUE test17")
i=0;
for(;i<100000000;i=i+1){
true ^ 0;
}
console.timeEnd("TRUE test17")
console.time("FALSE test18")
i=0;
for(;i<100000000;i=i+1){
false ^ 0;
}
console.timeEnd("FALSE test18")
console.log("----------------------------")
console.time("TRUE test19")
i=0;
for(;i<100000000;i=i+1){
true >> 0;
}
console.timeEnd("TRUE test19")
console.time("FALSE test20")
i=0;
for(;i<100000000;i=i+1){
false >> 0;
}
console.timeEnd("FALSE test20")
console.log("----------------------------")
console.time("TRUE test21")
i=0;
for(;i<100000000;i=i+1){
true >>> 0;
}
console.timeEnd("TRUE test21")
console.time("FALSE test22")
i=0;
for(;i<100000000;i=i+1){
false >>> 0;
}
console.timeEnd("FALSE test22")
console.log("----------------------------")
console.time("TRUE test23")
i=0;
for(;i<100000000;i=i+1){
true << 0;
}
console.timeEnd("TRUE test23")
console.time("FALSE test24")
i=0;
for(;i<100000000;i=i+1){
false << 0;
}
console.timeEnd("FALSE test24")
console.log("----------------------------")
console.time("TRUE test25")
i=0;
for(;i<100000000;i=i+1){
~~true;
}
console.timeEnd("TRUE test25")
console.time("FALSE test26")
i=0;
for(;i<100000000;i=i+1){
~~false;
}
console.timeEnd("FALSE test26")
console.log("----------------------------")
console.time("TRUE test25.1")
i=0;
for(;i<100000000;i=i+1){
~true*-1-1;
}
console.timeEnd("TRUE test25.1")
console.time("FALSE test26.1")
i=0;
for(;i<100000000;i=i+1){
~false*-1-1;
}
console.timeEnd("FALSE test26.1")
console.log("----------------------------")
console.time("TRUE test27")
i=0;
for(;i<100000000;i=i+1){
true/1;
}
console.timeEnd("TRUE test27")
console.time("FALSE test28")
i=0;
for(;i<100000000;i=i+1){
false/1;
}
console.timeEnd("FALSE test28")

Résultat

TRUE test1: 93.301ms
FALSE test2: 102.854ms
----------------------------
TRUE test1.1: 118.979ms
FALSE test2.1: 119.061ms
----------------------------
TRUE test3: 97.265ms
FALSE test4: 108.389ms
----------------------------
TRUE test5: 85.854ms
FALSE test6: 87.449ms
----------------------------
TRUE test7: 83.126ms
FALSE test8: 84.992ms
----------------------------
TRUE test9: 99.683ms
FALSE test10: 87.080ms
----------------------------
TRUE test9.1: 85.587ms
FALSE test10.1: 86.050ms
----------------------------
TRUE test9.2: 85.883ms
FALSE test10.2: 89.066ms
----------------------------
TRUE test9.3: 86.722ms
FALSE test10.3: 85.187ms
----------------------------
TRUE test11: 86.245ms
FALSE test12: 85.808ms
----------------------------
TRUE test13: 84.192ms
FALSE test14: 84.173ms
----------------------------
TRUE test15: 81.575ms
FALSE test16: 81.699ms
----------------------------
TRUE test17: 81.979ms
FALSE test18: 81.599ms
----------------------------
TRUE test19: 81.578ms
FALSE test20: 81.452ms
----------------------------
TRUE test21: 115.886ms
FALSE test22: 88.935ms
----------------------------
TRUE test23: 82.077ms
FALSE test24: 81.822ms
----------------------------
TRUE test25: 81.904ms
FALSE test26: 82.371ms
----------------------------
TRUE test25.1: 82.319ms
FALSE test26.1: 96.648ms
----------------------------
TRUE test27: 89.943ms
FALSE test28: 83.646ms

InformationsquelleAutor DarckBlezzer

essayer

val*1

JS:

let t=true;
let f=false;
console.log(t*1);
console.log(f*1)

InformationsquelleAutor Kamil Kiełczewski

Vous devez vous connecter pour publier un commentaire.