Jak sprawdzić, czy w JavaScript jest liczbą NaN?


414

Próbowałem tylko w konsoli JavaScript Firefoksa, ale żadne z poniższych stwierdzeń nie jest prawdziwe:

parseFloat('geoff') == NaN;

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

5
warto przeczytać, jeśli twoim prawdziwym celem jest sprawdzenie liczb: stackoverflow.com/questions/18082/…
Paul


1
@Gothdo: jasne, ale zapytałem, jak sprawdzić, czy liczba jest NaN, w przeciwieństwie do jakiejkolwiek wartości.
Paul D. Waite,

2
@ PaulD.Waite Tak, ale wiele osób przychodzi tutaj, gdy Googling coś takiego jak „jak sprawdzić, czy zmienna jest nan w javascript”.
Michał Perłakowski

PaulD.Czekaj, zgadzam się z tobą, ale mam takie same obawy jak @Gothdo. Wiele osób trafia na to pytanie z zamiarem: „Jak sprawdzić, czy wartość w JS to NaN”. Możesz sprawdzić komentarz mjohnsonengr dotyczący tej samej odpowiedzi . BTW, ja też oflagowałem to pytanie dla uwagi moderatorów.
dopeddude

Odpowiedzi:


581

Wypróbuj ten kod:

isNaN(parseFloat("geoff"))

Aby sprawdzić, czy jakakolwiek wartość to NaN, a nie tylko liczby, zobacz tutaj: Jak testujesz NaN w JavaScript?


8
Czy istnieje potrzeba korzystania z paseFloat?
rahul

23
Jeśli chcesz, aby pusty ciąg znaków był interpretowany jako NaN, to tak. (Nie twierdzę, że zawsze tak robisz)
Paul D. Waite

1
Gdybym był tobą, przypisałbym to do zmiennej i użyj zmiennej warunkowej! == zmienna. Jak podano
zwany

3
isNaN(parseFloat("geoff")) // true isNaN(parseFloat("10geo")) // false Jak to jest przydatne?
Prashanth

Może to być również przydatne, aby wypróbować w3schools.com/jsref/jsref_isnan.asp
Srijan Chaudhary

146

Właśnie natrafiłem na tę technikę w książce Skuteczne JavaScript, która jest dość prosta:

Ponieważ NaN jest jedyną wartością JavaScript, która jest traktowana jako nierówna w stosunku do siebie, zawsze możesz sprawdzić, czy wartość jest NaN, sprawdzając, czy jest równa:

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

Nie zdawałem sobie z tego sprawy, dopóki @allsyed nie skomentował, ale jest to w specyfikacji ECMA: https://tc39.github.io/ecma262/#sec-isnan-number


27
Skuteczny, ale sprzeczny z intuicją. Nie chciałbym utrzymywać tego rodzaju kodu.
osa

35
To nie jest kod sprzeczny z intuicją, to NaN.
Jazzy

20
@DanM To nie jest błąd, to standardowe zachowanie NaN IEE754. Jest to sposób implementacji w procesorach i oczekiwane zachowanie w każdym języku programowania na świecie, który używa liczb zmiennoprzecinkowych.
Tarmil

4
@Tarmil Należy zauważyć! To naprawdę bardzo interesujące; Zawsze myślałem, że dziwność nierówności NaN jest rzeczą Javascript.
Dan M

2
NaN === Nan; // fałszywe. Jest to znany błąd w javascript. isNan to nowa metoda.
atilkan

52

Użyj tego kodu:

isNaN('geoff');

Zobacz isNaN()dokumenty w MDN .

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

1
Może to tylko ja, ale idea NaN staje się myląca, kiedy var value = 0/0;i var value2= String("123 131");tworzymy wartości NaN, a coś takiego var value3 = "abcd";jest również wartością NaN.
Nick Pineda,

@NickPineda Dlaczego?
Sinjai

44

Jeśli chodzi o wartość typu Number, która ma zostać przetestowana, czy jest to, NaNczy nie, funkcja globalna isNaNwykona pracę

isNaN(any-Number);

Aby uzyskać ogólne podejście, które działa dla wszystkich typów w JS, możemy użyć dowolnego z poniższych:

Dla użytkowników ECMAScript-5:

#1
if(x !== x) {
    console.info('x is NaN.');
}
else {
    console.info('x is NOT a NaN.');
}

Dla osób używających ECMAScript-6:

#2
Number.isNaN(x);

Aby uzyskać spójność w ECMAScript 5 i 6, możemy również użyć tego wypełnienia dla 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;
}

