Überprüfen Dezimalzahlen in JavaScript - IsNumeric()

StackOverflow https://stackoverflow.com/questions/18082

  •  09-06-2019
  •  | 
  •  

Frage

Was ist der sauberste und effektivste Weg, um zu überprüfen Dezimalzahlen in JavaScript?

Bonus-Punkte für:

  1. Klarheit.Die Lösung sollte einfach und sauber.
  2. Cross-Plattform.

Testfälle:

01. IsNumeric('-1')      => true
02. IsNumeric('-1.5')    => true
03. IsNumeric('0')       => true
04. IsNumeric('0.42')    => true
05. IsNumeric('.42')     => true
06. IsNumeric('99,999')  => false
07. IsNumeric('0x89f')   => false
08. IsNumeric('#abcdef') => false
09. IsNumeric('1.2.3')   => false
10. IsNumeric('')        => false
11. IsNumeric('blah')    => false
War es hilfreich?

Lösung

@Joel Antwort ist ziemlich eng, aber es wird nicht in den folgenden Fällen:

// Whitespace strings:
IsNumeric(' ')    == true;
IsNumeric('\t\t') == true;
IsNumeric('\n\r') == true;

// Number literals:
IsNumeric(-1)  == false;
IsNumeric(0)   == false;
IsNumeric(1.1) == false;
IsNumeric(8e5) == false;

Vor einiger Zeit hatte ich um die Durchführung einer IsNumeric Funktion, um herauszufinden, ob eine variable enthalten einen numerischen Wert, unabhängig von der Art, es könnte eine String mit einem numerischen Wert (ich hatte zu prüfen, auch die Exponentialdarstellung, etc.), ein Number Objekt, nahezu alles kann übergeben werden, die Funktion konnte ich nicht machen jede Art Annahmen, die Pflege der Typ Zwang (zB. +true == 1; aber true sollte man Sie nicht als "numeric").

Ich denke, lohnt sich das teilen dieser Satz von +30 unit-tests gemacht, um zahlreiche Funktion Implementierungen, und auch das eine, dass er alle meine tests:

function isNumeric(n) {
    return !isNaN(parseFloat(n)) && isFinite(n);
}

P. S. isNaN & isFinite eine verwirrende Verhalten aufgrund von erzwungener Konvertierung zur Zahl.In ES6, Anzahl.isNaN & Anzahl.isFinite würde lösen diese Probleme.Halten, dass in Geist, wenn mit Ihnen.

Update : Hier ist, wie jQuery funktioniert es jetzt (2.2-stable): 

isNumeric: function(obj) {
    var realStringObj = obj && obj.toString();
    return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
}

Update : Angular 4.3:

export function isNumeric(value: any): boolean {
    return !isNaN(value - parseFloat(value));
}

Andere Tipps

Arrrgh!Hören Sie nicht auf die reguläre Ausdrücke Antworten.RegEx ist eklig, und ich spreche nicht nur Leistung.Es ist so einfach zu machen subtile, unmöglich zu erkennen Fehler mit Ihrem regulären Ausdruck.

Wenn Sie nicht verwenden kann isNaN(), sollte diese Arbeit noch viel besser:

function IsNumeric(input)
{
    return (input - 0) == input && (''+input).trim().length > 0;
}

Hier ist, wie es funktioniert:

Die (input - 0) Ausdruck der Kräfte JavaScript zu tun, geben Sie Zwang, auf Ihre input-Wert;es muss zunächst verstanden werden als eine Zahl für die Subtraktion.Wenn eine Konvertierung in eine Zahl fehlschlägt, wird der Ausdruck Folge NaN.Diese numerische Ergebnis ist dann im Vergleich zu den ursprünglichen Wert, den Sie übergeben.Da die linke Seite ist nun numerisch, geben Sie Zwang wieder verwendet werden.Nun, dass der input von beiden Seiten war gezwungen auf den gleichen Typ von der gleichen ursprünglichen Wert, würden Sie denken, dass Sie sollten immer das gleiche (immer wahr).Es gibt jedoch eine spezielle Regel, die sagt, NaN ist nie gleich NaN, und damit ein Wert, der nicht in eine Zahl konvertiert werden (und nur Werte, die nicht in zahlen umgewandelt werden) führt zu falschen.

