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

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

Ini berfungsi terlepas dari apakah konten variabel adalah string atau angka.

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

Contohnya

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 hal ini jika perlu. Misalnya, untuk menerapkan IsNumericcontoh yang Anda berikan:

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

Untuk mengonversi string yang berisi angka menjadi angka:

Hanya berfungsi jika string hanya berisi karakter numerik, jika tidak maka string akan kembali NaN.

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

Contohnya

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

Untuk mengkonversi string secara longgar ke angka

Berguna untuk mengubah '12px' menjadi 12, misalnya:

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

Contohnya

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 +num, parseInt(seperti namanya) akan mengubah float menjadi integer dengan memangkas semua yang 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. +nummengonversi string kosong atau string dengan spasi menjadi nol, dan isNaN()mengasumsikan yang sama:

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

Tetapi parseInt()tidak setuju:

parseInt('')       // NaN
parseInt('   ')    // NaN

Dan Anda bisa menggunakan cara 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
}

Jika Anda hanya mencoba memeriksa apakah string adalah bilangan bulat (tidak ada tempat desimal), regex adalah cara yang baik untuk dilakukan. Metode lain seperti isNaNterlalu 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 bilangan bulat positif gunakan ini:

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

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

Jika Anda benar-benar ingin memastikan bahwa string hanya berisi nomor, nomor apapun (integer atau floating point), dan tepat jumlah, Anda tidak dapat menggunakan parseInt()/ parseFloat(), Number()atau !isNaN()sendiri. Perhatikan bahwa !isNaN()sebenarnya kembali truekapan Number()akan mengembalikan nomor, dan falsekapan akan kembali NaN, jadi saya akan mengecualikannya dari sisa diskusi.

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

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

Masalahnya Number()adalah bahwa ia akan mengembalikan angka jika 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 karena Javascript mengenalinya, Anda akan kehilangan case atau mengenali case di mana Anda seharusnya tidak. Dan bahkan jika Anda dapat memutar regex Anda sendiri, mengapa? Ada cara bawaan yang lebih sederhana untuk melakukannya.

Namun, ternyata Number()(dan isNaN()) melakukan hal yang benar untuk setiap kasus di mana parseFloat()mengembalikan angka ketika seharusnya tidak, dan sebaliknya. Jadi untuk mengetahui apakah string benar-benar tepat dan hanya sebuah angka, panggil kedua fungsi dan lihat apakah keduanya 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))
}

Jawaban yang diterima untuk pertanyaan ini memiliki beberapa kelemahan (seperti disorot oleh beberapa pengguna lain). Ini adalah salah satu cara termudah & terbukti untuk mendekatinya dalam javascript:

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

Berikut adalah beberapa kasus pengujian yang baik:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false

// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Coba fungsi isNan :

Fungsi isNaN () menentukan apakah suatu nilai adalah angka ilegal (Bukan-a-Number).

Fungsi ini mengembalikan true jika nilainya sama dengan NaN. Kalau tidak, ia mengembalikan false.

Fungsi ini berbeda dari metode Number.is Number.isNaN () khusus .

  Fungsi global isNaN (), mengubah nilai yang diuji menjadi Angka, lalu mengujinya.

Number.isNan () tidak mengonversi nilai menjadi Angka, dan tidak akan mengembalikan nilai true untuk nilai apa pun yang tidak dari jenis Nomor ...

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

Notasi ilmiah.

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

