Pertanyaan Apakah ada cara (built-in) di JavaScript untuk memeriksa apakah string adalah angka yang valid?


Saya berharap ada sesuatu di ruang konseptual yang sama dengan fungsi VB6 IsNumeric () yang lama?


799
2017-10-06 19:12


asal


Jawaban:


Untuk memeriksa apakah suatu variabel (termasuk string) adalah angka, periksa apakah itu bukan angka:

Ini berfungsi terlepas apakah variabel mengandung string atau angka.

isNaN(num)         // returns true if the variable does NOT contain a valid number

Contoh

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Tentu saja, Anda dapat meniadakan ini jika perlu. Misalnya, untuk mengimplementasikan IsNumeric contoh yang Anda berikan:

function isNumeric(num){
  return !isNaN(num)
}

Untuk mengonversi string yang berisi angka menjadi angka:

hanya berfungsi jika string hanya mengandung karakter numerik, yang lain mengembalikannya NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Contoh

+'12'              // 12
+'12.'             // 12
+'12..'            // Nan
+'.12'             // 0.12
+'..12'            // Nan
+'foo'             // NaN
+'12px'            // NaN

Untuk mengonversi string secara longgar ke angka

berguna untuk mengkonversi '12px' ke 12, misalnya:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Contoh

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

Mengapung

Ingatlah bahwa, tidak seperti itu +num, parseInt (seperti namanya) akan mengkonversi float menjadi integer dengan memotong segala sesuatu mengikuti titik desimal (jika Anda ingin menggunakan parseInt()  karena perilaku ini, Anda mungkin lebih baik menggunakan metode lain sebagai gantinya):

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

String kosong

String kosong mungkin sedikit kontra-intuitif. +num mengkonversi string kosong ke nol, dan isNaN() berasumsi sama:

+''                // 0
isNaN('')          // false

Tapi parseInt() tidak setuju:

parseInt('')       // NaN

1667
2017-10-06 19:24



Dan Anda bisa menggunakan jalur RegExp:

var num = "987238";

if(num.match(/^-{0,1}\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

35
2017-10-06 19:20



Coba isNan function:

Fungsi isNaN () menentukan apakah suatu nilai merupakan nomor ilegal (Not-a-Number).

Fungsi ini mengembalikan nilai true jika nilainya setara dengan NaN. Kalau tidak, ia akan kembali salah.

Fungsi ini berbeda dari Nomor tertentu Number.isNaN () metode.

Fungsi isNaN () global, mengonversi nilai yang diuji ke Angka, lalu mengujinya.

Number.isNan () tidak mengonversi nilai menjadi Angka, dan tidak akan mengembalikan nilai sebenarnya yang bukan dari Jenis angka ...


21
2017-10-06 19:14



Jika Anda benar-benar ingin memastikan bahwa string hanya berisi angka, nomor apa pun (bilangan bulat atau titik mengambang), dan persisnya angka, Anda tidak bisa menggunakan parseInt()/ parseFloat(), Number(), atau !isNaN() oleh mereka sendiri. Perhatikan itu !isNaN() sebenarnya kembali true kapan Number() akan mengembalikan angka, dan false kapan itu akan kembali NaN, jadi saya akan mengecualikannya dari sisa diskusi.

Masalah dengan parseFloat() adalah bahwa ia akan mengembalikan angka jika string mengandung angka apa pun, bahkan jika string tidak berisi hanya dan persis sebuah angka:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Masalah dengan Number() adalah bahwa ia akan mengembalikan angka dalam kasus di mana nilai yang diteruskan bukan angka sama sekali!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Masalah dengan menggulirkan regex Anda sendiri adalah bahwa kecuali Anda membuat regex yang tepat untuk mencocokkan nomor floating point sebagai Javascript mengenali itu Anda akan melewatkan kasus atau mengenali kasus di mana Anda tidak seharusnya. Dan bahkan jika Anda dapat menggulirkan regex Anda sendiri, mengapa? Ada cara built-in yang lebih sederhana untuk melakukannya.

Namun, ternyata itu Number() (dan isNaN()) melakukan hal yang benar untuk setiap kasus di mana parseFloat()mengembalikan angka saat seharusnya tidak, dan sebaliknya. Jadi untuk mengetahui apakah string benar-benar tepat dan hanya angka, panggil kedua fungsi dan lihat apakah mereka kedua mengembalikan true:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

20
2018-03-02 22:56



Jika Anda hanya mencoba untuk memeriksa apakah string adalah angka bulat (tidak ada tempat desimal), regex adalah cara yang baik untuk pergi. Metode lain seperti isNaN terlalu rumit untuk sesuatu yang sangat sederhana.

function isNumeric(value) {
    return /^-{0,1}\d+$/.test(value);
}

console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Untuk hanya mengizinkan positif seluruh angka menggunakan ini:

function isNumeric(value) {
    return /^\d+$/.test(value);
}

console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

17
2018-06-27 17:13



Pertanyaan lama, tetapi ada beberapa poin yang hilang dalam jawaban yang diberikan.

Notasi ilmiah.

!isNaN('1e+30') aku s trueNamun dalam sebagian besar kasus ketika orang meminta nomor, mereka tidak ingin mencocokkan hal-hal seperti 1e+30.

Angka mengambang besar mungkin bertingkah aneh

Amati (menggunakan Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

Di samping itu:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Jadi, jika seseorang mengharapkan String(Number(s)) === s, maka lebih baik batasi string Anda hingga 15 digit paling banyak (setelah menghilangkan angka nol di depan).

Infinity

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Mengingat semua itu, memeriksa bahwa string yang diberikan adalah angka yang memuaskan semua hal berikut:

  • notasi non ilmiah
  • konversi yang dapat diprediksi menjadi Number dan kembali ke String
  • terbatas

bukan tugas yang mudah. Ini adalah versi sederhana:

  function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

Namun, bahkan yang satu ini masih jauh dari sempurna. Memimpin nol tidak ditangani di sini, tetapi mereka mengaitkan uji panjang.


10
2017-10-02 11:28



parseInt (), tetapi perlu diketahui bahwa fungsi ini sedikit berbeda dalam arti misalnya mengembalikan 100 untuk parseInt ("100px").


5
2017-10-06 19:16



Anda dapat menggunakan hasil dari Jumlah ketika melewati argumen ke konstruktornya.

Jika argumen (string) tidak dapat diubah menjadi angka, ia mengembalikan NaN, sehingga Anda dapat menentukan apakah string yang disediakan adalah angka yang valid atau tidak.

Catatan: Catatan saat mengirim string kosong atau '\t\t' dan '\n\t' sebagai Nomor akan mengembalikan 0; Melewati true akan mengembalikan 1 dan hasil salah 0.

    Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  

    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN

    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

5
2018-03-13 09:31



Mungkin ada satu atau dua orang yang menemukan pertanyaan ini yang membutuhkan jauh lebih ketat periksa dari biasanya (seperti yang saya lakukan). Dalam hal ini, ini mungkin berguna:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Awas! Ini akan menolak string seperti .1, 40.000, 080, 00.1. Ini sangat pemilih - string harus sesuai dengan "bentuk sempurna paling minimal"Jumlah untuk tes ini untuk lulus.

Ini menggunakan String dan Number konstruktor untuk mentransmisikan string ke angka dan kembali lagi dan dengan demikian memeriksa apakah "minimal form" dari mesin JavaScript itu (yang diubah menjadi dengan awal Number konstruktor) cocok dengan string asli.


5
2018-01-09 10:57