Die Prüfung auf die Länge ist für einen speziellen Fall mit leeren Zeichenfolgen.Beachten Sie auch, dass es fällt auf Ihre 0x89f test, aber das ist, weil in vielen Umgebungen ist ein guter Weg, um zu definieren, ein zahlenliteral.Wenn Sie möchten, zu fangen, die bestimmten Szenario könnte man hinzufügen, eine zusätzliche überprüfung.Noch besser, wenn das dein Grund für die nicht-Verwendung isNaN() dann einfach wickeln Sie Ihre eigene Funktion, um isNaN() das kann auch nicht die weitere Prüfung.

In Zusammenfassung, wenn Sie wissen möchten, ob ein Wert in eine Zahl umgewandelt werden, tatsächlich zu versuchen, ihn in eine Zahl umzuwandeln.

Ich ging zurück und habe einige der Forschung für warum eine whitespace-Zeichenfolge nicht die erwartete Leistung, und ich denke, ich bekomme es jetzt:eine leere Zeichenfolge ist dazu gezwungen 0 anstatt NaN.Einfach trimmen der Schnur, bevor die Länge überprüfen, werden in diesem Fall behandeln.

Das ausführen der unit-tests gegen den neuen code, und es schlägt nur auf den infinity-und boolean-Literale, und das einzige mal, das sollte ein problem sein, wenn Sie code generieren (wirklich, wer würde geben, die in einer direkten und prüfen, ob es numerisch?Sollten Sie weiß), und das wäre eine seltsame code zu generieren.

Aber, wieder, der einzige Grund, jemals zu verwenden ist, wenn für einige Grund Sie haben, um zu vermeiden, isNaN().

Auf diese Weise scheint gut zu funktionieren:

function IsNumeric(input){
    var RE = /^-{0,1}\d*\.{0,1}\d+$/;
    return (RE.test(input));
}

Und um es zu testen:

// alert(TestIsNumeric());

function TestIsNumeric(){
    var results = ''
    results += (IsNumeric('-1')?"Pass":"Fail") + ": IsNumeric('-1') => true\n";
    results += (IsNumeric('-1.5')?"Pass":"Fail") + ": IsNumeric('-1.5') => true\n";
    results += (IsNumeric('0')?"Pass":"Fail") + ": IsNumeric('0') => true\n";
    results += (IsNumeric('0.42')?"Pass":"Fail") + ": IsNumeric('0.42') => true\n";
    results += (IsNumeric('.42')?"Pass":"Fail") + ": IsNumeric('.42') => true\n";
    results += (!IsNumeric('99,999')?"Pass":"Fail") + ": IsNumeric('99,999') => false\n";
    results += (!IsNumeric('0x89f')?"Pass":"Fail") + ": IsNumeric('0x89f') => false\n";
    results += (!IsNumeric('#abcdef')?"Pass":"Fail") + ": IsNumeric('#abcdef') => false\n";
    results += (!IsNumeric('1.2.3')?"Pass":"Fail") + ": IsNumeric('1.2.3') => false\n";
    results += (!IsNumeric('')?"Pass":"Fail") + ": IsNumeric('') => false\n";
    results += (!IsNumeric('blah')?"Pass":"Fail") + ": IsNumeric('blah') => false\n";

    return results;
}

Ich lieh mir, dass regex aus http://www.codetoad.com/javascript/isnumeric.asp.Erklärung:

/^ match beginning of string
-{0,1} optional negative sign
\d* optional digits
\.{0,1} optional decimal point
\d+ at least one digit
$/ match end of string

Yahoo!UI nutzt diese:

isNumber: function(o) {
    return typeof o === 'number' && isFinite(o);
}

function IsNumeric(num) {
     return (num >=0 || num < 0);
}

Dies funktioniert für 0x23 geben Sie zahlen als gut.

Die akzeptierte Antwort scheiterte Ihr test #7 und ich denke, es ist, weil Sie Ihre Meinung geändert.Das ist also eine Antwort auf die akzeptierte Antwort, mit der ich hatte Probleme.

Während einige Projekte, die ich brauchte, um einige Daten validieren und so sicher wie möglich, dass es ein javascript numerischen Wert ein, der verwendet werden kann, die in mathematischen Operationen.

jQuery und einige andere javascript-Bibliotheken enthalten bereits eine solche Funktion, die normalerweise als isNumeric.Es ist auch eine post on stackoverflow das wurde weithin angenommen, als die Antwort, die dieselbe Allgemeine routine, die die oben genannten Bibliotheken verwenden.

