Soru JavaScript'te ondalık sayıları doğrula - IsNumeric ()


JavaScript'teki ondalık sayıları doğrulamak için en etkili ve en etkili yol nedir?

Bonus puanları:

  1. Netlik. Çözüm temiz ve basit olmalıdır.
  2. Çapraz platform.

Test çantaları:

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

2156


Menşei


Sadece bir not 99,999 Fransa'da geçerli bir sayıdır, onun 99.999 uk / us biçiminde aynıdır, bu yüzden bir giriş formundan bir dize okuyorsanız, o zaman 99,999 doğru olabilir. - Re0sless
Ayrıca check out bu gönderi ve harika yorumlar. - powtac
Ondalık virgül, tüm Avrupa ve Rusya'daki standarttır (İngiltere hariç) - Calmarius
jQuery 1.7 tanıttı jQuery.isNumeric yardımcı fonksiyon api.jquery.com/jQuery.isNumeric - Ates Goral
jQuery.isNumeric OP'nin yedinci test davası başarısız olur (IsNumeric('0x89f') => *false*). Ancak, bu test vakasına katılıyorum, emin değilim. - Tim Lehner


Cevaplar:


@ Joel'in cevabı oldukça yakındır, ancak aşağıdaki durumlarda başarısız olacaktır:

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

Bir süre önce uygulamak zorunda kaldım. IsNumeric Bir değişkenin sayısal bir değer içerip içermediğini bulmak için türünden bağımsız olarak, bir olabilir String sayısal bir değer içeren (üstel gösterim, vb. düşünmem gerekiyordu), Number Nesne, hemen hemen her şey bu işleve geçilebilirdi, tip baskısı ile ilgilenen herhangi bir tip varsayım yapamadım (ör. +true == 1; fakat true olarak düşünülmemeli "numeric").

Bence bu seti paylaşmaya değer. +30 birim testleri sayısız fonksiyon uygulamalarına ve ayrıca tüm testlerimi geçenleri paylaşır:

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

Not;  isNaN & isFinite numaraya zorla dönüştürme nedeniyle kafa karıştırıcı bir davranışa sahip olmak. ES6'da Number.isNaN & Number.isFinite Bu sorunları giderir. Bunları kullanırken aklınızda bulundurun.


Güncelleştirme : İşte jQuery şimdi nasıl (2.2-kararlı):

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

Güncelleştirme : Açısal 4.3:

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

2760



Bu cevap doğru. stackoverflow.com/questions/18082/... Joel'in cevabı yanlış. Yanlış cevap, doğru olandan nasıl daha fazla oy toplayabilir? - Arvin
Bu, ondalık virgül kullandığımız diğer yerel konumlarla başarısız olur, ancak n = n.replace (/, /, "."); düzeltmek için geri dönmeden önce. - Zoltan Lengyel
@RobG, bu davranış kasıtlı, 2e308 > Number.MAX_VALUE dan beri 2e308 == Infinity. Dönen bir işlev istiyorsanız true Ayrıca pozitif ve negatif sonsuzluk değerleri için, işlevi kontrol edin 2 numaralı içinde test odası. Şerefe. - CMS
Bu arada, ünite testleri şu an tarafından kullanılıyor. jQuery projesi - CMS
jQuery şimdi de kullanma bu uygulama. - RichardTowers


Arrrgh! Normal ifade cevaplarını dinleme. RegEx bunun için saçma ve ben sadece performanstan bahsetmiyorum. Düzenli ifadenizle hataları saptamak zordur, imkansızdır.

Eğer kullanamazsan isNaN()Bu daha iyi çalışmalı:

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

İşte nasıl çalışır:

(input - 0) ifadesi, giriş değerinizde tip baskısı yapmak için JavaScript'i zorlar; İlk olarak çıkarma işlemi için bir sayı olarak yorumlanmalıdır. Bu sayıya dönüştürme başarısız olursa, ifade sonuçlanır NaN. Bu sayısal Sonuç daha sonra girdiğiniz orijinal değerle karşılaştırılır. Soldaki sayı artık sayısal olduğundan, baskı tipi tekrar kullanılır. Şimdi her iki taraftaki girdinin aynı orijinal değere göre aynı türden bir zorlamaya tabi tutulduğuna göre, her zaman aynı olması gerektiğini düşünürdünüz (her zaman doğru). Ancak, özel bir kural var diyor NaN asla eşit değildir NaNve böylece bir sayıya dönüştürülemeyen bir değer (ve yalnızca sayılara dönüştürülemeyen değerler) yanlış sonuçlanır.