proszę sprawdzić tę odpowiedź, aby uzyskać więcej informacji.


6
Dzięki za nie tylko użycie „isNan ()”, ale raczej udzielenie całkowicie szczegółowej odpowiedzi. Właśnie tego dokładnie szukałem, kiedy znalazłem to pytanie w Google.
mjohnsonengr

1
„.... dawał złe wyniki dla powyższych przypadków” Nie powiedziałbym źle, po prostu inaczej, ponieważ globalny isNaNnajpierw przekształca argument na wartość liczbową.
Felix Kling

1
@FelixKling Sprawdź zaktualizowaną odpowiedź. Dzięki.
dopeddude

1
isNaN („lorem ipsum”); // prawda z ES5 była oszałamiająca
Nick Pineda

2
@NickPineda To uczucie jest takie wzajemne, ale w końcu MDN może to wytłumaczyć w ten sposób: „Gdy argument funkcji isNaN nie jest typu Number, wartość jest najpierw wymuszana na Number. Wynikowa wartość jest następnie testowana w celu ustalenia, czy jest NaN. ”
dopeddude

16

NaN to specjalna wartość, której nie można tak przetestować. Interesującą rzeczą, którą chciałem się tylko podzielić, jest to

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

Zwraca wartość true tylko dla wartości NaN i jest bezpiecznym sposobem testowania. Zdecydowanie powinien być zawinięty w funkcję lub przynajmniej skomentowany, ponieważ oczywiście nie ma sensu testowanie, czy ta sama zmienna nie jest sobie równa, hehe.


1
To nie jest całkowicie niezawodny sposób. Zgodnie ze specyfikacją. zmienna! == zmienna jest najbardziej niezawodnym sposobem sprawdzania
obecności

1
Zobacz moją odpowiedź powyżej na tym ^
Jazzy

14

Powinieneś użyć globalnego isNaN(value)wywołania funkcji, ponieważ:

  • Jest obsługiwany w różnych przeglądarkach
  • Zobacz isNaN dokumentacji

Przykłady:

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

Mam nadzieję, że to Ci pomoże.


1
Tak, isNaN('') //falseale parseInt('') //NaN. To samo można powiedzieć o null.
Silent Penguin

13

Począwszy od ES6 , Object.is(..)jest nowym narzędziem, które można wykorzystać do testowania dwóch wartości absolutnej równości:

var a = 3 / 'bar';
Object.is(a, NaN); // true


9

Aby naprawić problem '1.2geoff'polegający na Number()analizie składni , po prostu użyj parsera.

Więc raczej niż to:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Zrób to:

Number('1.2geoff'); // => NaN
isNaN(Number('1.2geoff')); // => true
isNaN(Number('.2geoff')); // => true
isNaN(Number('geoff')); // => true

EDYCJA: Właśnie zauważyłem inny problem z tego powodu ... fałszywe wartości (i prawdziwe jak prawdziwy boolean) zostały Number()zwrócone jako 0! W takim przypadku ... parseFloat działa za każdym razem. Wróćmy więc do tego:

function definitelyNaN (val) {
    return isNaN(val && val !== true ? Number(val) : parseFloat(val));
}

I to obejmuje na pozór wszystko. Testowałem go o 90% wolniej niż lodash, _.isNaNale to nie obejmuje wszystkich NaN:

http://jsperf.com/own-isnan-vs-underscore-lodash-isnan

Żeby było jasne, moje zajmuje się dosłowną ludzką interpretacją czegoś, co nie jest „liczbą”, a lodash zajmuje się dosłowną komputerową interpretacją sprawdzania, czy coś jest „NaN”.


7

Chociaż odpowiedź @chiborga JEST poprawna, należy zwrócić uwagę na jeszcze więcej:

parseFloat('1.2geoff'); // => 1.2
isNaN(parseFloat('1.2geoff')); // => false
isNaN(parseFloat('.2geoff')); // => false
isNaN(parseFloat('geoff')); // => true

Chodzi o to, że jeśli używasz tej metody do sprawdzania poprawności danych wejściowych, wynik będzie raczej liberalny.