function isNumber(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

Erste, der obige code würde true zurückgeben, wenn das argument ein array mit der Länge 1, und das einzige element war, einen Typ, der als numerischer durch die oben genannten Logik.Meiner Meinung nach, wenn es ein array, dann ist nicht numerisch.

Um dieses problem zu beheben, fügte ich eine überprüfung Rabatt-arrays aus der Logik

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n);
}

Natürlich, Sie könnte auch verwenden Array.isArray, jquery $.isArray oder Prototyp Object.isArray statt Object.prototype.toString.call(n) !== '[object Array]'

Mein zweites Problem war, dass Negative Hexadecimal integer literal-strings ("-0xA" -> -10) wurden nicht gezählt werden, die als numerische.Jedoch auch Positive Hexadecimal integer literal-strings ("0xA" -> 10) behandelt wurden, die als numerische.Ich brauchte beide, um gültig zu sein numerisch.

Danach baute ich die Logik, um dies zu berücksichtigen.

function isNumber(n) {
  return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

Wenn Sie sind besorgt über die Erstellung der regex-jedes mal, wenn die Funktion aufgerufen wird, dann könnte man umschreiben, dass es innerhalb einer Schließung, so etwas wie dieses

var isNumber = (function () {
  var rx = /^-/;

  return function (n) {
      return Object.prototype.toString.call(n) !== '[object Array]' &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(rx, ''));
  };
}());

Ich nahm dann CMSs +30 Testfälle und geklont Tests auf jsfiddle Hinzugefügt meine zusätzliche Testfälle und meine oben beschriebene Lösung.

Es kann nicht ersetzen die allgemein akzeptiert und verwendet beantworten, aber wenn dies ist, was Sie erwarten, wie Ergebnisse aus der isNumeric-Funktion dann hoffentlich eine Hilfe sein.

EDIT: Wie bereits von der Bergi, gibt es andere mögliche Objekte, die betrachtet werden könnten numerischen und es wäre besser, auf die whitelist als blacklist.Mit diesem im Verstand, würde ich hinzufügen, um die Kriterien.

Ich möchte, dass meine isNumeric-Funktion, um zu prüfen, nur aus Zahlen oder Zeichenketten

Mit diesem im Verstand, es wäre besser, verwenden

function isNumber(n) {
  return (Object.prototype.toString.call(n) === '[object Number]' || Object.prototype.toString.call(n) === '[object String]') &&!isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
}

Testen Sie die Lösungen