Uzunluğun kontrolü boş dizeleri içeren özel bir durum içindir. Ayrıca, 0x89f testinizin üzerine düştüğünü de unutmayın, bunun nedeni, birçok ortamda, bir sayı değişkeni tanımlamanın iyi bir yolu olmasıdır. Belirli bir senaryoyu yakalamak istiyorsanız, ek bir kontrol ekleyebilirsiniz. Daha da iyisi, eğer kullanmamanın sebebi buysa isNaN() o zaman kendi işlevini etrafına sar isNaN() ek kontrol de yapabilir.

Özetle, Bir değerin bir sayıya dönüştürülüp dönüştürülmeyeceğini bilmek istiyorsanız, aslında bir sayıya dönüştürmeyi deneyin.


Geri döndüm ve araştırma yaptım niye ya Bir boşluk dizgesi beklenen çıktıya sahip değildi ve şimdi bunu elde ettiğimi düşünüyorum: boş bir dize 0 ziyade NaN. Sadece uzunluk kontrolünden önce dizgiyi kırpmak bu davayı halledecektir.

Ünite testlerini yeni koda karşı çalıştırıyorsunuz ve bu sadece sonsuzluk ve boolean editörlerde başarısız oluyor ve bir problem olması gereken tek zaman, eğer kod üretiyorsanız (gerçekten, bir editöre yazı yazan ve sayısal olup olmadığını kontrol eden)? Malısın bilmek), ve bu üretmek için biraz garip kod olurdu.

Ama yine Bunu kullanmanın tek nedeni, nedense isNaN () 'dan kaçınmak zorunda olmanızdır.


315



sadece 0x89f özel durum için hesap gerekiyorsa bile daha iyi isNumN () isNaN () etrafında bir IsNumeric () işlevini sarmak gerekiyorsa, o zaman sadece özel bir çek yapar isNaN () yanlış döndürür. - Joel Coehoorn
Bu, boşluk dizelerinde başarısız olur, örn. IsNumeric(' '), IsNumeric('\n\t'), vb tüm iade true - Crescent Fresh
Ayrıca üzerinde başarısız olacak Number değişmezleri IsNumeric(5) == false; Gönderdiğim birim testleri grubunu kontrol et, bu fonksiyon numaradır 16 Test takımında. stackoverflow.com/questions/18082/... - CMS
Düzenli ifadeler kullanmama konusunda uyardıktan sonra normal ifadenin kullanılmasının (değiştirilmesinin) kimsenin işaret edemediğine inanamıyorum ... Verilen bir boşluk, bir sayı ayrıştırmasından daha basittir, ancak yine de kesinlikle "icky" dir. - Patrick M
@Oriol Bu büyük bir sorun ... o tarihten sonra çıkarılan güvenlik düzeltmeleri olmadan, XP'den uzaklaşmak bir öncelik olmalı. - Joel Coehoorn


Bu şekilde iyi çalışır gibi görünüyor:

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

Ve bunu test etmek için:

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

Bu regex'i ödünç aldım http://www.codetoad.com/javascript/isnumeric.asp. Açıklama:

/^ 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

58



// AYRICA SİZİN TESTLERİNİZE EKLENMELİDİR + = (! IsNumeric ('-')? "Pass": "Fail") + ": IsNumeric ('-') => false \ n"; results + = (! IsNumeric ('01 ')? "Pass": "Fail") + ": IsNumeric ('01') => false \ n"; results + = (! IsNumeric ('- 01')? "Pass": "Fail") + ": IsNumeric ('- 01') => false \ n"; results + = (! IsNumeric ('000')? "Pass": "Fail") + ": IsNumeric ('000') => false \ n"; - Dan
bu ne yapar? / ^ - {0,1} \ d * \. {0,1} \ d + $ / - call-me
"{0,1}" ifadesi "?" ile değiştirilebilir, dolayısıyla regex'iniz şöyle görünecektir: /^-?\d*\.?\d+$/? - Cloud


Yahoo! UI bunu kullanır:

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

45



Bu, sayının içeriğinin aksine değişken türün daha fazla kontrol edilmesidir. İle oluşturulan sayılarda da başarısız olur new Number(1). - alex
Alex'in dediği gibi, bu aslında sorulan soruya cevap vermiyor çünkü o = 1001 ise. - Case


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

Bu, 0x23 tipi numaralar için de çalışır.


44



IsNumeric(''), IsNumeric(' '), IsNumeric(true), IsNumeric(false), IsNumeric(null) dönüş true yerine false. - Oriol
Bunu geliştirdim: stackoverflow.com/a/20712631/1985601 - daniel1426