Tak, więc możesz użyć parseFloat(string)(lub w przypadku liczb pełnych parseInt(string, radix)”, a następnie owinąć je isNaN(), ale pamiętaj o gotcha z liczbami splecionymi z dodatkowymi znakami nienumerycznymi.


1
Ciekawy. Jakiś sposób, aby temu przeciwdziałać i wykryć, że „1.2geoff” nie jest tak naprawdę prawidłowym ciągiem liczbowym?
Gabe Halsmer

2
Zauważ, że dzieje się tak tylko wtedy, gdy ciąg zaczyna się od liczby. parseFloat('test1.2')wróci NaN.
Eduard Luca,

6

Proste rozwiązanie!

NAPRAWDĘ super proste! Tutaj! Miej tę metodę!

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

Użyj tak prostego jak:

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

Zobacz test wydajnościhere za pomocą tego func vsselected answer

Ponadto: patrz poniżej 1. przykład kilku alternatywnych implementacji.


Przykład:

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>

Istnieje kilka alternatywnych ścieżek, które wybierasz do implementacji, jeśli nie chcesz używać metody o alternatywnej nazwie i chciałbyś upewnić się, że jest ona bardziej dostępna na całym świecie. Ostrzeżenie Te rozwiązania obejmują modyfikowanie obiektów rodzimych i mogą nie być najlepszym rozwiązaniem. Zawsze zachowaj ostrożność i pamiętaj, że inne biblioteki, których możesz użyć, mogą zależeć od kodu natywnego lub podobnych zmian.

Alternatywna implementacja 1: Zastąp isNaNmetodę rodzimą .

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

Alternatywne wdrożenie 2: Dołącz do obiektu liczbowego
* Sugerowane, ponieważ jest to również wielokrotne wypełnienie dla ECMA od 5 do 6

Number['isNaN'] || (Number.isNaN = function(a) { return a !== a });
//  Use as simple as
Number.isNaN(NaN)

Test rozwiązania alternatywnego, jeśli jest pusty

Prostą metodę okna napisałem ten test, jeśli obiekt jest Pusty . Jest trochę inny w tym, że nie daje, jeśli przedmiot jest „dokładnie” NaN , ale pomyślałem, że zwymiotuję, ponieważ może to być przydatne, gdy szukam pustych przedmiotów.

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

Przykład:


Bardzo dokładne sprawdzenie, czy jest puste

Ten ostatni jest nieco głęboki, nawet sprawdzając, czy obiekt jest pełen pustych obiektów. Jestem pewien, że ma miejsce na ulepszenia i możliwe doły, ale jak dotąd wydaje się, że łapie większość wszystkiego.


1
@ PaulD. Poczekaj może to ta aplikacja, ale nie widzę zaakceptowanej odpowiedzi. W rzeczywistości widzę tylko około 5 odpowiedzi, ale widzę, że jest ich 15
SpYk3HH

1
Z jakiej aplikacji korzystasz?
Paul D. Waite

2
@ PaulD.Waite The SE one for android. na galaktyce s3
SpYk3HH

1
Aha. Nie mam aplikacji do samodzielnego wyglądania, ale oto link do zaakceptowanej odpowiedzi: stackoverflow.com/a/2652335/20578
Paul D. Waite

@ PaulD.Waite Ach, rozumiem. Sądzę, że w bezpośredniej odpowiedzi na samo pytanie samo w sobie odpowiedź ta może wystarczyć. Odpowiedziałem na inne pytanie w związku z „JS sposobem na sprawdzenie, czy to„ naprawdę ”NaN, ponieważ isNaNNIE jest wiarygodne. Zostałem tam skomentowany i powiedziałem, że to pytanie lepiej pasuje do mojej odpowiedzi, przenosząc ją tutaj. Wystarczy tylko wprowadzenie czegoś pomocne / użyteczne tam w odniesieniu do tej kwestii, że pojawi się na wyszukiwarce Google kwestii pod ręką is it NaN?. Na marginesie, moja odpowiedź byłaby bardziej precyzyjna niż wybrana odpowiedź.
SpYk3HH

5

Chcę tylko podzielić się inną alternatywą, niekoniecznie jest lepsza niż inne tutaj, ale myślę, że warto spojrzeć na:

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

Logika tego polega na tym, że każda liczba oprócz 0 i NaNjest obsadzona true.

Zrobiłem szybki test, który Number.isNaNsprawdza się zarówno pod względem fałszowania, jak i sprawdzania. Wszystkie trzy działają lepiej niżisNan

Wyniki

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

Może się przydać, jeśli chcesz uniknąć zepsutej isNaNfunkcji.


5

Jeśli twoje środowisko obsługuje ECMAScript 2015 , możesz użyć Number.isNaNtego, aby upewnić się, że wartość jest naprawdę NaN.

Problem isNaNpolega na tym, że jeśli używasz tego z danymi nienumerycznymi, stosuje się niewiele mylących reguł (zgodnie z MDN). Na przykład,

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true

Tak więc w środowiskach obsługiwanych przez ECMA Script 2015 możesz chcieć użyć

Number.isNaN(parseFloat('geoff'))

7
Moje środowisko obsługuje tylko ECMAScript XP Home Edition :(
Paul D. Waite

1
@ PaulD.Waite (mam nadzieję, że miałeś na myśli IE 6: D) Nie ma problemu :-) Po prostu pamiętaj, że isNaNmożesz mieć kłopoty i pamiętaj, aby używać Number.isNaNw środowiskach ECMAScript 2015 :-)
thefourtheye