var testHelper = function() {

  var testSuite = function() {
    test("Integer Literals", function() {
      ok(isNumber("-10"), "Negative integer string");
      ok(isNumber("0"), "Zero string");
      ok(isNumber("5"), "Positive integer string");
      ok(isNumber(-16), "Negative integer number");
      ok(isNumber(0), "Zero integer number");
      ok(isNumber(32), "Positive integer number");
      ok(isNumber("040"), "Octal integer literal string");
      ok(isNumber(0144), "Octal integer literal");
      ok(isNumber("-040"), "Negative Octal integer literal string");
      ok(isNumber(-0144), "Negative Octal integer literal");
      ok(isNumber("0xFF"), "Hexadecimal integer literal string");
      ok(isNumber(0xFFF), "Hexadecimal integer literal");
      ok(isNumber("-0xFF"), "Negative Hexadecimal integer literal string");
      ok(isNumber(-0xFFF), "Negative Hexadecimal integer literal");
    });

    test("Foating-Point Literals", function() {
      ok(isNumber("-1.6"), "Negative floating point string");
      ok(isNumber("4.536"), "Positive floating point string");
      ok(isNumber(-2.6), "Negative floating point number");
      ok(isNumber(3.1415), "Positive floating point number");
      ok(isNumber(8e5), "Exponential notation");
      ok(isNumber("123e-2"), "Exponential notation string");
    });

    test("Non-Numeric values", function() {
      equals(isNumber(""), false, "Empty string");
      equals(isNumber("        "), false, "Whitespace characters string");
      equals(isNumber("\t\t"), false, "Tab characters string");
      equals(isNumber("abcdefghijklm1234567890"), false, "Alphanumeric character string");
      equals(isNumber("xabcdefx"), false, "Non-numeric character string");
      equals(isNumber(true), false, "Boolean true literal");
      equals(isNumber(false), false, "Boolean false literal");
      equals(isNumber("bcfed5.2"), false, "Number with preceding non-numeric characters");
      equals(isNumber("7.2acdgs"), false, "Number with trailling non-numeric characters");
      equals(isNumber(undefined), false, "Undefined value");
      equals(isNumber(null), false, "Null value");
      equals(isNumber(NaN), false, "NaN value");
      equals(isNumber(Infinity), false, "Infinity primitive");
      equals(isNumber(Number.POSITIVE_INFINITY), false, "Positive Infinity");
      equals(isNumber(Number.NEGATIVE_INFINITY), false, "Negative Infinity");
      equals(isNumber(new Date(2009, 1, 1)), false, "Date object");
      equals(isNumber(new Object()), false, "Empty object");
      equals(isNumber(function() {}), false, "Instance of a function");
      equals(isNumber([]), false, "Empty Array");
      equals(isNumber(["-10"]), false, "Array Negative integer string");
      equals(isNumber(["0"]), false, "Array Zero string");
      equals(isNumber(["5"]), false, "Array Positive integer string");
      equals(isNumber([-16]), false, "Array Negative integer number");
      equals(isNumber([0]), false, "Array Zero integer number");
      equals(isNumber([32]), false, "Array Positive integer number");
      equals(isNumber(["040"]), false, "Array Octal integer literal string");
      equals(isNumber([0144]), false, "Array Octal integer literal");
      equals(isNumber(["-040"]), false, "Array Negative Octal integer literal string");
      equals(isNumber([-0144]), false, "Array Negative Octal integer literal");
      equals(isNumber(["0xFF"]), false, "Array Hexadecimal integer literal string");
      equals(isNumber([0xFFF]), false, "Array Hexadecimal integer literal");
      equals(isNumber(["-0xFF"]), false, "Array Negative Hexadecimal integer literal string");
      equals(isNumber([-0xFFF]), false, "Array Negative Hexadecimal integer literal");
      equals(isNumber([1, 2]), false, "Array with more than 1 Positive interger number");
      equals(isNumber([-1, -2]), false, "Array with more than 1 Negative interger number");
    });
  }

  var functionsToTest = [

    function(n) {
      return !isNaN(parseFloat(n)) && isFinite(n);
    },

    function(n) {
      return !isNaN(n) && !isNaN(parseFloat(n));
    },

    function(n) {
      return !isNaN((n));
    },

    function(n) {
      return !isNaN(parseFloat(n));
    },

    function(n) {
      return typeof(n) != "boolean" && !isNaN(n);
    },

    function(n) {
      return parseFloat(n) === Number(n);
    },

    function(n) {
      return parseInt(n) === Number(n);
    },

    function(n) {
      return !isNaN(Number(String(n)));
    },

    function(n) {
      return !isNaN(+('' + n));
    },

    function(n) {
      return (+n) == n;
    },

    function(n) {
      return n && /^-?\d+(\.\d+)?$/.test(n + '');
    },

    function(n) {
      return isFinite(Number(String(n)));
    },

    function(n) {
      return isFinite(String(n));
    },

    function(n) {
      return !isNaN(n) && !isNaN(parseFloat(n)) && isFinite(n);
    },

    function(n) {
      return parseFloat(n) == n;
    },

    function(n) {
      return (n - 0) == n && n.length > 0;
    },

    function(n) {
      return typeof n === 'number' && isFinite(n);
    },

    function(n) {
      return !Array.isArray(n) && !isNaN(parseFloat(n)) && isFinite(n.toString().replace(/^-/, ''));
    }

  ];


  // Examines the functionsToTest array, extracts the return statement of each function
  // and fills the toTest select element.
  var fillToTestSelect = function() {
    for (var i = 0; i < functionsToTest.length; i++) {
      var f = functionsToTest[i].toString();
      var option = /[\s\S]*return ([\s\S]*);/.exec(f)[1];
      $("#toTest").append('<option value="' + i + '">' + (i + 1) + '. ' + option + '</option>');
    }
  }

  var performTest = function(functionNumber) {
    reset(); // Reset previous test
    $("#tests").html(""); //Clean test results
    isNumber = functionsToTest[functionNumber]; // Override the isNumber global function with the one to test
    testSuite(); // Run the test

    // Get test results
    var totalFail = 0;
    var totalPass = 0;
    $("b.fail").each(function() {
      totalFail += Number($(this).html());
    });
    $("b.pass").each(function() {
      totalPass += Number($(this).html());
    });
    $("#testresult").html(totalFail + " of " + (totalFail + totalPass) + " test failed.");

    $("#banner").attr("class", "").addClass(totalFail > 0 ? "fail" : "pass");
  }

  return {
    performTest: performTest,
    fillToTestSelect: fillToTestSelect,
    testSuite: testSuite
  };
}();


