Comment puis-je vérifier qu'un nombre est flottant ou entier?
Comment trouver qu'un nombre est float ou integer?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
vérifier le reste en divisant par 1:
function isInt(n) {
return n % 1 === 0;
}
Si vous ne savez pas que l'argument est un nombre, vous avez besoin de deux tests:
function isInt(n){
return Number(n) === n && n % 1 === 0;
}
function isFloat(n){
return Number(n) === n && n % 1 !== 0;
}
Mise à jour 2019 5 ans après la rédaction de cette réponse, une solution a été normalisée dans ECMA Script 2015. Cette solution est couverte dans cette réponse =.
Testez ces fonctions pour vérifier si une valeur est une valeur primitive numérique qui n’a pas de fraction et se situe dans les limites de taille de ce qui peut être représenté sous la forme d’un entier exact.
function isFloat(n) {
return n === +n && n !== (n|0);
}
function isInteger(n) {
return n === +n && n === (n|0);
}
Pourquoi pas quelque chose comme ça:
var isInt = function(n) { return parseInt(n) === n };
Il existe une méthode appelée Number.isInteger() qui est actuellement implémentée dans tout sauf IE. MDN fournit également un polyfill pour les autres navigateurs:
Number.isInteger = Number.isInteger || function(value) {
return typeof value === 'number' &&
isFinite(value) &&
Math.floor(value) === value;
};
Cependant, dans la plupart des cas d'utilisation, il vaut mieux utiliser Number.isSafeInteger, qui vérifie également si la valeur est si élevée/faible que les décimales auraient été perdues de toute façon. MDN possède également un polyfil. (Vous avez également besoin de la isInteger pollyfill ci-dessus.)
if (!Number.MAX_SAFE_INTEGER) {
Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};
Vous pouvez utiliser une expression régulière simple:
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
Ou vous pouvez également utiliser les fonctions ci-dessous, selon vos besoins. Ils sont développés par le Projet PHPJS .
is_int() => Vérifier si le type de variable est un entier et si son contenu est un entier
is_float() => Vérifier si le type de variable est float et si son contenu est float
ctype_digit() => Vérifier si le type de variable est une chaîne et si son contenu ne contient que des chiffres décimaux
Mise à jour 1
Maintenant, il vérifie aussi les nombres négatifs, merci pour @ commentaire de ChrisBartley !
Voici des fonctions efficaces qui vérifient si la valeur est un nombre ou peut être converti en toute sécurité en un nombre:
function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}
Et pour les entiers (renverrait false si la valeur est un float):
function isInteger(value) {
if ((undefined === value) || (null === value)) {
return false;
}
return value % 1 == 0;
}
L'efficacité ici est que parseInt (ou parseNumber) est évité lorsque la valeur est déjà un nombre. Les deux fonctions d'analyse toujours convertissent d'abord en chaîne, puis tentent d'analyser cette chaîne, ce qui constituerait un gaspillage si la valeur est déjà un nombre.
Merci aux autres messages ici pour avoir fourni d'autres idées d'optimisation!
function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }
// give it a spin
isInteger(1.0); // true
isFloat(1.0); // false
isFloat(1.2); // true
isInteger(1.2); // false
isFloat(1); // false
isInteger(1); // true
isFloat(2e+2); // false
isInteger(2e+2); // true
isFloat('1'); // false
isInteger('1'); // false
isFloat(NaN); // false
isInteger(NaN); // false
isFloat(null); // false
isInteger(null); // false
isFloat(undefined); // false
isInteger(undefined); // false
function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
fonctionne pour tous les cas.
Comme d’autres l’ont mentionné, vous n’avez que des doubles en JS. Alors, comment définissez-vous un nombre étant un entier? Il suffit de vérifier si le nombre arrondi est égal à lui-même:
function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
Voici ce que j'utilise pour les entiers:
Math.ceil(parseFloat(val)) === val
Bref, sympa :) ça marche tout le temps. C'est ce que suggère David Flanagan si je ne me trompe pas.
var isInt = function (n) { return n === (n | 0); };
Je n'ai pas eu de cas où cela n'a pas fait le travail.
Ce n'est pas vraiment compliqué. La valeur numérique des équivalents parseFloat () et parseInt () d'un entier sera la même. Ainsi, vous pouvez faire comme si:
function isInt(value){
return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}
Ensuite
if (isInt(x)) // do work
Cela permettra également d'effectuer des vérifications de chaîne et n'est donc pas strict. Si vous voulez une solution de type fort (aka, ne fonctionnera pas avec des chaînes):
function is_int(value){ return !isNaN(parseInt(value * 1) }
Tout nombre flottant avec une partie décimale nulle (par exemple 1.0, 12.00, 0.0) est implicitement converti en entier, il est donc impossible de vérifier s'il est flottant ou non.
!!(24%1) // false
!!(24.2%1) // true
Celui-ci, ça va?
isFloat(num) {
return typeof num === "number" && !Number.isInteger(num);
}
Cela dépend vraiment de ce que vous voulez réaliser. Si vous voulez "émuler" des langages fortement typés, je vous suggère de ne pas essayer. Comme d'autres l'ont mentionné, tous les nombres ont la même représentation (le même type).
En utilisant quelque chose comme Claudi fourni:
isInteger( 1.0 ) -> true
ce qui semble bien pour le bon sens, mais dans quelque chose comme C, vous obtiendrez false
Cette solution a fonctionné pour moi.
<html>
<body>
<form method="post" action="#">
<input type="text" id="number_id"/>
<input type="submit" value="send"/>
</form>
<p id="message"></p>
<script>
var flt=document.getElementById("number_id").value;
if(isNaN(flt)==false && Number.isInteger(flt)==false)
{
document.getElementById("message").innerHTML="the number_id is a float ";
}
else
{
document.getElementById("message").innerHTML="the number_id is a Integer";
}
</script>
</body>
</html>
function isInteger(n) {
return ((typeof n==='number')&&(n%1===0));
}
function isFloat(n) {
return ((typeof n==='number')&&(n%1!==0));
}
function isNumber(n) {
return (typeof n==='number');
}
CECI IS CODE FINAL POUR LE CONTRÔLE À LA FOIS INT et FLOAT
function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}
OR
function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}
J'ai écrit la fonction qui accepte les chaînes (si quelqu'un aura besoin)
function isInt(x) {
return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}
function isFloat(x) {
return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}
exemple ouptuts:
console.log(isFloat('0.2')) // true
console.log(isFloat(0.2)) // true
console.log(isFloat('.2')) // true
console.log(isFloat('-.2')) // true
console.log(isFloat(-'.2')) // true
console.log(isFloat(-.2)) // true
console.log(isFloat('u.2')) // false
console.log(isFloat('2')) // false
console.log(isFloat('0.2u')) // false
console.log(isInt('187')) // true
console.log(isInt(187)) // true
console.log(isInt('1.2')) // false
console.log(isInt('-2')) // true
console.log(isInt(-'1')) // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1)) // true
C'est simple comme:
if( n === parseInt(n) ) ...
Essayez ceci dans la console:
x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously
// BUT!
x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!
Cela déroute beaucoup de gens. Chaque fois que quelque chose est 0,0, ce n'est plus un float. C'est un entier. Ou vous pouvez simplement l'appeler "une chose numérique" car il n'y a pas de distinction stricte comme à l'époque en C. Bon vieux temps.
Donc, fondamentalement, tout ce que vous pouvez faire est de vérifier l'entier en acceptant le fait que 1.000 est un entier.
Note latérale intéressante
Il y avait un commentaire sur les chiffres énormes. Des nombres énormes ne signifient aucun problème pour cette approche; chaque fois que parseInt est incapable de gérer le nombre (car il est trop grand), il retournera autre chose que la valeur réelle, ainsi le test renverra FALSE. C’est une bonne chose, car si vous considérez quelque chose comme un "nombre", vous vous attendez normalement à ce que JS puisse calculer avec cela - alors, oui, les nombres sont limités et parseInt tiendra compte de ceci , pour le dire de cette façon.
Essaye ça:
<script>
var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);
</script>
Dans mon navigateur (IE8), cela retourne "a est ok; b échoue", ce qui est exactement dû au nombre énorme dans b. La limite peut varier mais je suppose que 20 chiffres "devrait être suffisant pour tout le monde", pour citer un classique :)
En essayant certaines des réponses ici, j'ai fini par écrire cette solution. Cela fonctionne aussi avec des nombres dans une chaîne.
function isInt(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
return !(number - parseInt(number));
}
function isFloat(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
return number - parseInt(number) ? true : false;
}
var tests = {
'integer' : 1,
'float' : 1.1,
'integerInString' : '5',
'floatInString' : '5.5',
'negativeInt' : -345,
'negativeFloat' : -34.98,
'negativeIntString' : '-45',
'negativeFloatString' : '-23.09',
'notValidFalse' : false,
'notValidTrue' : true,
'notValidString' : '45lorem',
'notValidStringFloat' : '4.5lorem',
'notValidNan' : NaN,
'notValidObj' : {},
'notValidArr' : [1,2],
};
function isInt(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
return !(number - parseInt(number));
}
function isFloat(number) {
if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
return number - parseInt(number) ? true : false;
}
function testFunctions(obj) {
var keys = Object.keys(obj);
var values = Object.values(obj);
values.forEach(function(element, index){
console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
});
}
testFunctions(tests);Pour les entiers j'utilise ceci
function integer_or_null(value) {
if ((undefined === value) || (null === value)) {
return null;
}
if(value % 1 != 0) {
return null;
}
return value;
}
Dans le script Java, tous les nombres sont internally 64 bit floating point, comme double en Java. Il n'y a pas de types différents en javascript, ils sont tous représentés par le type number. Par conséquent, vous ne pourrez pas effectuer de vérification instanceof. Cependant, vous pouvez utiliser les solutions ci-dessus pour déterminer s'il s'agit d'un nombre fractionnaire. Les concepteurs de Java scripts ayant le sentiment de ne pouvoir utiliser qu'un seul type peuvent éviter de nombreuses erreurs de transtypage.
C'est à moi:
function isInt(quale) {
var valore = $('#'+quale).val().toLowerCase();
if (isNaN(Number(String(valore))) || (valore.indexOf("e") > 0)) {
// Not int
} else {
// Is Int!
}
}
Et ça:
function isFloat(quale) {
var valore = $('#'+quale).val();
valore = valore.replace(",", "");
if (isNaN(String(valore)) || (valore.indexOf("e") > 0)) {
// Not Float
} else {
// Float
}
}
Ad majora!
Cela n’est peut-être pas aussi performant que la% réponse, ce qui vous évite d’avoir à convertir d’abord une chaîne, mais je n’ai encore vu personne la publier, alors voici une autre option qui devrait fonctionner correctement:
function isInteger(num) {
return num.toString().indexOf('.') === -1;
}
Je trouve cela la manière la plus élégante:
function isInteger(n) {
return n === (n^0);
}
Il est également important de retourner false en cas de valeur non numérique.
Les fonctions ci-dessous protègent contre les chaînes vides, les définitions non définies, les valeurs NULL et les plages de valeurs max/min. Le moteur Javascript devrait avoir intégré ces fonctions dès le premier jour. :)
Prendre plaisir!
function IsInteger(iVal) {
var iParsedVal; //our internal converted int value
iParsedVal = parseInt(iVal,10);
if (isNaN(iParsedVal) || Infinity == iParsedVal || -Infinity == iParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return Number(iVal) === (iParsedVal | 0); //the 2nd operand group (intValue | 0), evaluates to true only if the intValue is an integer; so an int type will only return true
}
function IsFloat(fVal) {
var fParsedVal; //our internal converted float value
fParsedVal = parseFloat(fVal);
if (isNaN(fParsedVal) || Infinity == fParsedVal || -Infinity == fParsedVal) //sanity check - guard against empty strings and max/min values
return false;
else
return !!(fVal % 1); //true only if there is a fractional value after the mod op; the !! returns the opposite value of the op which reflects the function's return value
}
Pour ceux qui sont curieux, en utilisant Benchmark.js, j’ai testé les réponses les plus votées (et celle postée aujourd’hui) sur ce post, voici mes résultats:
var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
// kennebec
.add('0', function() {
return n % 1 == 0;
})
// kennebec
.add('1', function() {
return typeof n === 'number' && n % 1 == 0;
})
// kennebec
.add('2', function() {
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
})
// Axle
.add('3', function() {
return n.toString().indexOf('.') === -1;
})
// Dagg Nabbit
.add('4', function() {
return n === +n && n === (n|0);
})
// warfares
.add('5', function() {
return parseInt(n) === n;
})
// Marcio Simao
.add('6', function() {
return /^-?[0-9]+$/.test(n.toString());
})
// Tal Liron
.add('7', function() {
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
});
// Define logs and Run
suite.on('cycle', function(event) {
console.log(String(event.target));
}).on('complete', function() {
console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });
0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)
Fastest is 7 Tal Liron
try this one
function amountcheck()
{
var dpamt=$('#dpamt').val()/5000;
var ints=dpamt.toString();
var isint=ints.split('.');
if(isint[1]>0)
{
alert('float value');
return false;
}
else
{
alert('int value');
}
}
Condition pour la validation flottante:
if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
Condition pour la validation Integer:
if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
J'espère que cela pourrait être utile.
Voici mon code. Il vérifie que ce n'est pas une chaîne vide (qui passera sinon), puis le convertit au format numérique. Maintenant, selon que vous voulez ou non "1.1" soit égal à 1.1, cela peut être ou ne pas être ce que vous cherchez.
var isFloat = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseFloat(n));
};
var isInteger = function(n) {
n = n.length > 0 ? Number(n) : false;
return (n === parseInt(n));
};
var isNumeric = function(n){
if(isInteger(n) || isFloat(n)){
return true;
}
return false;
};
Inspiré par warfares 'réponse, je l'utilise pour valider une entrée de chaîne.
function validLatLng(n) {
var isInt = function(n) { return parseInt(n) == n };
var isFloat = function(n) { return parseFloat(n) == n };
// For testing
console.log("validLatLng::n", n);
console.log("validLatLng::parseInt", parseInt(n));
console.log("validLatLng::parseFloat", parseFloat(n));
console.log("validLatLng::isInt", isInt(n));
console.log("validLatLng::isFloat", isFloat(n));
return isInt(n) || isFloat(n);
}
Vous pouvez le tester sur la console avec ceci:
// Invalid for my use case
validLatLng("") // or `null`, `undefined`, etc.
validLatLng("a")
validLatLng("a1100")
validLatLng("-100a")
validLatLng("a100.00")
validLatLng("-2a100.00123")
// VALID for my use case
validLatLng("100")
validLatLng("-100")
validLatLng("100.00")
validLatLng("-100.00123")
YourJS fournit les deux fonctions suivantes qui fonctionnent pour tous les nombres, y compris renvoyer false pour -Infinity et Infinity:
function isFloat(x) {
return typeOf(x, 'Number') && !!(x % 1);
}
function isInt(x) {
return typeOf(x, 'Number') && x % 1 == 0;
}
Étant donné que typeOf() est une fonction interne de YourJS, si vous souhaitez utiliser ces définitions, vous pouvez télécharger la version uniquement pour ces fonctions ici: http://yourjs.com/snippets/build/ 34
Sur la base de tout ce que j'ai vu ici, j'ai créé mon propre ensemble de fonctions pour tester ce dont j'ai besoin:
function NumberValidator() {
this.isFloat = function (n) {
return typeof(n)==="number" && n === +n && Math.round(n) !== n;
};
this.isInteger = function (n) {
return typeof(n)==="number" && n === +n && Math.round(n) === n;
};
this.isFloatOrInteger = function (n) {
return this.isFloat(n) || this.isInteger(n);
};
this.isNonZeroFloatOrInteger = function (n) {
return this.isFloatOrInteger(n) && n > 0;
};
this.isNonZeroInteger = function (n) {
return this.isInteger(n) && n > 0;
};
}
Cependant, la solution de shime est plus courte et nécessite moins de contrôles, elle pourrait donc être meilleure.
Je devais vérifier une valeur d'entrée s'il s'agissait d'un entier ou d'un flottant et, pour ce faire, j'ai développé ce qui suit:
function isInteger(x) {
var integer = parseInt(x, 10);
if (!isNaN(integer) && !isFloat(x)) {
return true;
}
return false;
}
function isFloat(x) {
var f = parseFloat(x);
var floor = Math.floor(f);
var fraction = f - floor;
if (fraction > 0) {
return true;
}
return false;
}
var cases = [
"1",
"1.00",
"1.01",
"0.05",
"ab1",
"ab1.1",
1,
1.00,
1.01,
0.05,
1e+5,
"",
true,
false,
null,
NaN,
undefined,
];
console.log("isInteger()");
for (var i = 0; i < cases.length; i++) {
console.log(cases[i], isInteger(cases[i]));
}
console.log("\nisFloat()");
for (var i = 0; i < cases.length; i++) {
console.log(cases[i], isFloat(cases[i]));
}function int(a) {
return a - a === 0 && a.toString(32).indexOf('.') === -1
}
function float(a) {
return a - a === 0 && a.toString(32).indexOf('.') !== -1
}
Vous pouvez ajouter typeof a === 'number' si vous souhaitez exclure des chaînes.
Parfois, les objets Number ne vous permettent pas d’utiliser directement l’opérateur mod (%). Si vous rencontrez ce problème, vous pouvez utiliser cette solution.
if(object instanceof Number ){
if( ((Number) object).doubleValue() % 1 == 0 ){
//your object is an integer
}
else{
//your object is a double
}
}
J'aime cette petite fonction, qui retournera true pour les entiers positifs et négatifs:
function isInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}
Cela fonctionne parce que 1 ou "1" devient "1.0", ce qui isNaN () renvoie false sur (puis nous le nions et le renvoyons), mais 1.0 ou "1.0" devient "1.0.0", tandis que "chaîne" devient "chaîne". 0 ", aucun des deux n'étant un nombre, isNaN () renvoie donc false (et, encore une fois, est annulé).
Si vous ne voulez que des entiers positifs, voici la variante:
function isPositiveInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}
ou, pour les entiers négatifs:
function isNegativeInt(val) {
return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}
isPositiveInt () fonctionne en déplaçant la chaîne numérique concaténée en avant de la valeur à tester. Par exemple, isPositiveInt (1) entraîne isNaN () qui évalue "01", ce qui évalue la valeur false. Pendant ce temps, isPositiveInt (-1) a pour résultat isNaN () qui évalue "0-1", ce qui évalue la valeur true. Nous nions la valeur de retour et cela nous donne ce que nous voulons. isNegativeInt () fonctionne de la même manière, mais sans nier la valeur de retour de isNaN ().
Modifier:
Mon implémentation d'origine renverrait également true sur les tableaux et les chaînes vides. Cette implémentation n'a pas ce défaut. Il a également l'avantage de revenir plus tôt si val n'est pas une chaîne ou un nombre, ou s'il s'agit d'une chaîne vide, ce qui le rend plus rapide dans ces cas-là. Vous pouvez le modifier davantage en remplaçant les deux premières clauses par
typeof(val) != "number"
si vous voulez seulement faire correspondre des nombres littéraux (et non des chaînes)
Modifier:
Je ne peux pas encore publier de commentaires, alors j'ajoute ceci à ma réponse. Le repère publié par @Asok est très informatif; Cependant, la fonction la plus rapide ne correspond pas aux exigences, car elle renvoie également TRUE pour les flottants, les tableaux, les booléens et les chaînes vides.
J'ai créé la suite de tests suivante pour tester chacune des fonctions, en ajoutant également ma réponse à la liste (fonction 8, qui analyse les chaînes, et la fonction 9, qui ne fonctionne pas):
funcs = [
function(n) {
return n % 1 == 0;
},
function(n) {
return typeof n === 'number' && n % 1 == 0;
},
function(n) {
return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
},
function(n) {
return n.toString().indexOf('.') === -1;
},
function(n) {
return n === +n && n === (n|0);
},
function(n) {
return parseInt(n) === n;
},
function(n) {
return /^-?[0-9]+$/.test(n.toString());
},
function(n) {
if ((undefined === n) || (null === n)) {
return false;
}
if (typeof n == 'number') {
return true;
}
return !isNaN(n - 0);
},
function(n) {
return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
}
];
vals = [
[1,true],
[-1,true],
[1.1,false],
[-1.1,false],
[[],false],
[{},false],
[true,false],
[false,false],
[null,false],
["",false],
["a",false],
["1",null],
["-1",null],
["1.1",null],
["-1.1",null]
];
for (var i in funcs) {
var pass = true;
console.log("Testing function "+i);
for (var ii in vals) {
var n = vals[ii][0];
var ns;
if (n === null) {
ns = n+"";
} else {
switch (typeof(n)) {
case "string":
ns = "'" + n + "'";
break;
case "object":
ns = Object.prototype.toString.call(n);
break;
default:
ns = n;
}
ns = "("+typeof(n)+") "+ns;
}
var x = vals[ii][1];
var xs;
if (x === null) {
xs = "(ANY)";
} else {
switch (typeof(x)) {
case "string":
xs = "'" + n + "'";
break;
case "object":
xs = Object.prototype.toString.call(x);
break;
default:
xs = x;
}
xs = "("+typeof(x)+") "+xs;
}
var rms;
try {
var r = funcs[i](n);
var rs;
if (r === null) {
rs = r+"";
} else {
switch (typeof(r)) {
case "string":
rs = "'" + r + "'";
break;
case "object":
rs = Object.prototype.toString.call(r);
break;
default:
rs = r;
}
rs = "("+typeof(r)+") "+rs;
}
var m;
var ms;
if (x === null) {
m = true;
ms = "N/A";
} else if (typeof(x) == 'object') {
m = (xs === rs);
ms = m;
} else {
m = (x === r);
ms = m;
}
if (!m) {
pass = false;
}
rms = "Result: "+rs+", Match: "+ms;
} catch (e) {
rms = "Test skipped; function threw exception!"
}
console.log(" Value: "+ns+", Expect: "+xs+", "+rms);
}
console.log(pass ? "PASS!" : "FAIL!");
}
J'ai également relancé la référence avec la fonction n ° 8 ajoutée à la liste. Je ne publierai pas le résultat, car ils sont un peu gênants (par exemple, cette fonction n'est PAS rapide) ...
Les résultats (abrégés - j'ai supprimé les tests réussis, car le résultat est assez long) sont les suivants:
Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!
Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!
Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!
Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!
J'ai laissé des échecs pour que vous puissiez voir où chaque fonction échoue et les tests (string) '#' pour voir comment chaque fonction gère les valeurs entières et flottantes dans les chaînes, car certains voudront peut-être les analyser et les convertir en nombres. Peut-être pas.
Sur les 10 fonctions testées, celles qui répondent réellement aux exigences de OP sont [1,3,5,6,8,9]