5

NaN w JavaScript oznacza „Not A Number”, chociaż jego typ to w rzeczywistości liczba.

typeof(NaN) // "number"

Aby sprawdzić, czy zmienna ma wartość NaN, nie możemy po prostu użyć funkcji isNaN (), ponieważ isNaN () ma następujący problem, patrz poniżej:

var myVar = "A";
isNaN(myVar) // true, although "A" is not really of value NaN

To, co się naprawdę dzieje, to fakt, że myVar jest domyślnie przymuszany do pewnej liczby:

var myVar = "A";
isNaN(Number(myVar)) // true. Number(myVar) is NaN here in fact

To ma sens, ponieważ „A” w rzeczywistości nie jest liczbą. Ale tak naprawdę chcemy sprawdzić, czy myVar ma dokładnie wartość NaN.

Więc isNaN () nie może pomóc. Co zatem powinniśmy zrobić?

W świetle tego, że NaN jest jedyną wartością JavaScript, która jest traktowana nierówno względem siebie, więc możemy sprawdzić jej równość względem siebie za pomocą! ==

var myVar; // undefined
myVar !== myVar // false

var myVar = "A";
myVar !== myVar // false

var myVar = NaN
myVar !== myVar // true

Podsumowując , jeśli prawdą jest, że sama zmienna! ==, to ta zmienna ma dokładnie wartość NaN:

function isOfValueNaN(v) {
    return v !== v;
}

var myVar = "A";
isNaN(myVar); // true
isOfValueNaN(myVar); // false

4

Korzystam zisNaN funkcji podkreślenia, ponieważ w JavaScript:

isNaN(undefined) 
-> true

Przynajmniej bądź świadomy tej gotcha.


10
Jestem zmieszany. Dlaczego zwrot NAN nie byłby prawdą, gdy zostałby przekazany undefinedjako niepoprawne? To prawda, że undefinednie jest liczbą, prawda?
Xaxis,

3
@Xaxis NaN nie powinno być uważane za równoważne niezdefiniowanemu, oba są wartościami specjalnymi o określonych i różnych znaczeniach. Zastanów się: mam wartość, ale nie mówię, co to jest, może jest to liczba, a może jednak nie jest, z twojego punktu widzenia, nieokreślona.
Corin

1
@Corin undefinedmoże być czymś innym niż NaN, ale wciąż nie jest liczbą, więc isNaN(undefined)powinien być (i jest)true
neuhaus,

4

Może także to:

function isNaNCustom(value){
    return value.toString() === 'NaN' && 
           typeof value !== 'string' && 
           typeof value === 'number'
}

3

Wygląda na to, że isNaN () nie jest obsługiwany w Node.js po wyjęciu z pudełka.
Pracowałem z

var value = 1;
if (parseFloat(stringValue)+"" !== "NaN") value = parseFloat(stringValue);

Jasne, ale nie pytałem o Node.js.
Paul D. Waite,



2

Reguła jest następująca:

NaN != NaN

Problemem funkcji isNaN () jest to, że w niektórych przypadkach może zwrócić nieoczekiwany wynik:

isNaN('Hello')      //true
isNaN('2005/12/12') //true
isNaN(undefined)    //true
isNaN('NaN')        //true
isNaN(NaN)          //true
isNaN(0 / 0)        //true

Lepszym sposobem sprawdzenia, czy naprawdę jest NaN, jest:

function is_nan(value) {
    return value != value
}

is_nan(parseFloat("geoff"))

1

Według IEEE 754 wszystkie relacje z udziałem NaN są oceniane jako fałszywe, z wyjątkiem! =. Zatem na przykład (A> = B) = fałsz i (A <= B) = fałsz, jeśli A lub B lub oba są / są NaN.


1

Napisałem tę odpowiedź na inne pytanie na StackOverflow, gdzie inna sprawdza kiedy, NaN == nullale potem została oznaczona jako duplikat, więc nie chcę marnować pracy.

Spójrz na Mozilla Developer Network o NaN.


Krótka odpowiedź

