Saya ingin tes gagal-aman yang paling sederhana untuk memeriksa apakah string dalam JavaScript adalah bilangan bulat positif.

isNaN(str)mengembalikan true untuk semua jenis nilai non-integer dan parseInt(str)mengembalikan integer untuk string float, seperti "2.5". Dan saya tidak mau harus menggunakan beberapa plugin jQuery juga.

Dua jawaban untuk Anda:

• Berdasarkan parsing

• Ekspresi reguler

Perhatikan bahwa dalam kedua kasus, saya telah menafsirkan "bilangan bulat positif" untuk disertakan 0, meskipun 0tidak positif. Saya menyertakan catatan jika Anda ingin melarang 0.

Berdasarkan Parsing

Jika Anda menginginkannya menjadi string integer desimal yang dinormalisasi pada rentang nilai yang wajar, Anda dapat melakukan ini:

function isNormalInteger(str) {
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}

atau jika Anda ingin membolehkan spasi putih dan memimpin nol:

function isNormalInteger(str) {
    str = str.trim();
    if (!str) {
        return false;
    }
    str = str.replace(/^0+/, "") || "0";
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}

Testbed langsung (tanpa menangani angka nol atau spasi kosong):

function isNormalInteger(str) {
    var n = Math.floor(Number(str));
    return n !== Infinity && String(n) === str && n >= 0;
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isNormalInteger(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Testbed langsung ( dengan penanganan untuk memimpin nol dan spasi putih):

function isNormalInteger(str) {
    str = str.trim();
    if (!str) {
        return false;
    }
    str = str.replace(/^0+/, "") || "0";
    var n = Math.floor(Number(str));
    return String(n) === str && n >= 0;
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isNormalInteger(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", true);
test(" 123 ", true);

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Jika Anda ingin melarang 0, ubah saja >= 0ke > 0. (Atau, dalam versi yang memungkinkan angka nol di depan, hapus angka || "0"di replacetelepon.)

Cara kerjanya:

1. Dalam versi yang memungkinkan spasi dan nol terkemuka:

   • str = str.trim(); menghapus whitepace terkemuka dan tertinggal.
   • if (!str) menangkap string kosong dan kembali, tidak ada gunanya melakukan sisa pekerjaan.
   • str = str.replace(/^0+/, "") || "0"; menghapus semua 0 terkemuka dari string - tetapi jika itu menghasilkan string kosong, mengembalikan satu 0.

2. Number(str): Konversi strke angka; jumlahnya mungkin memiliki porsi fraksional, atau mungkin NaN.

3. Math.floor: Pangkas angkanya (memotong bagian pecahan).

4. String(...): Mengubah hasil kembali menjadi string desimal normal. Untuk jumlah yang sangat besar, ini akan masuk ke notasi ilmiah, yang mungkin mematahkan pendekatan ini. (Saya tidak tahu di mana perpecahan itu, detailnya ada dalam spesifikasi , tetapi untuk bilangan bulat, saya yakin itu pada titik Anda telah melampaui 21 digit [saat itu jumlahnya menjadi sangat tidak tepat, seperti IEEE-754 angka presisi ganda hanya memiliki presisi 15 digit ..)

5. ... === str: Membandingkannya dengan string asli.

6. n >= 0: Periksa apakah itu positif.

Perhatikan bahwa ini gagal untuk input "+1", input apa pun dalam notasi ilmiah yang tidak berubah menjadi notasi ilmiah yang sama di atas String(...)panggung, dan untuk nilai apa pun yang digunakan oleh nomor jenis JavaScript (IEEE-754 floating point biner presisi ganda) tidak dapat secara akurat menunjukkan parses mana yang lebih dekat ke nilai yang berbeda dari yang diberikan (yang mencakup banyak bilangan bulat lebih dari 9.007.199.254.740.992; misalnya, 1234567890123456789akan gagal). Yang pertama adalah perbaikan yang mudah, dua yang terakhir tidak begitu banyak.

Ekspresi Reguler

Pendekatan lain adalah untuk menguji karakter string melalui ekspresi reguler, jika tujuan Anda hanya mengizinkan (katakanlah) sebuah opsi +diikuti oleh salah satu 0atau string dalam format desimal normal:

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

Testbed langsung:

function isNormalInteger(str) {
    return /^\+?(0|[1-9]\d*)$/.test(str);
}
function gid(id) {
    return document.getElementById(id);
}
function test(str, expect) {
    var result = isNormalInteger(str);
    console.log(
        str + ": " +
        (result ? "Yes" : "No") +
        (expect === undefined ? "" : !!expect === !!result ? " <= OK" : " <= ERROR ***")
    );
}
gid("btn").addEventListener(
    "click",
    function() {
        test(gid("text").value);
    },
    false
);
test("1", true);
test("1.23", false);
test("1234567890123", true);
test("1234567890123.1", false);
test("0123", false); // false because we don't handle leading 0s
test(" 123 ", false); // false because we don't handle whitespace

<label>
  String:
  <input id="text" type="text" value="">
<label>
<input id="btn" type="button" value="Check">

Cara kerjanya:

1. ^: Cocokkan mulai dari string

2. \+?: Izinkan satu, opsional +(hapus ini jika Anda tidak mau)

3. (?:...|...): Izinkan salah satu dari dua opsi ini (tanpa membuat grup tangkap):

   1. (0|...): Izinkan 0sendiri ...

   2. (...|[1-9]\d*): ... atau angka yang dimulai dengan sesuatu selain 0dan diikuti oleh sejumlah angka desimal.

4. $: Cocokkan ujung string.

Jika Anda ingin melarang 0(karena itu tidak positif), ekspresi reguler menjadi adil /^\+?[1-9]\d*$/(misalnya, kita dapat kehilangan pergantian yang perlu kami izinkan 0).

Jika Anda ingin membolehkan angka nol di depan (0123, 00524), maka ganti saja alternasinya (?:0|[1-9]\d*)dengan\d+

function isNormalInteger(str) {
    return /^\+?\d+$/.test(str);
}

Jika Anda ingin membolehkan spasi putih, tambahkan \s*setelah ^dan \s*sebelum $.

Catatan untuk ketika Anda mengonversikannya menjadi angka: Pada mesin modern mungkin akan baik untuk digunakan +stratau Number(str)melakukannya, tetapi yang lebih tua mungkin memperpanjangnya dengan cara yang tidak standar (tetapi sebelumnya diizinkan) yang mengatakan nol di depan berarti oktal (basis 8), mis. "010" => 8. Setelah Anda memvalidasi angka, Anda dapat menggunakan dengan aman parseInt(str, 10)untuk memastikan bahwa itu diuraikan sebagai desimal (basis 10). parseIntakan mengabaikan sampah di akhir string, tetapi kami telah memastikan tidak ada dengan regex.

Solusi 1

Jika kami menganggap integer JavaScript sebagai nilai maksimum 4294967295(yaitu Math.pow(2,32)-1), maka solusi singkat berikut ini akan berfungsi dengan baik:

function isPositiveInteger(n) {
    return n >>> 0 === parseFloat(n);
}

DESKRIPSI:

1. Operator zero-fill right shift melakukan tiga hal penting:
   • memotong bagian desimal
     • 123.45 >>> 0 === 123
   • apakah pergeseran untuk angka negatif
     • -1 >>> 0 === 4294967295
   • "berfungsi" dalam kisaran MAX_INT
     • 1e10 >>> 0 === 1410065408
     • 1e7 >>> 0 === 10000000
2. parseFloatmelakukan parsing nomor string yang benar (pengaturan NaNuntuk string non numerik)

UJI:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e7"                  : false
"1e7"                   : true
"1e10"                  : false
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/37/

Solusi 2

Cara lain baik untuk semua nilai numerik yang valid hingga Number.MAX_VALUE, yaitu sekitar 1.7976931348623157e+308:

function isPositiveInteger(n) {
    return 0 === n % (!isNaN(parseFloat(n)) && 0 <= ~~n);
}

DESKRIPSI:

1. !isNaN(parseFloat(n))digunakan untuk menyaring murni nilai string, misalnya "", " ", "string";
2. 0 <= ~~nmenyaring negatif dan nilai-nilai non-integer besar, misalnya "-40.1", "129000098131766699";
3. (!isNaN(parseFloat(n)) && 0 <= ~~n)kembali truejika nilainya numerik dan positif ;
4. 0 === n % (...)memeriksa apakah nilainya tidak mengambang - di sini (...)(lihat 3) dievaluasi seperti 0dalam kasus false, dan seperti 1dalam kasus true.

UJI:

"0"                     : true
"23"                    : true
"-10"                   : false
"10.30"                 : false
"-40.1"                 : false
"string"                : false
"1234567890"            : true
"129000098131766699.1"  : false
"-1e10"                 : false
"1e10"                  : true
"1edf"                  : false
" "                     : false
""                      : false

DEMO: http://jsfiddle.net/5UCy4/14/

Versi sebelumnya:

function isPositiveInteger(n) {
    return n == "0" || ((n | 0) > 0 && n % 1 == 0);
}

DEMO: http://jsfiddle.net/5UCy4/2/

Sepertinya ekspresi reguler adalah caranya:

var isInt = /^\+?\d+$/.test('the string');

Solusi modern yang bekerja di node dan di lebih dari 90% dari semua browser (kecuali IE dan Opera Mini) adalah dengan menggunakan Number.isInteger diikuti oleh pemeriksaan positif sederhana.

Number.isInteger(x) && x > 0

Ini diselesaikan dalam ECMAScript 2015 .

function isPositiveInteger(x) {
    return Number.isInteger(x) && x > 0
}

Polyfil adalah:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

Jika Anda perlu mendukung input yang mungkin dalam bentuk string atau angka maka Anda dapat menggunakan fungsi ini Saya menulis sebuah test suite besar setelah semua jawaban yang ada (2/1/2018) gagal pada beberapa bentuk input.

function isPositiveInteger(v) {
  var i;
  return v && (i = parseInt(v)) && i > 0 && (i === v || ''+i === v);
}

Ini hampir merupakan pertanyaan rangkap untuk pertanyaan ini:

Validasi angka desimal dalam JavaScript - IsNumeric ()

Jawabannya adalah:

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

jadi, bilangan bulat positif adalah:

function isPositiveInteger(n) {
  var floatN = parseFloat(n);
  return !isNaN(floatN) && isFinite(n) && floatN > 0
      && floatN % 1 == 0;
}

return ((parseInt(str, 10).toString() == str) && str.indexOf('-') === -1);

tidak akan bekerja jika Anda memberikan string seperti '0001'

Fungsi saya memeriksa apakah angka + ve dan bisa memiliki nilai desimal juga.

       function validateNumeric(numValue){
            var value = parseFloat(numValue);
            if (!numValue.toString().match(/^[-]?\d*\.?\d*$/)) 
                    return false;
            else if (numValue < 0) {
                return false;
            }
            return true;        
        }

Hanya untuk membangun jawaban VisioN di atas, jika Anda menggunakan plugin validasi jQuery Anda dapat menggunakan ini:

$(document).ready(function() {
    $.validator.addMethod('integer', function(value, element, param) {
        return (value >>> 0 === parseFloat(value) && value > 0);
    }, 'Please enter a non zero integer value!');
}

Kemudian Anda dapat menggunakan dalam aturan normal Anda mengatur atau menambahkannya secara dinamis dengan cara ini:

$("#positiveIntegerField").rules("add", {required:true, integer:true});

Sederhana

function isInteger(num) {
  return (num ^ 0) === num;
}

console.log(isInteger(1));

Anda juga dapat menambah Nomor dan menetapkan fungsinya melalui prototipe.

Jika Anda menggunakan formulir HTML5, Anda bisa menggunakan atribut min="0"untuk elemen formulir <input type="number" />. Ini didukung oleh semua browser utama. Itu tidak melibatkan Javascript untuk tugas-tugas sederhana seperti itu, tetapi terintegrasi dalam standar html baru. Itu didokumentasikan di https://www.w3schools.com/tags/att_input_min.asp

(~~a == a)dimana asenarnya.

ES6:

Number.isInteger(Number(theNumberString)) > 0