$(document).ready(function() {
  testHelper.fillToTestSelect();
  testHelper.performTest(0);

  $("#toTest").change(function() {
    testHelper.performTest($(this).children(":selected").val());
  });
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js" type="text/javascript"></script>
<script src="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.js" type="text/javascript"></script>
<link href="https://rawgit.com/Xotic750/testrunner-old/master/testrunner.css" rel="stylesheet" type="text/css">
<h1>isNumber Test Cases</h1>

<h2 id="banner" class="pass"></h2>

<h2 id="userAgent">Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.95 Safari/537.11</h2>

<div id="currentFunction"></div>

<div id="selectFunction">
  <label for="toTest" style="font-weight:bold; font-size:Large;">Select function to test:</label>
  <select id="toTest" name="toTest">
  </select>
</div>

<div id="testCode"></div>

<ol id="tests">
  <li class="pass">
    <strong>Integer Literals <b style="color:black;">(0, 10, 10)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative integer string</li>

      <li class="pass">Zero string</li>

      <li class="pass">Positive integer string</li>

      <li class="pass">Negative integer number</li>

      <li class="pass">Zero integer number</li>

      <li class="pass">Positive integer number</li>

      <li class="pass">Octal integer literal string</li>

      <li class="pass">Octal integer literal</li>

      <li class="pass">Hexadecimal integer literal string</li>

      <li class="pass">Hexadecimal integer literal</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Foating-Point Literals <b style="color:black;">(0, 6, 6)</b></strong>

    <ol style="display: none;">
      <li class="pass">Negative floating point string</li>

      <li class="pass">Positive floating point string</li>

      <li class="pass">Negative floating point number</li>

      <li class="pass">Positive floating point number</li>

      <li class="pass">Exponential notation</li>

      <li class="pass">Exponential notation string</li>
    </ol>
  </li>

  <li class="pass">
    <strong>Non-Numeric values <b style="color:black;">(0, 18, 18)</b></strong>

    <ol style="display: none;">
      <li class="pass">Empty string: false</li>

      <li class="pass">Whitespace characters string: false</li>

      <li class="pass">Tab characters string: false</li>

      <li class="pass">Alphanumeric character string: false</li>

      <li class="pass">Non-numeric character string: false</li>

      <li class="pass">Boolean true literal: false</li>

      <li class="pass">Boolean false literal: false</li>

      <li class="pass">Number with preceding non-numeric characters: false</li>

      <li class="pass">Number with trailling non-numeric characters: false</li>

      <li class="pass">Undefined value: false</li>

      <li class="pass">Null value: false</li>

      <li class="pass">NaN value: false</li>

      <li class="pass">Infinity primitive: false</li>

      <li class="pass">Positive Infinity: false</li>

      <li class="pass">Negative Infinity: false</li>

      <li class="pass">Date object: false</li>

      <li class="pass">Empty object: false</li>

      <li class="pass">Instance of a function: false</li>
    </ol>
  </li>
</ol>

<div id="main">
  This page contains tests for a set of isNumber functions. To see them, take a look at the source.
</div>

<div>
  <p class="result">Tests completed in 0 milliseconds.
    <br>0 tests of 0 failed.</p>
</div>

Ja, gebaut-in isNaN(object) viel schneller als jede regex-parsing, weil es ist gebaut-in und kompiliert statt interpretiert, die auf die Fliegen.

Auch wenn die Ergebnisse etwas anders, was Sie suchen (versuchen Sie es):

                                              // IS NUMERIC
document.write(!isNaN('-1') + "<br />");      // true
document.write(!isNaN('-1.5') + "<br />");    // true
document.write(!isNaN('0') + "<br />");       // true
document.write(!isNaN('0.42') + "<br />");    // true
document.write(!isNaN('.42') + "<br />");     // true
document.write(!isNaN('99,999') + "<br />");  // false
document.write(!isNaN('0x89f') + "<br />");   // true
document.write(!isNaN('#abcdef') + "<br />"); // false
document.write(!isNaN('1.2.3') + "<br />");   // false
document.write(!isNaN('') + "<br />");        // true
document.write(!isNaN('blah') + "<br />");    // false

Verwenden Sie die Funktion isNaN.Ich glaube, wenn Sie den test für die !isNaN(yourstringhere) es funktioniert gut für jede dieser Situationen.

Seit jQuery 1.7, können Sie Sie nutzen jQuery.isNumeric():

$.isNumeric('-1');      // true
$.isNumeric('-1.5');    // true
$.isNumeric('0');       // true
$.isNumeric('0.42');    // true
$.isNumeric('.42');     // true
$.isNumeric('0x89f');   // true (valid hexa number)
$.isNumeric('99,999');  // false
$.isNumeric('#abcdef'); // false
$.isNumeric('1.2.3');   // false
$.isNumeric('');        // false
$.isNumeric('blah');    // false

Nur beachten Sie, dass im Gegensatz zu dem, was Sie sagte, 0x89f eine gültige Zahl (hexa)

Es kann getan werden, ohne RegExp als 

function IsNumeric(data){
    return parseFloat(data)==data;
}

Erkenne ich die ursprüngliche Frage nicht zu erwähnen, jQuery, aber wenn Sie jQuery verwenden, können Sie tun:

$.isNumeric(val)

Einfach.

https://api.jquery.com/jQuery.isNumeric/ (ab jQuery 1.7)

Wenn ich mich nicht Irre, sollte dies passen jede gültige JavaScript-number-Wert, ohne Konstanten (Infinity, NaN), und das Vorzeichen-Operatoren +/- (weil Sie sind nicht wirklich Teil der Reihe, soweit ich besorgt, Sie sind separate Operatoren):

Ich brauchte diese für einen tokenizer, wo senden die Anzahl zu JavaScript für die Bewertung war keine option...Es ist definitiv nicht der kürzest möglichen regulären Ausdruck, aber ich glaube, es fängt all die feineren Feinheiten von JavaScript Nummer syntax.

/^(?:(?:(?:[1-9]\d*|\d)\.\d*|(?:[1-9]\d*|\d)?\.\d+|(?:[1-9]\d*|\d)) 
(?:[e]\d+)?|0[0-7]+|0x[0-9a-f]+)$/i

Gültige zahlen sind:

 - 0
 - 00
 - 01
 - 10
 - 0e1
 - 0e01
 - .0
 - 0.
 - .0e1
 - 0.e1
 - 0.e00
 - 0xf
 - 0Xf

Ungültige Nummern

 - 00e1
 - 01e1
 - 00.0
 - 00x0
 - .
 - .e0

return (input - 0) == input && input.length > 0;

hat bei mir nicht funktioniert.Wenn ich in eine alert und getestet, input.length war undefined.Ich denke, es ist keine Eigenschaft, um zu überprüfen integer length.Also, was ich Tat, war

var temp = '' + input;
return (input - 0) == input && temp.length > 0;

Es hat gut funktioniert.

Für mich ist dies der beste Weg ist:

isNumber : function(v){
   return typeof v === 'number' && isFinite(v);
}

Nur ein problem hatte ich mit @CMS Antwort ist der Ausschluss des NaN und die Unendlichkeit, die nützlich sind, zahlen für viele Situationen.Eine Möglichkeit zu prüfen, zur NaN's ist zu prüfen, für numerische Werte, die nicht gleich selbst, NaN != NaN!Also, es gibt wirklich 3 tests, die Sie würde wie zu deal mit ...

function isNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) || n != n;
}
function isFiniteNumber(n) {
  n = parseFloat(n);
  return !isNaN(n) && isFinite(n);
}    
function isComparableNumber(n) {
  n = parseFloat(n);
  return (n >=0 || n < 0);
}

