Periksa apakah variabel angka atau string dalam JavaScript

Adakah yang tahu bagaimana saya bisa mengecek apakah suatu variabel adalah angka atau string dalam JavaScript?

Jika Anda berurusan dengan notasi literal, dan bukan konstruktor, Anda dapat menggunakan typeof :.

typeof "Hello World"; // string
typeof 123;           // number

Jika Anda membuat angka dan string melalui konstruktor, seperti var foo = new String("foo"), Anda harus ingat bahwa typeofmungkin kembali objectuntuk foo.

Mungkin metode yang lebih mudah memeriksa jenis akan menggunakan metode yang ditemukan di underscore.js (sumber beranotasi dapat ditemukan di sini ),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

Ini mengembalikan boolean trueuntuk yang berikut:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

Cara terbaik untuk melakukannya adalah menggunakan isNaNcasting tipe +:

Metode all-in yang diperbarui:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

Menggunakan regex yang sama:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber('123'); // true  
isNumber('123abc'); // false  
isNumber(5); // true  
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

Cara terbaik yang saya temukan adalah memeriksa metode di string, yaitu:

if (x.substring) {
// do string thing
} else{
// do other thing
}

atau jika Anda ingin melakukan sesuatu dengan memeriksa nomor untuk properti nomor,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

Ini seperti "mengetik bebek", terserah Anda mana cara yang paling masuk akal. Saya tidak memiliki cukup karma untuk berkomentar, tetapi typeof gagal untuk string dan angka kotak, yaitu:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

akan mengingatkan "objek".

Anda sedang mencari isNaN():

console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));

Lihat JavaScript isNaN () Berfungsi di MDN.

Periksa apakah nilainya berupa string literal atau objek String:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Tes unit:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

Memeriksa nomornya serupa:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Karena ES2015 cara yang benar untuk memeriksa apakah suatu variabel memiliki angka yang valid Number.isFinite(value)

Contoh:

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

Coba ini,

<script>
var regInteger = /^-?\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>

Cara terbaik untuk melakukan ini:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

Ini memenuhi uji kasus berikut:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is('String', 'test'); // true
is('Array', true); // false

Atau sesuaikan untuk mengembalikan jenis yang tidak dikenal:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

Pembaruan 12 Mei 2012: Contoh lengkap di Javascript: A Better typeof .

Berikut adalah pendekatan yang didasarkan pada gagasan untuk memaksa input ke angka atau string dengan menambahkan nol atau string nol, dan kemudian melakukan perbandingan kesetaraan yang diketik.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Untuk beberapa alasan yang tak terduga, x===x+0tampaknya berkinerja lebih baik daripadax===+x .

Apakah ada kasus di mana ini gagal?

Dalam nada yang sama:

function is_boolean(x) { return x === !!x; }

Ini tampaknya sedikit lebih cepat daripada salah satu x===true || x===falseatau typeof x==="boolean"(dan jauh lebih cepat daripadax===Boolean(x) ).

Lalu ada juga

function is_regexp(x)  { return x === RegExp(x); }

Semua ini tergantung pada keberadaan operasi "identitas" khusus untuk setiap jenis yang dapat diterapkan pada nilai apa pun dan secara andal menghasilkan nilai dari jenis yang dimaksud. Saya tidak bisa memikirkan operasi semacam itu untuk kencan.

Untuk NaN, ada

function is_nan(x) { return x !== x;}

Ini pada dasarnya adalah versi garis bawah, dan seperti berdiri sekitar empat kali lebih cepat daripada isNaN(), tetapi komentar dalam sumber garis bawah menyebutkan bahwa "NaN adalah satu-satunya angka yang tidak sama dengan dirinya sendiri" dan menambahkan tanda centang untuk _.isNumber. Mengapa? Benda apa lagi yang tidak akan menyamai diri mereka sendiri? Juga, garis bawah menggunakan - x !== +xtetapi apa bedanya+ sini?

Kemudian untuk paranoid:

function is_undefined(x) { return x===[][0]; }

atau ini

function is_undefined(x) { return x===void(0); }

Bisakah Anda membaginya dengan 1?

Saya berasumsi bahwa masalahnya adalah input string seperti: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

Hanya cara saya melakukannya baru-baru ini.

eh, bagaimana kalau saja:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

Setelah ditinjau lebih lanjut berbulan-bulan kemudian, jaminan ini hanya objobjek yang memiliki metode atau nama properti yang toLowerCaseditentukan. Saya malu dengan jawaban saya. Silakan lihat typeofsalah satu yang terpilih .

Atau cukup gunakan invert dari isNaN():

if(!isNaN(data))
  do something with the number
else
  it is a string

Dan ya, menggunakan jQuery $.isNumeric()lebih menyenangkan.

Saya pikir mengkonversi var ke string mengurangi kinerja, setidaknya tes ini dilakukan di browser terbaru.

Jadi jika Anda peduli tentang kinerja, saya akan, saya akan menggunakan ini:

typeof str === "string" || str instanceof String

untuk memeriksa apakah variabel tersebut adalah string (bahkan jika Anda menggunakan var str = new String("foo"),str instanceof String akan mengembalikan true).

Adapun memeriksa apakah itu nomor saya akan pergi untuk asli isNaN:; fungsi.

jQuery menggunakan ini:

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

Solusi ini menyelesaikan banyak masalah yang diangkat di sini!

Sejauh ini, ini adalah metode paling andal yang saya gunakan. Saya tidak menciptakan ini, dan tidak dapat mengingat di mana saya awalnya menemukannya. Tapi itu berfungsi ketika teknik lain gagal:

// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
  if (undefined === data ){ return 'Undefined'; }
  if (data === null ){ return 'Null'; }
  return {}.toString.call(data).slice(8, -1);
};  
// End public utility /getVarType/