Angka mengambang besar mungkin berperilaku 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 paling banyak 15 digit (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 ke Numberdan kembali keString
• terbatas

bukanlah 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 lengkap. Nol pengarah tidak ditangani di sini, tetapi mereka mengacaukan uji panjang.

Saya telah menguji dan solusi Michael adalah yang terbaik. Pilih jawabannya di atas (cari halaman ini untuk "Jika Anda benar-benar ingin memastikan bahwa sebuah string" dapat menemukannya). Intinya, jawabannya adalah ini:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Ini berfungsi untuk setiap test case, yang saya dokumentasikan di sini: https://jsfiddle.net/wggehvp9/5/

Banyak solusi lain gagal untuk kasus tepi ini: '', null, "", true, dan []. Secara teori, Anda bisa menggunakannya, dengan penanganan kesalahan yang tepat, misalnya:

return !isNaN(num);

atau

return (+num === +num);

dengan penanganan khusus untuk / \ s /, null, "", true, false, [] (dan lainnya?)

Anda bisa menggunakan hasil dari Number ketika meneruskan argumen ke konstruktornya.

Jika argumen (string) tidak dapat dikonversi menjadi angka, ia mengembalikan NaN, jadi Anda dapat menentukan apakah string yang diberikan adalah angka yang valid atau tidak.

Catatan: Catatan saat meneruskan string kosong atau '\t\t'dan '\n\t'sebagai Angka akan mengembalikan 0; Passing true akan mengembalikan 1 dan pengembalian 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

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

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

Waspadalah! Ini akan menolak string seperti .1, 40.000, 080, 00.1. Ini sangat pemilih - string harus cocok dengan " bentuk paling sempurna minimal " dari angka untuk lulus tes ini.

Ini menggunakan Stringdan Numberkonstruktor untuk melemparkan string ke nomor dan kembali lagi dan dengan demikian memeriksa apakah "bentuk minimal sempurna" mesin JavaScript (yang itu dikonversi dengan Numberkonstruktor awal ) cocok dengan string asli.

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

Mengutip:

isNaN (num) // mengembalikan true jika variabel TIDAK berisi angka yang valid

tidak sepenuhnya benar jika Anda perlu memeriksa ruang depan / belakang - misalnya ketika diperlukan jumlah digit tertentu, dan Anda perlu mendapatkan, katakan, '1111' dan bukan '111' atau '111' untuk kemungkinan PIN memasukkan.

Lebih baik digunakan:

var num = /^\d+$/.test(num)

Mengapa implementasi jQuery tidak cukup baik?

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael menyarankan sesuatu seperti ini (meskipun saya telah mencuri "user1691651 - versi John yang diubah di sini):

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

Berikut ini adalah solusi dengan kemungkinan besar kinerja buruk, tetapi hasil yang solid. Ini adalah alat yang dibuat dari implementasi jQuery 1.12.4 dan jawaban Michael, dengan pemeriksaan tambahan untuk spasi awal / akhir (karena versi Michael mengembalikan true untuk angka dengan spasi awalan / spasi tambahan):

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

Versi terakhir memiliki dua variabel baru. Seseorang dapat menyiasati salah satu dari itu, dengan melakukan:

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Saya belum menguji salah satu dari ini sangat banyak, dengan cara lain selain secara manual menguji beberapa kasus penggunaan saya akan memukul dengan kesulitan saya saat ini, yang semuanya sangat standar. Ini adalah situasi "berdiri di pundak-raksasa".

Ini tidak valid untuk TypeScript karena:

declare function isNaN(number: number): boolean;

Untuk TypeScript Anda dapat menggunakan:

/^\d+$/.test(key)

Yah, saya menggunakan yang ini saya buat ...

Sejauh ini sudah berfungsi:

function checkNumber(value) {
    if ( value % 1 == 0 )
    return true;
    else
    return false;
}

Jika Anda menemukan masalah dengan itu, tolong beri tahu saya.

Jika ada yang pernah sampai sejauh ini, saya menghabiskan waktu meretas ini mencoba menambal moment.js ( https://github.com/moment/moment ). Berikut adalah sesuatu yang saya ambil dari itu:

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

Menangani kasus-kasus berikut:

Benar! :

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

Salah! :

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

Ironisnya, yang paling sulit saya perjuangkan:

isNumeric(new Number(1)) => false

Ada saran yang diterima. :]

Menggunakan JavaScript biasa:

Number.isNaN(Number('1')); // false
Number.isNaN(Number('asdf')); // true

Menggunakan Lodash:

_.isNaN(_.toNumber('1')); // false
_.isNaN(_.toNumber('asdf')); // true

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}

console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true

console.log(isNumberCandidate('Infinity'));  // true

if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

2019: Termasuk Contoh ES3, ES6 dan TypeScript

Mungkin ini telah berulang kali diulangi, namun saya bertarung dengan yang ini hari ini juga dan ingin memposting jawaban saya, karena saya tidak melihat jawaban lain yang melakukannya secara sederhana atau menyeluruh:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Naskah

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Ini tampaknya cukup sederhana dan mencakup semua pangkalan yang saya lihat di banyak posting lain dan berpikir sendiri:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Anda juga dapat mencoba sendiri isNumeric fungsi dan hanya melewati dalam kasus penggunaan ini dan memindai "benar" untuk semuanya.

Atau, untuk melihat nilai yang dikembalikan masing-masing:

2019: Pemeriksaan validitas numerik yang praktis dan ketat

Seringkali, 'angka valid' berarti nomor Javascript tidak termasuk NaN dan Infinity, yaitu 'angka terbatas'.

Untuk memeriksa validitas numerik suatu nilai (dari sumber eksternal misalnya), Anda dapat mendefinisikan dalam gaya ESlint Airbnb:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

dan gunakan seperti ini:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

PFB solusi kerja:

 function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

Selamatkan diri Anda dari sakit kepala karena mencoba menemukan solusi "bawaan".

Tidak ada jawaban yang baik, dan jawaban yang sangat bagus di utas ini salah.

npm install is-number

Dalam JavaScript, tidak selalu semudah yang seharusnya untuk memeriksa apakah suatu nilai adalah angka. Sangat umum bagi dev untuk menggunakan +, -, atau Number () untuk memberikan nilai string ke angka (misalnya, ketika nilai dikembalikan dari input pengguna, pertandingan regex, parser, dll). Tetapi ada banyak kasus tepi non-intuitif yang menghasilkan hasil yang tidak terduga:

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

Saya baru-baru ini menulis sebuah artikel tentang cara untuk memastikan variabel adalah angka yang valid: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md Artikel ini menjelaskan cara memastikan floating point atau integer, jika itu penting ( +xvs ~~x).

Artikel ini mengasumsikan variabelnya adalah a stringatau a numbersebagai permulaan dan trimtersedia / polyfilled. Tidak akan sulit untuk memperpanjangnya untuk menangani tipe lain, juga. Inilah dagingnya:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}

// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

Usaha saya sedikit membingungkan, Mungkin bukan solusi terbaik

function isInt(a){
    return a === ""+~~a
}


console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false

// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

Dalam aplikasi saya, kami hanya mengizinkan az AZ dan 0-9 karakter. Saya menemukan jawaban di atas menggunakan " string % 1 === 0" berfungsi kecuali string dimulai dengan 0xnn (seperti 0x10) dan kemudian akan mengembalikannya sebagai numerik ketika kami tidak menginginkannya. Perangkap sederhana berikut ini dalam pemeriksaan numerik saya tampaknya berhasil dalam kasus-kasus khusus kami.

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Peringatan : Ini mungkin mengeksploitasi bug lama dalam Javascript dan Actionscript [Number ("1" + the_string)% 1 === 0)], saya tidak bisa berbicara untuk itu, tetapi itulah yang kami butuhkan.

Solusi saya:

// returns true for positive ints; 
// no scientific notation, hexadecimals or floating point dots

var isPositiveInt = function(str) { 
   var result = true, chr;
   for (var i = 0, n = str.length; i < n; i++) {
       chr = str.charAt(i);
       if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
         result = false;
         break;
       };
       if (i == 0 && (chr == "0" || chr == ",")) {  //should not start with 0 or ,
         result = false;
         break;
       };
   };
   return result;
 };

Anda dapat menambahkan kondisi tambahan di dalam loop, agar sesuai dengan kebutuhan khusus Anda.

Anda dapat menggunakan tipe, seperti dengan aliran librar y, untuk mendapatkan statis, kompilasi waktu memeriksa. Tentu saja tidak terlalu berguna untuk input pengguna.

// @flow

function acceptsNumber(value: number) {
  // ...
}

acceptsNumber(42);       // Works!
acceptsNumber(3.14);     // Works!
acceptsNumber(NaN);      // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo");    // Error!

Berikut ini adalah satu-liner untuk memeriksa apakah sNumnilai numerik yang valid; telah diuji untuk berbagai macam input:

!isNaN(+s.replace(/\s|\$/g, ''));  // returns True if numeric value

Cukup gunakan isNaN(), ini akan mengonversi string ke angka dan jika mendapatkan nomor yang valid , akan kembali false...

isNaN("Alireza"); //return true
isNaN("123"); //return false

Saya menggunakan yang berikut ini:

const isNumber = s => !isNaN(+s)