isFiniteNumber('NaN')
false
isFiniteNumber('OxFF')
true
isNumber('NaN')
true
isNumber(1/0-1/0)
true
isComparableNumber('NaN')
false
isComparableNumber('Infinity')
true

Meine isComparableNumber ist ziemlich nah an eine weitere elegante Antwort, sondern behandelt in hex und andere string-Repräsentationen von zahlen.

Ein integer-Wert kann überprüft werden durch:

function isNumeric(value) {
    var bool = isNaN(+value));
    bool = bool || (value.indexOf('.') != -1);
    bool = bool || (value.indexOf(",") != -1);
    return !bool;
};

Dieser Weg ist einfacher und schneller!Alle tests sind geprüft!

Hier ist eine lil bit verbesserte version (wahrscheinlich der Schnellste Weg gibt), dass ich, statt exakt die jQuery-Variante, ich weiß wirklich nicht, warum nicht diese hier verwenden:

function isNumeric(val) {
    return !isNaN(+val) && isFinite(val);
}

Die Kehrseite der jQuery-version ist, dass, wenn Sie übergeben einen string mit führenden Numerik und nachgestellte Buchstaben wie "123abc" die parseFloat | parseInt extrahieren Sie die numerische Bruchteil aus und kehren 123, ABER die zweite Garde isFinite scheitern wird es trotzdem.Mit der unäre + Betreiber, sterben auf die erste guard seit + wirft NaN für solche Hybriden :) Ein wenig Leistung, aber ich denke, eine solide semantische erlangen.

