Я пробовал это только в консоли JavaScript Firefox, но ни одно из следующих утверждений не возвращает true:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
Я пробовал это только в консоли JavaScript Firefox, но ни одно из следующих утверждений не возвращает true:
parseFloat('geoff') == NaN;
parseFloat('geoff') == Number.NaN;
Ответы:
Попробуйте этот код:
isNaN(parseFloat("geoff"))
Для проверки, является ли какое-либо значение NaN, а не просто числами, смотрите здесь: Как вы проверяете NaN в Javascript?
NaN
, тогда да. (Я не говорю, что вы всегда будете.)
isNaN(parseFloat("geoff")) // true
isNaN(parseFloat("10geo")) // false
Как это полезно?
Я только что столкнулся с этой техникой в книге « Эффективный JavaScript», которая довольно проста:
Поскольку NaN является единственным значением JavaScript, которое рассматривается как неравное для себя, вы всегда можете проверить, является ли значение NaN, проверив его на равенство с самим собой:
var a = NaN;
a !== a; // true
var b = "foo";
b !== b; // false
var c = undefined;
c !== c; // false
var d = {};
d !== d; // false
var e = { valueOf: "foo" };
e !== e; // false
Не осознавал этого, пока @allsyed не прокомментировал, но это в спецификации ECMA: https://tc39.github.io/ecma262/#sec-isnan-number
Используйте этот код:
isNaN('geoff');
Смотрите isNaN()
документы по MDN .
alert ( isNaN('abcd')); // alerts true
alert ( isNaN('2.0')); // alerts false
alert ( isNaN(2.0)); // alerts false
var value = 0/0;
и var value2= String("123 131");
создавать значения NaN, и что-то вроде этого var value3 = "abcd";
также является значением NaN.
Поскольку значение типа Number должно быть проверено, является ли оно NaN
или нет, глобальная функция isNaN
будет делать работу
isNaN(any-Number);
Для общего подхода, который работает для всех типов в JS, мы можем использовать любое из следующего:
Для пользователей ECMAScript-5:
#1
if(x !== x) {
console.info('x is NaN.');
}
else {
console.info('x is NOT a NaN.');
}
Для людей, использующих ECMAScript-6:
#2
Number.isNaN(x);
И в целях обеспечения согласованности в ECMAScript 5 и 6, мы также можем использовать этот polyfill для Number.isNan
#3
//Polyfill from MDN
Number.isNaN = Number.isNaN || function(value) {
return typeof value === "number" && isNaN(value);
}
// Or
Number.isNaN = Number.isNaN || function(value) {
return value !== value;
}
пожалуйста, проверьте этот ответ для более подробной информации.
isNaN
сначала преобразует аргумент в числовое значение.
NaN - это особая ценность, которую нельзя так проверить. Интересно, что я просто хотел поделиться этим
var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
alert('nanValue is NaN');
Это возвращает истину только для значений NaN и является безопасным способом тестирования. Должен определенно быть обернут в функцию или, по крайней мере, прокомментирован, потому что, очевидно, нет смысла проверять, не совпадают ли одна и та же переменная, хе-хе.
Вы должны использовать isNaN(value)
вызов глобальной функции, потому что:
Примеры:
isNaN('geoff'); // true
isNaN('3'); // false
Я надеюсь, что это поможет вам.
isNaN('') //false
но parseInt('') //NaN
. То же самое можно сказать и для null
.
Начиная с ES6 , Object.is(..)
это новая утилита, которую можно использовать для проверки двух значений на абсолютное равенство:
var a = 3 / 'bar';
Object.is(a, NaN); // true
Чтобы исправить проблему с '1.2geoff'
анализом, просто используйте Number()
вместо этого анализатор.
Итак, а не это:
parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true
Сделай это:
Number('1.2geoff'); // => NaN
isNaN(Number('1.2geoff')); // => true
isNaN(Number('.2geoff')); // => true
isNaN(Number('geoff')); // => true
РЕДАКТИРОВАТЬ: я только что заметил еще одну проблему из этого, хотя ... ложные значения (и true, как настоящий логический) передаются в Number()
качестве 0
! В этом случае ... parseFloat работает каждый раз вместо этого. Итак, вернемся к этому:
function definitelyNaN (val) {
return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}
И это охватывает, казалось бы, все. Я оценил его на 90% медленнее, чем у Лодаша, _.isNaN
но тогда он не охватывает все NaN:
http://jsperf.com/own-isnan-vs-underscore-lodash-isnan
Просто чтобы прояснить, моя заботится о человеческой буквальной интерпретации чего-то, что является «Не числом», а Лодаш заботится о компьютерной буквальной интерпретации проверки, является ли что-то «NaN».
Хотя ответ @chiborg является верным, следует отметить следующее:
parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true
Суть в том, что если вы используете этот метод для проверки ввода, результат будет довольно либеральным.
Итак, да, вы можете использовать parseFloat(string)
(или в случае полных чисел parseInt(string, radix)
), а затем обернуть это с помощью isNaN()
, но будьте внимательны с полученными числами, переплетенными с дополнительными нечисловыми символами.
parseFloat('test1.2')
вернется NaN
.
ДЕЙСТВИТЕЛЬНО супер просто! Вот! Есть этот метод!
function isReallyNaN(a) { return a !== a; };
Используйте так же просто, как:
if (!isReallyNaN(value)) { return doingStuff; }
Смотрите тест производительностиhere с помощью этой функции противselected answer
Также: см. Ниже 1-й пример для пары альтернативных реализаций.
function isReallyNaN(a) { return a !== a; };
var example = {
'NaN': NaN,
'an empty Objet': {},
'a parse to NaN': parseFloat('$5.32'),
'a non-empty Objet': { a: 1, b: 2 },
'an empty Array': [],
'a semi-passed parse': parseInt('5a5'),
'a non-empty Array': [ 'a', 'b', 'c' ],
'Math to NaN': Math.log(-1),
'an undefined object': undefined
}
for (x in example) {
var answer = isReallyNaN(example[x]),
strAnswer = answer.toString();
$("table").append($("<tr />", { "class": strAnswer }).append($("<th />", {
html: x
}), $("<td />", {
html: strAnswer
})))
};
table { border-collapse: collapse; }
th, td { border: 1px solid; padding: 2px 5px; }
.true { color: red; }
.false { color: green; }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table></table>
Есть несколько альтернативных путей, которые вы выбираете для реализации, если вы не хотите использовать метод с альтернативным именем и хотели бы обеспечить его глобальную доступность. Предупреждение Эти решения включают изменение собственных объектов и могут быть не самым лучшим решением. Всегда соблюдайте осторожность и помните, что другие библиотеки, которые вы можете использовать, могут зависеть от собственного кода или аналогичных изменений.
isNaN
метод.// Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }
Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
// Use as simple as
Number.isNaN(NaN)
Проверка альтернативного раствора, если она пуста
Простой метод окна я написал этот тест, если объект пуст . Это немного отличается тем, что не дает, если элемент «точно» NaN , но я решил, что это будет важно, так как это может быть полезно при поиске пустых элементов.
/** isEmpty(varried)
* Simple method for testing if item is "empty"
**/
;(function() {
function isEmpty(a) { return (!a || 0 >= a) || ("object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a))); };
window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();
Этот последний идет немного глубже, даже проверяя, заполнен ли объект пустыми объектами. Я уверен, что в нем есть место для улучшений и возможных ям, но пока что, похоже, ловит почти все.
isNaN
как не является надежным. Там меня прокомментировали и сказали, что этот вопрос лучше подойдет для моего ответа, поэтому перенес его сюда. Просто добавьте что-нибудь полезное / полезное в связи с этой проблемой, которая появится в поиске Google по данной проблеме is it NaN?
. С другой стороны, мой ответ будет более точным, чем выбранный ответ.
Я просто хочу поделиться другой альтернативой, она не обязательно лучше, чем у других здесь, но я думаю, что стоит посмотреть:
function customIsNaN(x) { return (typeof x == 'number' && x != 0 && !x); }
Логика заключается в том, что каждое число, кроме 0
и NaN
приведено кtrue
.
Я сделал быстрый тест, и он работает так же хорошо, как Number.isNaN
и проверяет себя на ложность. Все три работают лучше, чемisNan
Результаты
customIsNaN(NaN); // true
customIsNaN(0/0); // true
customIsNaN(+new Date('?')); // true
customIsNaN(0); // false
customIsNaN(false); // false
customIsNaN(null); // false
customIsNaN(undefined); // false
customIsNaN({}); // false
customIsNaN(''); // false
Может стать полезным, если вы хотите избежать нарушения isNaN
функции.
Если ваша среда поддерживает ECMAScript 2015 , вы можете использовать Number.isNaN
ее, чтобы убедиться, что значение действительноNaN
.
Проблема в isNaN
том, что , если вы используете это с нечисловыми данными, применяется несколько непонятных правил (согласно MDN). Например,
isNaN(NaN); // true
isNaN(undefined); // true
isNaN({}); // true
Итак, в средах, поддерживаемых ECMA Script 2015, вы можете использовать
Number.isNaN(parseFloat('geoff'))
isNaN
может привести к неприятностям, и не забывайте использовать Number.isNaN
в средах ECMAScript 2015 :-)
NaN в JavaScript означает «не число», хотя на самом деле его тип - число.
typeof(NaN) // "number"
Чтобы проверить, имеет ли переменная значение NaN, мы не можем просто использовать функцию isNaN (), потому что isNaN () имеет следующую проблему, см. Ниже:
var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN
Здесь действительно происходит то, что myVar неявно приводится к числу:
var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact
Это действительно имеет смысл, потому что «А» на самом деле не число. Но мы действительно хотим проверить, действительно ли myVar имеет значение NaN.
Так что isNaN () не может помочь. Тогда что мы должны делать вместо этого?
В свете того, что NaN является единственным значением JavaScript, которое обрабатывается неравномерно для самого себя, мы можем проверить его равенство самому себе, используя! ==
var myVar; // undefined
myVar !== myVar // false
var myVar = "A";
myVar !== myVar // false
var myVar = NaN
myVar !== myVar // true
Таким образом, чтобы заключить , что если это правда, что переменная! == сама, то эта переменная точно имеет значение NaN:
function isOfValueNaN(v) {
return v !== v;
}
var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false
Я использую функцию подчеркивания,isNaN
потому что в JavaScript:
isNaN(undefined)
-> true
По крайней мере, помните об этом.
undefined
будет некорректным поведением? Это правда, что undefined
это не число, не так ли?
undefined
может быть чем-то иным NaN
, но это не число, поэтому isNaN(undefined)
должно быть (и есть)true
Возможно также это:
function isNaNCustom(value){
return value.toString() === 'NaN' &&
typeof value !== 'string' &&
typeof value === 'number'
}
Кажется, что isNaN () не поддерживается в Node.js из коробки.
Я работал с
var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);
function isNotANumber(n) {
if (typeof n !== 'number') {
return true;
}
return n !== n;
}
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
Оператор равенства (== и ===) нельзя использовать для проверки значения с NaN.
Посмотрите на документацию Mozilla . Глобальное свойство NaN - это значение, представляющее Not-A-Numbe.
Лучший способ - использовать функцию isNaN (), которая является встроенной функцией для проверки NaN. Все браузеры поддерживают способ ..
Правило таково:
NaN != NaN
Проблема функции isNaN () в том, что она может возвращать неожиданный результат в некоторых случаях:
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true
Лучший способ проверить, действительно ли значение NaN:
function is_nan(value) {
return value != value
}
is_nan(parseFloat("geoff"))
Согласно IEEE 754 все отношения с участием NaN оцениваются как ложные, кроме! =. Таким образом, например, (A> = B) = false и (A <= B) = false, если A или B или оба являются / являются NaN.
Я написал этот ответ на другой вопрос о StackOverflow, когда другой проверяет, когда, NaN == null
но затем он был отмечен как дубликат, поэтому я не хочу тратить свою работу.
Посмотрите на Сеть разработчиков Mozilla о NaN
.
Просто используйте, distance || 0
когда вы хотите убедиться, что вы цените правильное число или isNaN()
проверить его.
NaN (Not-a-Number) - это странный глобальный объект в javascript, часто возвращаемый при сбое какой-либо математической операции.
Вы хотели проверить, NaN == null
какие результаты false
. Hovewer даже NaN == NaN
результаты с false
.
Простой способ узнать, является ли переменная NaN
глобальной функцией isNaN()
.
Другое, x !== x
которое верно только тогда, когда х является NaN. (спасибо, что напомнили @ Raphael-Schweikert)
Давайте выясним.
Когда вы звоните, NaN == false
результат false
, то же самое с NaN == true
.
Где-то в спецификациях JavaScript есть запись с всегда ложными значениями, которая включает в себя:
NaN
- не номер""
- пустой строкойfalse
- логическое значение falsenull
- нулевой объектundefined
- неопределенные переменные0
- числовое 0, включая +0 и -0var xIsNaN = x !== x;
это дает истину, только если х есть NaN
.
Другое решение упомянуто на странице parseFloat MDN
Он обеспечивает функцию фильтра для строгого анализа
var filterFloat = function (value) {
if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/
.test(value))
return Number(value);
return NaN;
}
console.log(filterFloat('421')); // 421
console.log(filterFloat('-421')); // -421
console.log(filterFloat('+421')); // 421
console.log(filterFloat('Infinity')); // Infinity
console.log(filterFloat('1.61803398875')); // 1.61803398875
console.log(filterFloat('421e+0')); // NaN
console.log(filterFloat('421hop')); // NaN
console.log(filterFloat('hop1.61803398875')); // NaN
И тогда вы можете использовать, isNaN
чтобы проверить, если этоNaN
Точный способ проверить это:
//takes care of boolen, undefined and empty
isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'
Я создал эту маленькую функцию, которая работает как шарм. Вместо того, чтобы проверять NaN, который кажется нелогичным, вы проверяете число. Я уверен, что я не первый, кто делает это таким образом, но я думал, что поделюсь.
function isNum(val){
var absVal = Math.abs(val);
var retval = false;
if((absVal-absVal) == 0){
retval = true
}
return retval;
}
Нашел другой способ, просто для удовольствия.
function IsActuallyNaN(obj) {
return [obj].includes(NaN);
}
Ответ Марксизма работает хорошо, но он не возвращает ложь для Infinity
поскольку Бесконечность технически не число.
я придумал isNumber
функцию, которая будет проверять, является ли это число.
function isNumber(i) {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY].indexOf(i) === -1;
}
console.log(isNumber(Infinity));
console.log(isNumber("asdf"));
console.log(isNumber(1.4));
console.log(isNumber(NaN));
console.log(isNumber(Number.MAX_VALUE));
console.log(isNumber("1.68"));
ОБНОВЛЕНИЕ: я заметил, что этот код не работает для некоторых параметров, поэтому я сделал его лучше.
function isNumber(i) {//function for checking if parameter is number
if(!arguments.length) {
throw new SyntaxError("not enough arguments.");
} else if(arguments.length > 1) {
throw new SyntaxError("too many arguments.");
} else if([Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].indexOf(i) !== -1) {
throw new RangeError("number cannot be \xB1infinity.");
} else if(typeof i === "object" && !(i instanceof RegExp) && !(i instanceof Number) && !(i === null)) {
throw new TypeError("parameter cannot be object/array.");
} else if(i instanceof RegExp) {
throw new TypeError("parameter cannot be RegExp.");
} else if(i == null || i === undefined) {
throw new ReferenceError("parameter is null or undefined.");
} else {
return !isNaN(i && i !== true ? Number(i) : parseFloat(i)) && (i === i);
}
}
console.log(isNumber(Infinity));
console.log(isNumber(this));
console.log(isNumber(/./ig));
console.log(isNumber(null));
alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);
Это не элегантно. но после попытки isNAN () я пришел к этому решению, которое является другой альтернативой. В этом примере я также разрешил '.' потому что я маскируюсь для поплавка. Вы также можете отменить это, чтобы убедиться, что номера не используются.
("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)
Это односимвольная оценка, но вы также можете просмотреть строку для проверки любых чисел.
Вы можете проверить NaN, используя функцию javascript isNaN. Просто передав число или значение в функцию isNaN
isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true
Просто конвертируйте результат в строку и сравните с NaN.
var val = Number("test");
if(String(val) === 'NaN') {
console.log("true");
}
Является ли (NaN> = 0) ? ...... " Я не знаю ".
function IsNotNumber( i ){
if( i >= 0 ){ return false; }
if( i <= 0 ){ return false; }
return true;
}
Условия выполняются только если ИСТИНА .
Не на ЛОЖЬ .
Не на " Я не знаю ".