私はFirefoxのJavaScriptコンソールでそれを試してみましたが、次のステートメントはどちらもtrueを返しません。

parseFloat('geoff') == NaN;

parseFloat('geoff') == Number.NaN;

このコードを試してください：

isNaN(parseFloat("geoff"))

数値ではなく値がNaNであるかどうかを確認するには、こちらを参照してください：JavaScriptでNaNをテストするにはどうすればよいですか？

私はこのテクニックに出会ったばかりですが、これはかなり単純な「効果的な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');

MDNのドキュメントを参照isNaN()。

alert ( isNaN('abcd'));  // alerts true
alert ( isNaN('2.0'));  // alerts false
alert ( isNaN(2.0));  // alerts false

Number型の値がaかどうかに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の両方で一貫性を保つために、このポリフィルを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;
}

詳細については、この回答を確認してください。

NaNは、そのようにテストできない特別な値です。共有したいのはこれです

var nanValue = NaN;
if(nanValue !== nanValue) // Returns true!
    alert('nanValue is NaN');

これは、NaN値に対してのみ trueを返し、テストの安全な方法です。同じ変数が互いに等しくないかどうかをテストすることは明らかに意味がないので、関数でラップするか、少なくともコメントする必要があります。

次のisNaN(value)理由により、グローバル関数呼び出しを使用する必要があります。

• クロスブラウザをサポートしています
• ドキュメンテーションについてはisNaNを参照してください

例：

 isNaN('geoff'); // true
 isNaN('3'); // false

これがお役に立てば幸いです。

ES6の時点で、Object.is(..)は、2つの値の絶対等価性をテストするために使用できる新しいユーティリティです。

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

編集：私はちょうどこのしかし...偽の値から別の問題に気づいた（そして実際のbooleanとして真）に渡された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

明確にするために、私は「Not a Number」であるものの人間の文字通りの解釈を担当し、lodashは何かが「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()ができますが、数値以外の文字と絡み合った数値の問題に注意してください。

シンプルなソリューション！

本当に超簡単！ここに！この方法があります！

function isReallyNaN(a) { return a !== a; };

次のように簡単に使用してください：

if (!isReallyNaN(value)) { return doingStuff; }

hereこの関数を使用したパフォーマンステストを参照してください。selected answer

また、いくつかの代替実装については、以下の最初の例を参照してください。

例：

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>

別の方法で名前を付けたメソッドを使用せず、よりグローバルに利用できるようにしたい場合は、実装のために取る代替パスがいくつかあります。警告これらのソリューションはネイティブオブジェクトの変更を伴うものであり、最善のソリューションではない場合があります。常に注意を払い、使用する可能性のある他のライブラリがネイティブコードまたは同様の変更に依存している可能性があることに注意してください。

代替実装1：ネイティブisNaNメソッドを置き換えます。

//  Extremely simple. Just simply write the method.
window.isNaN = function(a) { return a !==a; }

代替実装2：数値オブジェクトに追加
^{* ECMA 5〜6のポリフィルでもあるため推奨}

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);
})();

例：

;(function() {
   function isEmpty(a) { return !a || void 0 === a || a !== a || 0 >= a || "object" == typeof a && /\{\}|\[(null(,)*)*\]/.test(JSON.stringify(a)); };
   window.hasOwnProperty("empty")||(window.empty=isEmpty);
})();

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    '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 = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

空かどうかの非常に詳細なチェック

最後の1つは、オブジェクトが空のオブジェクトでいっぱいかどうかをチェックする場合でも、少し深くなります。きっと改善の余地があり、ピットの可能性はあると思いますが、今のところほとんどすべてを捕らえているようです。

function isEmpty(a) {
	if (!a || 0 >= a) return !0;
	if ("object" == typeof a) {
		var b = JSON.stringify(a).replace(/"[^"]*":(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '').replace(/"[^"]*":\{\},?/g, '');
		if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		else if (a instanceof Array)  {
			b = b.replace(/(0|"0*"|false|null|\{\}|\[(null(,)?)*\]),?/g, '');
			if ( /^$|\{\}|\[\]/.test(b) ) return !0;
		}
	}
	return false;
}
window.hasOwnProperty("empty")||(window.empty=isEmpty);

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': new Array(),
    'an empty Array w/ 9 len': new Array(9),
    'a semi-passed parse': parseInt('5a5'),
    'a non-empty Array': [ 'a', 'b', 'c' ],
    'Math to NaN': Math.log(-1),
    'an undefined object': undefined,
    'Object Full of Empty Items': { 1: '', 2: [], 3: {}, 4: false, 5:new Array(3), 6: NaN, 7: null, 8: void 0, 9: 0, 10: '0', 11: { 6: NaN, 7: null, 8: void 0 } },
    'Array Full of Empty Items': ["",[],{},false,[null,null,null],null,null,null,0,"0",{"6":null,"7":null}]
  }