Kabul edilen cevap 7 numaralı sınavında başarısız oldu ve sanırım zihnini değiştirdiğin için. Yani bu benim sorunlarım olan kabul edilen cevaba bir cevaptır.

Bazı projeler sırasında bazı verileri doğrulamak ve matematiksel işlemlerde kullanılabilecek bir javascript sayısal değeri olması gerektiğinden emin olmak istedim.

jQuery ve diğer bazı javascript kitaplıkları zaten böyle bir işlevi içerir, genellikle isNumeric. Ayrıca bir stackoverflow üzerinde yayınla Bu, yaygın olarak kabul edilen kütüphanelerin kullandığı aynı genel rutin olarak kabul edildi.

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

Öncelikle, eğer argüman 1 uzunluğundaki bir dizi ise, yukarıdaki kod, yukarıdaki mantık tarafından sayısal olarak kabul edilen bir tipte olan tek tiptir. Benim düşünceme göre, eğer bir dizi ise o zaman sayısal değil.

Bu sorunu hafifletmek için, mantıktan dizileri indirmeye bir kontrol ekledim

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

Tabii ki de kullanabilirsiniz Array.isArray, jquery $.isArray veya prototip Object.isArray yerine Object.prototype.toString.call(n) !== '[object Array]'

İkinci sayım Negatif Onaltılık tamsayı değişmez dizeleri ("-0xA" -> -10) sayısal olarak sayılmıyordu. Ancak, pozitif Onaltılık tamsayı değişmez dizeleri ("0xA" -> 10) sayısal olarak kabul edildi. Her ikisinin de geçerli bir sayısal olması gerekiyordu.

Daha sonra bunu hesaba katmak için mantığı değiştirdim.

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

Fonksiyon her çağrıldığında normal ifadenin oluşturulmasından endişe ediyorsanız, bir kapanış içinde yeniden yazabilirsiniz.

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

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

Sonra CMS'leri aldım +30 test çantası ve klonlanmış jsfiddle üzerinde test Ekstra test durumlarımı ve yukarıda açıklanan çözümüme ekledim.

Yaygın olarak kabul edilen / kullanılan cevabı değiştirmeyebilir, ancak bu sizin isNumeric fonksiyonunuzdan sonuç beklediğinizden daha fazlası ise, umarız bu biraz yardımcı olacaktır.

DÜZENLE: Tarafından işaret edildiği gibi Bergisayısal olarak düşünülebilecek diğer olası nesneler vardır ve kara listeye göre daha beyaz olmak daha iyi olacaktır. Bu düşünceyle ölçütleri ekleyebilirim.

İsNumeric işlevimin yalnızca Sayıları veya Dizeleri dikkate almasını istiyorum

Bu düşünceyle, kullanmak daha iyi olurdu

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(/^-/, ''));
}

Çözümleri test edin

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>


37



Bu benim görüşüme göre en korumalı işlevdir; sonuncu. Kabul edilen cevap muhtemelen tüm vakaların% 99.99'unu kapsamaktadır, ancak bu durum a)% 40'lık bir avantaja sahiptir. - Samuel
"99,999" Foating-Point literalini unutmuştun. Tüm Avrupa’da İngiltere’de geçerli bir numaradır. - Andrii Horda
Unutulmadı, sayısal olarak düşündüğüm bir şey değildi. IsNumeric('99,999') => false - Xotic750


Evet, yerleşik isNaN(object) Herhangi bir regex ayrıştırmadan çok daha hızlı olacaktır, çünkü bu, anında yorumlanması yerine yerleşik ve derlenmiş.

Sonuçlar, aradığınız şeyden biraz farklı olsa da (dene):

                                              // 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

30





JQuery 1.7'den beri kullanabilirsiniz 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

Sadece söylediğin şeyden farklı olarak, 0x89f geçerli bir sayıdır (hexa)


14



OP geçerli istiyor ondalık sayı, yani jQuery vererek isNumeric öğesinin uygun değil Çok büyük sayılar için de başarısız oluyor. - RobG


İşlevi kullanın isNaN. Eğer test ederseniz inanıyorum !isNaN(yourstringhere) Bu durumlardan herhangi biri için iyi çalışıyor.


14



Not:! İsNaN (null) == true, Number (null) == 0 olduğundan - Jonathan Lonowski
eğer (! (x == null || isNaN (x))) uyarı ("isNumeric"); // Ancak bu çözüm 0x40 kabul ediyor, bu yüzden hala ne istediğini değil. - some
Muhtemelen ne istediğinizi değil, aynı zamanda gerçek hayatta da olmayacak olanNNN ("Infinity") === false. - Erik Hesselink