Contoh kebenaran

var str = new String();
console.warn( getVarType(str) ); // Reports "String"    
console.warn( typeof str );      // Reports "object"

var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num );      // Reports "object"

var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list );        // Reports "object"

Hanya FYI, jika Anda menggunakan jQuery yang Anda miliki

$.isNumeric() 

untuk menangani ini. Lebih detail tentang http://api.jquery.com/jQuery.isNumeric/

typeof bekerja sangat baik bagi saya dalam banyak kasus. Anda dapat mencoba menggunakan pernyataan if

if(typeof x === 'string' || typeof x === 'number') {
    console.log("Your statement");
}

di mana x adalah nama variabel apa pun pilihan Anda

cara terbaik yang saya temukan yang juga memikirkan angka positif dan negatif adalah dari: O'Reilly Javascript dan DHTML Cookbook :

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
    oneChar = str.charAt(i).charCodeAt(0);
    // OK for minus sign as first character
    if (oneChar =  = 45) {
        if (i =  = 0) {
            continue;
        } else {
            alert("Only the first character may be a minus sign.");
            return false;
        }
    }
    // OK for one decimal point
    if (oneChar =  = 46) {
        if (!oneDecimal) {
            oneDecimal = true;
            continue;
        } else {
            alert("Only one decimal is allowed in a number.");
            return false;
        }
    }
    // characters outside of 0 through 9 not OK
    if (oneChar < 48 || oneChar > 57) {
        alert("Enter only numbers into the field.");
        return false;
    }
}
return true;

}

Errr? Cukup gunakan ekspresi reguler! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*/\.[0-9]+$/)
}

karena string seperti '1234' dengan typeof akan menampilkan 'string', dan kebalikannya tidak akan pernah terjadi (typeof 123 akan selalu berupa angka), yang terbaik adalah menggunakan regex sederhana /^\-?\d+$/.test(var). Atau yang lebih maju untuk mencocokkan float, bilangan bulat dan angka negatif, /^[\-\+]?[\d]+\.?(\d+)?$/ Sisi penting .testadalah bahwa ia TIDAK akan melempar pengecualian jika var bukan string, nilainya bisa apa saja.

var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;

regex.test(val)       // false 
val = '1234';
regex.test(val)       // true
val = '-213';
regex.test(val)       // true
val = '-213.2312';
regex.test(val)       // true
val = '+213.2312';
regex.test(val)       // true
val = 123;
regex.test(val)       // true
val = new Number(123);
regex.test(val)       // true
val = new String('123');
regex.test(val)       // true
val = '1234e';
regex.test(val)       // false 
val = {};
regex.test(val)       // false 
val = false;
regex.test(val)       // false 
regex.test(undefined) // false 
regex.test(null)      // false 
regex.test(window)    // false 
regex.test(document)  // false 

Jika Anda mencari tipe nyata, maka typeof saja yang akan dilakukan.

@ Jawaban BitOfUniverse baik, dan saya menemukan cara baru:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('')  // false
isNum(2)   // true
isNum('2k') // false
isNum('2')  //true

Saya tahu 0tidak bisa dividen, tapi di sini fungsinya bekerja dengan sempurna.

Ketik memeriksa

Anda dapat memeriksa jenis variabel dengan menggunakan typeofoperator:

typeof variable

Pengecekan nilai

Kode di bawah ini mengembalikan true untuk angka dan false untuk hal lain:

!isNaN(+variable);

Operasi XOR dapat digunakan untuk mendeteksi angka atau string. angka ^ 0 akan selalu memberikan angka sebagai output dan string ^ 0 akan memberikan 0 sebagai output.

Example: 
   1)  2 ^ 0 = 2
   2)  '2' ^ 0  = 2
   3)  'Str' ^ 0 = 0

Sederhana dan menyeluruh:

function isNumber(x) {
  return parseFloat(x) == x
};

Kasus uji:

console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));

console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));

Cukup gunakan

myVar.constructor == String

atau

myVar.constructor == Number

jika Anda ingin menangani string yang didefinisikan sebagai objek atau literal dan menyimpan Anda tidak ingin menggunakan fungsi pembantu.

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

Sangat terlambat ke pesta; Namun, berikut ini selalu bekerja dengan baik untuk saya ketika saya ingin memeriksa apakah beberapa input adalah string atau angka dalam satu kesempatan.

return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);

Membuat jsperf pada pemeriksaan jika variabel adalah angka. Cukup menarik! typeof sebenarnya memiliki penggunaan kinerja. Menggunakan typeofuntuk apa pun selain angka, biasanya bergerak 1/3 kecepatan sebagai avariable.constructor karena mayoritas tipe data dalam javascript adalah Objects; angka tidak!

http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-nnumber

typeof variable === 'number'| tercepat | jika Anda ingin nomor, seperti 5, dan bukan '5'
typeof parseFloat(variable) === 'number' | tercepat | jika Anda ingin nomor, seperti 5, dan '5'

isNaN()lebih lambat, tapi tidak terlalu lambat. Saya memiliki harapan tinggi untuk parseIntdan parseFloat, namun mereka sangat lambat.

Untuk mendeteksi angka, bagian berikut dari JavaScript: Bagian Baik oleh Douglas Crockford relevan:

Fungsi isFinite adalah cara terbaik untuk menentukan apakah suatu nilai dapat digunakan sebagai angka karena ia menolak NaN dan Infinity. Sayangnya, isFinite akan mencoba untuk mengubah operan menjadi angka, jadi itu bukan tes yang baik jika nilai sebenarnya bukan angka. Anda mungkin ingin mendefinisikan fungsi isNumber Anda sendiri:

var isNumber = function isNumber(value) { return typeof value === 'number' &&
            isFinite(value);
};