Ich möchte Folgendes hinzufügen:

1. IsNumeric('0x89f') => true
2. IsNumeric('075') => true

Positiv hex-zahlen beginnen mit 0x und negative hex-zahlen beginnen mit -0x.Positive Okt Nummern beginnen mit 0 und negative Okt Nummern beginnen mit -0.Diese nimmt man das meiste von dem, was bereits erwähnt wurde, in Betracht, sondern umfasst hexadezimal und oktal zahlen, negative wissenschaftlichen, Unendlichkeit und entfernt hat dezimal wissenschaftliche (4e3.2 ist nicht gültig).

function IsNumeric(input){
  var RE = /^-?(0|INF|(0[1-7][0-7]*)|(0x[0-9a-fA-F]+)|((0|[1-9][0-9]*|(?=[\.,]))([\.,][0-9]+)?([eE]-?\d+)?))$/;
  return (RE.test(input));
}

Ein paar tests hinzufügen:

IsNumeric('01.05') => false
IsNumeric('1.') => false
IsNumeric('.') => false

Ich kam mit dieser:

function IsNumeric(input) {
    return /^-?(0|[1-9]\d*|(?=\.))(\.\d+)?$/.test(input);
}

Die Lösung umfasst:

  • Ein optionales Minuszeichen am Anfang
  • Eine einzelne null, oder eine oder mehrere Ziffern, die nicht beginnend mit 0, - oder-nichts-so lange, wie eine Periode folgt
  • Eine Zeit, die ist gefolgt von 1 oder mehr zahlen

Meine Lösung,

function isNumeric(input) {
    var number = /^\-{0,1}(?:[0-9]+){0,1}(?:\.[0-9]+){0,1}$/i;
    var regex = RegExp(number);
    return regex.test(input) && input.length>0;
}

Es scheint zu funktionieren in jeder situation, aber ich könnte falsch sein.

Dies sollte funktionieren.Einige der Funktionen sind hier fehlerhaft, sollte auch schneller sein als für jede andere Funktion hier.

        function isNumeric(n)
        {
            var n2 = n;
            n = parseFloat(n);
            return (n!='NaN' && n2==n);
        }

Erklärt:

Erstellen einer Kopie von sich selbst, dann wandelt den Wert in float, und vergleicht sich selbst mit der ursprünglichen Anzahl, wenn es ist immer noch eine Zahl ist, (ob integer oder float) , und stimmt mit der ursprünglichen Nummer,, dass bedeutet, es ist in der Tat eine Reihe.

Es funktioniert mit numerischen strings als einfache zahlen.Funktioniert nicht mit hexadezimale zahlen.

Warnung:Nutzung auf eigene Gefahr keine Garantie.

Keine Antworten zurück false für leere Zeichenfolgen, die eine Lösung für das...

function is_numeric(n)
{
 return (n != '' && !isNaN(parseFloat(n)) && isFinite(n));
}

Um zu überprüfen, ob eine variable eine gültige Nummer enthält und nicht nur einen String, der wie eine Zahl aussieht, Number.isFinite(value) verwendet werden können.

Dies ist ein Teil der Sprache, da ES2015

Beispiele:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite('0')        // false
Number.isFinite(null)       // false

Ich bin mit einfacherer Lösung:

function isNumber(num) {
    return parseFloat(num).toString() == num
}

Ich weiß, das wurde schon oft beantwortet, aber die folgende ist eine anständige Kandidaten, die nützlich sein können in einigen Szenarien.

es sollte angemerkt werden, dass es davon ausgegangen, dass '.42' ist KEINE Zahl, und '4.' ist KEINE Zahl, so sollte dies berücksichtigt werden.

function isDecimal(x) {
  return '' + x === '' + +x;
}

function isInteger(x) {
  return '' + x === '' + parseInt(x);
}

