Как найти, что число float или integer?
1.25 --> float
1 --> integer
0 --> integer
0.25 --> float
Как проверить, что число является float или integer?
Ответ 1
проверьте остаток при делении на 1:
function isInt(n) {
return n % 1 === 0;
}
Если вы не знаете, что аргумент является числом, вам нужно два теста:
function isInt(n){
return Number(n) === n && n % 1 === 0;
}
function isFloat(n){
return Number(n) === n && n % 1 !== 0;
}
Обновление 2019 года Через 5 лет после написания этого ответа решение было стандартизировано в ECMA Script 2015. Это решение описано в этом ответе.
Ответ 2
Попробуйте эти функции, чтобы проверить, является ли значение числовым примитивным значением, которое не имеет дробной части и находится в пределах размера того, что может быть представлено как точное целое число.
function isFloat(n) {
return n === +n && n !== (n|0);
}
function isInteger(n) {
return n === +n && n === (n|0);
}
Ответ 3
Почему бы не что-то вроде этого:
var isInt = function(n) { return parseInt(n) === n };
Ответ 4
Существует метод под названием Number.isInteger(), который в настоящее время реализован во всем, кроме IE. MDN также предоставляет полифилл для других браузеров:
Number.isInteger = Number.isInteger || function(value) {
return typeof value === 'number' &&
isFinite(value) &&
Math.floor(value) === value;
};
Однако в большинстве случаев лучше использовать Number.isSafeInteger, который также проверяет, является ли значение настолько высоким/низким, что любые десятичные разряды в любом случае будут потеряны. У MDN также есть полифайл. (Вам также потребуется указанная выше isInteger).
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;
};
Ответ 5
Вы можете использовать простое регулярное выражение:
function isInt(value) {
var er = /^-?[0-9]+$/;
return er.test(value);
}
Или вы можете использовать приведенные ниже функции, в соответствии с вашими потребностями. Они разработаны PHPJS Project.
is_int() = > Проверить, является ли тип переменной целочисленным, и если его содержимое является целым числом
is_float() = > Проверить, является ли тип переменной float, и если его содержимое равно float
ctype_digit() = > Проверьте, является ли тип переменной строкой, и если ее содержимое имеет только десятичные цифры
Обновление 1
Теперь он также проверяет отрицательные числа, спасибо за комментарий @ChrisBartley!
Ответ 6
Вот эффективные функции, которые проверяют, является ли это число числом или могут быть безопасно преобразованы в число:
function isNumber(value) {
if ((undefined === value) || (null === value)) {
return false;
}
if (typeof value == 'number') {
return true;
}
return !isNaN(value - 0);
}
И для целых чисел (вернет false, если значение является float):
function isInteger(value) {
if ((undefined === value) || (null === value)) {
return false;
}
return value % 1 == 0;
}
Эффективность здесь заключается в том, что parseInt (или parseNumber) избегают, когда значение уже является числом. Обе функции синтаксического анализа всегда сначала преобразуются в строку, а затем пытаются проанализировать эту строку, которая будет пустой, если значение уже является числом.
Благодарим вас за другие сообщения для предоставления дальнейших идей для оптимизации!
Ответ 7
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
Ответ 8
function isInt(n)
{
return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
return n != "" && !isNaN(n) && Math.round(n) != n;
}
работает для всех случаев.
Ответ 9
Как уже упоминалось, в JS есть только удвоения. Итак, как вы определяете число, являющееся целым числом? Просто проверьте, равно ли округленное число:
function isInteger(f) {
return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }
Ответ 10
Здесь я использую для целых чисел:
Math.ceil(parseFloat(val)) === val
Короткая, симпатичная:) Работает постоянно. Это то, что предлагает Давид Фланаган, если я не ошибаюсь.
Ответ 11
Любое число Float с нулевой десятичной частью (например, 1.0, 12.00, 0.0) неявно приводится к Integer, поэтому невозможно проверить, являются ли они Float или нет.
Ответ 12
Это действительно зависит от того, чего вы хотите достичь. Если вы хотите "эмулировать" сильно типизированные языки, я предлагаю вам не пытаться. Как отмечали другие, все числа имеют одно и то же представление (один и тот же тип).
Используя что-то вроде Клаудиу, при условии:
isInteger( 1.0 ) → true
который выглядит хорошо для здравого смысла, но в чем-то вроде C вы получите false
Ответ 13
Это действительно не так сложно. Числовое значение эквивалентных чисел parseFloat() и parseInt() будет одинаковым. Таким образом, вы можете сделать так:
function isInt(value){
return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}
Тогда
if (isInt(x)) // do work
Это также позволит проверять строки и, следовательно, не является строгим. Если требуется сильное решение типа (он же не работает со строками):
function is_int(value){ return !isNaN(parseInt(value * 1) }
Ответ 14
!!(24%1) // false
!!(24.2%1) // true
Ответ 15
var isInt = function (n) { return n === (n | 0); };
Не было случая, когда это не выполнялось.
Ответ 16
Как насчет этого?
isFloat(num) {
return typeof num === "number" && !Number.isInteger(num);
}
Ответ 17
ЭТО ЗАКЛЮЧИТЕЛЬНЫЙ КОД ДЛЯ ПРОВЕРКИ ОБА И ИСТОРИИ
function isInt(n) {
if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
return true;
} else {
return false;
}
}
ИЛИ
function isInt(n) {
return typeof n == 'number' && Math.Round(n) % 1 == 0;
}
Ответ 18
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');
}
Ответ 19
Это просто:
if( n === parseInt(n) ) ...
Попробуйте это в консоли:
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!
Это смущает много людей. Всякий раз, когда что-то есть .0, он больше не плавает. Это целое число. Или вы можете просто называть это "числовой штукой", потому что нет строгого различия, как тогда, в C. Хорошие старые времена.
В принципе, все, что вы можете сделать, это проверить на целое число, принимающее тот факт, что 1.000 является целым числом.
Интересная заметка
Был комментарий о огромных числах. Огромные цифры означают NO проблему для этого подхода; всякий раз, когда parseInt не может обработать номер (для него слишком большой), он вернет что-то другое, чем фактическое значение, поэтому тест вернет FALSE. Это хорошо, потому что, если вы считаете что-то "числом", которое вы обычно ожидаете, что JS сможет вычислить с ним - так что да, числа ограничены, и parseInt учтет это, чтобы выразить это так.
Попробуйте следующее:
<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>
В моем браузере (IE8) это возвращает "a в порядке, b сбой", что именно из-за огромного числа в b. Предел может меняться, но я думаю, что 20 цифр "должно быть достаточно для кого-то", чтобы процитировать классику:)
Ответ 20
Я написал функцию, которая принимает строки (если кому-то понадобится)
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
}
Пример вывода:
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
Ответ 21
Это решение сработало для меня.
<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>
Ответ 22
Для целых чисел я использую этот
function integer_or_null(value) {
if ((undefined === value) || (null === value)) {
return null;
}
if(value % 1 != 0) {
return null;
}
return value;
}
Ответ 23
В java script все числа internally 64 bit floating point, такие же, как double в java.
В javascript нет разных типов, все они представлены типом number. Следовательно, вы не сможете сделать проверку instanceof. Однако вы можете использовать приведенные выше решения, чтобы выяснить, является ли это дробным числом. дизайнеры java script чувствовали себя одним типом, они могут избежать многочисленных ошибок при наборе типов.
Ответ 24
Пробуя некоторые ответы здесь, я закончил тем, что написал это решение. Это работает также с числами внутри строки.
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);Ответ 25
Возможно, это не так важно, как% answer, что мешает вам сначала преобразовать в строку, но я еще не видел, чтобы кто-то опубликовал ее, так что здесь еще один вариант, который должен работать нормально:
function isInteger(num) {
return num.toString().indexOf('.') === -1;
}
Ответ 26
Для любопытных, используя Benchmark.js, я опробовал самые опрошенные ответы (и опубликованные сегодня) на этом посту, вот мои результаты:
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
Ответ 27
Вот мой код. Он проверяет, чтобы это не пустая строка (которая в противном случае пройдет), а затем преобразует ее в числовой формат. Теперь, в зависимости от того, хотите ли вы '1.1' быть равным 1.1, это может быть или не быть тем, что вы ищете.
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;
};
Ответ 28
Мне нравится эта небольшая функция, которая вернет true как для положительных, так и для отрицательных целых чисел:
function isInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}
Это работает, потому что 1 или "1" становится "1.0", который isNaN() возвращает значение false (которое мы затем отрицаем и возвращаем), но 1.0 или "1.0" становится "1.0.0", тогда как "строка" становится "string.0", ни один из которых не является числом, поэтому isNaN() возвращает false (и, опять же, получает отрицание).
Если вам нужны только целые положительные числа, то этот вариант:
function isPositiveInt(val) {
return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}
или, для отрицательных целых чисел:
function isNegativeInt(val) {
return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}
isPositiveInt() работает, перемещая конкатенированную числовую строку перед тестируемым значением. Например, isPositiveInt (1) приводит к isNaN(), оценивающему "01", который оценивает значение false. Между тем, isPositiveInt (-1) приводит к isNaN(), оценивающему "0-1", который оценивает значение true. Мы отрицаем возвращаемое значение, и это дает нам то, что мы хотим. isNegativeInt() работает аналогично, но без отрицания возвращаемого значения isNaN().
Edit:
Моя первоначальная реализация также вернет true для массивов и пустых строк. Эта реализация не имеет этого дефекта. Это также имеет преимущество возврата раньше, если val не является строкой или номером, или если это пустая строка, что делает это быстрее в этих случаях. Вы можете изменить его, заменив первые два предложения на
typeof(val) != "number"
если вы хотите только сопоставить буквенные числа (а не строки)
Edit:
Я не могу оставлять комментарии, поэтому я добавляю это к своему ответу. Тест, опубликованный @Asok, очень информативен; однако самая быстрая функция не соответствует требованиям, так как она также возвращает TRUE для поплавков, массивов, булевых и пустых строк.
Я создал следующий тестовый набор, чтобы проверить каждую из функций, добавив также мой ответ в список (функция 8, которая анализирует строки и функцию 9, а это не так):
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!");
}
Я также перепрограммировал тест с добавлением функции # 8 в список. Я не буду публиковать результат, так как они немного смущают (например, эта функция НЕ быстрая)...
(сокращено - я удалил успешные тесты, так как результат довольно длинный):
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!
Я остался в неудачах, чтобы вы могли видеть, где каждая функция терпит неудачу, и тесты (string) '#', чтобы вы могли видеть, как каждая функция обрабатывает целочисленные и плавающие значения в строках, поскольку некоторые из них могут захотеть, чтобы эти синтаксические выражения числа, а некоторые - нет.
Из 10 проверенных функций те, которые фактически соответствуют требованиям OP, [1,3,5,6,8,9]
Ответ 29
Конфликт для плавающей проверки:
if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0))
Конфликт для проверки целостности:
if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0))
Надеюсь, это может быть полезно.
Ответ 30
function int(a) {
return a - a === 0 && a.toString(32).indexOf('.') === -1
}
function float(a) {
return a - a === 0 && a.toString(32).indexOf('.') !== -1
}
Вы можете добавить typeof a === 'number', если хотите исключить строки.