for (x in example) {
	var answer = empty(example[x]),
		strAnswer = answer.toString();
	$("#t1").append(
		$("<tr />", { "class": strAnswer }).append(
			$("<th />", { html: x }),
			$("<td />", { html: strAnswer.toUpperCase() })
		)
	)
};


function isReallyNaN(a) { return a !== a; };
for(x in example){var answer=isReallyNaN(example[x]),strAnswer=answer.toString();$("#t2").append($("<tr />",{"class":strAnswer}).append($("<th />",{html:x}),$("<td />",{html:strAnswer.toUpperCase()})))};

table { border-collapse: collapse; float: left; }
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 id="t1"><thead><tr><th colspan="2">isEmpty()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>
<table id="t2"><thead><tr><th colspan="2">isReallyNaN()</th></tr></thead><thead><tr><th>Value Type</th><th>Bool Return</th></tr></thead></table>

私は別の選択肢を共有したいだけです。ここで他の選択肢よりも優れているとは限りませんが、一見の価値があると思います。

function customIsNaN(x) { return (typeof x == 'number' && x != 0 && !x); }

この背後にある論理は、0とNaNを除くすべての数値がtrueです。

私は簡単なテストを行いましたが、それは Number.isNaNそれ自体がfalseかかをチェックするのと同じを示します。3つすべてのパフォーマンスは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'))

JavaScriptのNaNは「Not A Number」を表しますが、その型は実際には数値です。

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

「A」は実際には数値ではないため、実際には意味があります。しかし、実際に確認したいのは、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関数を使用しています。

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);

NaN === NaN;        // false
Number.NaN === NaN; // false
isNaN(NaN);         // true
isNaN(Number.NaN);  // true

等価演算子（==および===）を使用して、NaNに対して値をテストすることはできません。

Mozillaドキュメントを見てください。グローバルNaNプロパティはNot-A-Numbeを表す値です。

最善の方法は、NaNをチェックするための組み込み関数である「isNaN（）」を使用することです。すべてのブラウザがこの方法をサポートしています。

ルールは：

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を含むすべての関係はfalseと評価されます。したがって、たとえば、AまたはB、あるいはその両方がNaNの場合、（A> = B）= falseおよび（A <= B）= falseとなります。

私は別の質問にこの回答を書きました StackOverflowでチェックしましたNaN == nullが、重複としてマークされたので、仕事を無駄にしたくありません。

見る Mozillaの開発者ネットワークについてNaN。

簡潔な答え

使うだけ distance || 0値が適切な数値であるisNaN()ことを確認したり、値を確認したりときにします。

長い答え

NaN（Not-a-Number）は、数学演算が失敗したときに頻繁に返されるJavaScriptの奇妙なグローバルオブジェクトです。

NaN == null結果がどうなるかを確認したかったのfalseです。HovewerはNaN == NaN、false。

変数がNaNグローバル関数かどうかを確認する簡単な方法isNaN()。

もう一つは x !== x、xがNaNの場合にのみ当てはまることです。（@ raphael-schweikertへの通知に感謝）

しかし、なぜ短い答えが機能したのですか？

確認してみましょう。

NaN == false結果を呼び出すとfalse、と同じNaN == trueです。

仕様のどこかに、JavaScriptには常にfalse値を持つレコードがあります。

• NaN -非数
• "" -空の文字列
• false -ブールfalse
• null -nullオブジェクト
• undefined -未定義の変数
• 0 -+0と-0を含む数値0

MDNのparseFloatページで別のソリューションが言及されています

厳密な解析を行うためのフィルター機能を提供します

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);  
}

markyzmの答えはうまくいきますがInfinity、Infinityは厳密には数値ではないため、はfalseを返しません。

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)

これは1文字の評価ですが、文字列をループして数値をチェックすることもできます。

isNaN JavaScript関数を使用してNaNを確認できます。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;
}

条件は、TRUEの場合にのみ実行されます。

FALSEではありません。

「わからない」ではありません。