Die isDecimal übergibt den folgenden test:

function testIsNumber(f) {
  return f('-1') && f('-1.5') && f('0') && f('0.42')
    && !f('.42') && !f('99,999') && !f('0x89f')
    && !f('#abcdef') && !f('1.2.3') && !f('') && !f('blah');
}

Die Idee hier ist, dass jede Zahl oder ganze Zahl hat eine "kanonische" string-Darstellung, und jeder nicht-kanonische Darstellung abgelehnt werden sollte.So warfen wir in eine Zahl um und zurück, und sehen, ob das Ergebnis den ursprünglichen string.

Ob diese Funktionen sind nützlich für Sie ist, hängt vom Anwendungsfall.Eine Besonderheit ist, dass unterschiedliche Zeichenfolgen repräsentieren unterschiedliche zahlen (wenn beide passieren die isNumber() test).

Dies ist relevant, z.B.für zahlen, die als Objekt-Eigenschaft-Namen.

var obj = {};
obj['4'] = 'canonical 4';
obj['04'] = 'alias of 4';
obj[4];  // prints 'canonical 4' to the console.

knockoutJs Inbuild-Bibliothek Validierung Funktionen

Durch die Ausweitung der it-Bereich erhalten überprüft

1) Anzahl

self.number = ko.observable(numberValue).extend({ number:true});

TestCase

numberValue = '0.0'    --> true
numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '-1'     --> true
numberValue = '-3.5'   --> true
numberValue = '11.112' --> true
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

2) digit

self.number = ko.observable(numberValue).extend({ digit:true});

TestCase

numberValue = '0'      --> true
numberValue = '25'     --> true
numberValue = '0.0'    --> false
numberValue = '-1'     --> false
numberValue = '-3.5'   --> false
numberValue = '11.112' --> false
numberValue = '0x89f'  --> false
numberValue = ''       --> false
numberValue = 'sfsd'   --> false
numberValue = 'dg##$'  --> false

3) min und max

self.number = ko.observable(numberValue).extend({ min:5}).extend({ max:10});

Dieses Feld akzeptiert einen Wert zwischen 5 und 10 nur

TestCase

numberValue = '5'    --> true
numberValue = '6'    --> true
numberValue = '6.5'  --> true
numberValue = '9'    --> true
numberValue = '11'   --> false
numberValue = '0'    --> false
numberValue = ''    --> false

Sie minimieren können diese Funktion in einer Menge Wege, und Sie können auch implementieren, es mit einem benutzerdefinierten regex für negative Werte oder benutzerdefinierte Diagramme:

$('.number').on('input',function(){
    var n=$(this).val().replace(/ /g,'').replace(/\D/g,'');
    if (!$.isNumeric(n))
        $(this).val(n.slice(0, -1))
    else
        $(this).val(n)
});

function inNumeric(n){
   return Number(n).toString() === n;
}

Wenn n numerisch Number(n) Rückkehr wird der numerische Wert und toString() wird, schalten Sie es wieder zu einem string.Aber wenn n ist nicht numerisch Number(n) zurück NaN so wird es nicht mit dem original übereinstimmen n

Ich denke, parseFloat-Funktion können alle tun, die hier arbeiten.Die Funktion übergibt alle tests auf dieser Seite, einschließlich isNumeric(Infinity) == true:

function isNumeric(n) {

    return parseFloat(n) == n;
}

@CMS Antwort:Das snippet nicht auf Leerzeichen Fällen auf meinem Rechner mit nodejs.Also kombinierte ich es mit @joel Antwort auf die folgenden:

is_float = function(v) {
    return !isNaN(v) && isFinite(v) &&
        (typeof(v) == 'number' || v.replace(/^\s+|\s+$/g, '').length > 0);
}

Ich unittested es mit den Fällen, die schwimmt:

var t = [
        0,
        1.2123,
        '0',
        '2123.4',
        -1,
        '-1',
        -123.423,
        '-123.432',
        07,
        0xad,
        '07',
        '0xad'
    ];

und jene Fälle, die nicht schwimmt (auch die leeren Zwischenräume und Objekte / arrays):

    var t = [
        'hallo',
        [],
        {},
        'jklsd0',
        '',
        "\t",
        "\n",
        ' '
    ];

Alles wie erwartet funktioniert hier.Vielleicht hilft dies ja.

Den vollständigen Quellcode für diese gefunden werden kann hier.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top