Po prostu użyj, distance || 0jeśli chcesz mieć pewność, że cenisz właściwy numer lub isNaN()go sprawdzić.

Długa odpowiedź

NaN (Not-a-Number) to dziwny obiekt globalny w javascript, często zwracany w przypadku niepowodzenia niektórych operacji matematycznych.

Chciałeś sprawdzić, NaN == nullktóre wyniki false. Hovewer nawet NaN == NaNwyniki zfalse .

Prosty sposób na sprawdzenie, czy zmienna jest NaN funkcją globalną isNaN().

Innym jest x !== x prawdą tylko wtedy, gdy x jest NaN. (dzięki za przypomnienie @ raphael-schweikert)

Ale dlaczego krótka odpowiedź zadziałała?

Dowiedzmy Się.

Po wywołaniu NaN == falsewynik jest falsetaki sam jakNaN == true .

Gdzieś w specyfikacjach JavaScript ma rekord z zawsze fałszywymi wartościami, który obejmuje:

  • NaN - Brak numeru
  • "" - pusta struna
  • false - boolean false
  • null - zerowy obiekt
  • undefined - niezdefiniowane zmienne
  • 0 - numerycznie 0, w tym +0 i -0

1
„Jedynym prostym sposobem sprawdzenia, czy zmienną jest NaN, jest funkcja globalna toNaN ()” - nieprawda; jest inny prosty sposób: var xIsNaN = x !== x;daje to wartość prawdy tylko wtedy, gdy x jest NaN.
Raphael Schweikert

1

Inne rozwiązanie wspomniane jest na stronie parseFloat w MDN

Zapewnia funkcję filtrowania do dokładnego analizowania

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

A potem możesz użyć, isNaNaby sprawdzić, czy tak jestNaN


1

Dokładny sposób sprawdzenia to:

//takes care of boolen, undefined and empty

isNaN(x) || typeof(x) ==='boolean' || typeof(x) !=='undefined' || x!=='' ? 'is really a nan' : 'is a number'

1

Stworzyłem tę małą funkcję, która działa jak urok. Zamiast sprawdzania NaN, który wydaje się sprzeczny z intuicją, sprawdzasz liczbę. Jestem pewien, że nie jestem pierwszym, który zrobił to w ten sposób, ale pomyślałem, że się podzielę.

function isNum(val){
    var absVal = Math.abs(val);
    var retval = false;
    if((absVal-absVal) == 0){
        retval = true
    }

    return retval;
}


1

Odpowiedź markyzm działa dobrze, ale nie zwraca fałszu, Infinityponieważ Infinity technicznie nie jest liczbą.

wymyśliłem isNumberfunkcję, która sprawdzi, czy jest to liczba.

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

AKTUALIZACJA: zauważyłem, że ten kod zawodzi w przypadku niektórych parametrów, więc poprawiłem go.

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


Twoje założenie, że nieskończoność nie jest technicznie liczbą, jest technicznie wadliwe: math.stackexchange.com/questions/36289/is-infinity-a-number . Z mojego odczytania odpowiedzi wynika, że ​​nieskończoność będąca liczbą zależy od kontekstu.
Jon P

zamierzam przenieść to na inne pytanie
adddff

1
alert("1234567890.".indexOf(String.fromCharCode(mycharacter))>-1);

To nie jest eleganckie. ale po wypróbowaniu isNAN () doszedłem do tego rozwiązania, które jest kolejną alternatywą. W tym przykładzie zezwoliłem również na „.” ponieważ maskuję za float. Możesz to również odwrócić, aby upewnić się, że nie są używane żadne liczby.

("1234567890".indexOf(String.fromCharCode(mycharacter))==-1)

Jest to ocena jednoznakowa, ale można również zapętlić ciąg znaków, aby sprawdzić dowolne liczby.


1

Możesz sprawdzić NaN za pomocą funkcji javascript isNaN. Tylko przekazanie liczby lub wartości do funkcji 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

0

Po prostu przekonwertuj wynik na String i porównaj z „NaN”.

var val = Number("test");
if(String(val) === 'NaN') {
   console.log("true");
}

0

Czy (NaN> = 0) ? ...... „ Nie wiem ”.

function IsNotNumber( i ){
    if( i >= 0 ){ return false; }
    if( i <= 0 ){ return false; }
    return true;
}

Warunki są wykonywane tylko wtedy, gdy PRAWDA .

Nie na FAŁSZ .

Nie w „ Nie wiem ”.


niezbyt przydatne, jeśli wyraźnie szukasz wartości NaN zamiast szukać czegoś przeciwnego
liviu blidar
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.