Bagaimana saya dapat mengetahui apakah suatu variabel string atau sesuatu yang lain dalam JavaScript?
Anda dapat menggunakan jenis
operator:
var booleanValue = true;
var numericalValue = 354;
var stringValue = "This is a String";
var stringObject = new String( "This is a String Object" );
alert(typeof booleanValue) // displays "boolean"
alert(typeof numericalValue) // displays "number"
alert(typeof stringValue) // displays "string"
alert(typeof stringObject) // displays "object"
Contoh dari halaman web ini. (Contoh adalah sedikit dimodifikasi meskipun).
Ini won't bekerja seperti yang diharapkan dalam kasus string dibuat dengan new String()
, tapi ini jarang digunakan dan direkomendasikan terhadap[1][2]. Melihat jawaban yang lain untuk bagaimana untuk menangani ini, jika anda inginkan.
Sejak 580+ orang-orang yang telah memilih jawaban yang salah, dan 800+ telah memilih untuk bekerja tetapi senapan-gaya jawabannya, saya pikir itu mungkin layak mengulangi jawaban saya dalam bentuk yang lebih sederhana bahwa setiap orang dapat mengerti.
function isString(x) {
return Object.prototype.toString.call(x) === "[object String]"
}
Atau, inline (saya memiliki UltiSnip setup untuk ini):
Object.prototype.toString.call(myVar) === "[object String]"
FYI, Pablo Santa Cruz's jawaban yang salah, karena typeof new String("string")
adalah objek
DRAX's jawaban yang lebih akurat dan fungsional, dan harus menjadi jawaban yang benar (karena Pablo Santa Cruz adalah yang paling jelas salah, dan aku tidak't berpendapat terhadap suara rakyat.)
Namun, jawaban ini juga pasti benar, dan yang benar-benar jawaban terbaik (kecuali, mungkin, untuk saran menggunakan lodash/underscore). disclaimer: saya berkontribusi lodash 4 codebase.
Asli saya menjawab (yang jelas terbang tepat di atas banyak kepala) berikut:
Saya transkode ini dari underscore.js:
['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'].forEach(
function(name) {
window['is' + name] = function(obj) {
return toString.call(obj) == '[object ' + name + ']';
};
});
Yang akan menentukan isString, isNumber, dll.
Di Node.js ini dapat diimplementasikan sebagai modul:
module.exports = [
'Arguments',
'Function',
'String',
'Number',
'Date',
'RegExp'
].reduce( (obj, name) => {
obj[ 'is' + name ] = x => toString.call(x) == '[object ' + name + ']';
return obj;
}, {});
Saya sarankan untuk menggunakan built-in fungsi dari jQuery atau lodash/Underscore. Mereka're mudah untuk digunakan dan lebih mudah untuk dibaca.
Kedua fungsi tersebut akan menangani kasus DRAX disebutkan... itu, mereka kedua periksa apakah (A) variabel adalah sebuah string literal atau (B) it's sebuah instance dari objek String. Dalam kedua kasus, fungsi-fungsi ini dengan benar mengidentifikasi nilai sebagai sebuah string.
lodash / Underscore.js
if(_.isString(myVar))
//it's a string
else
//it's something else
jQuery
if($.type(myVar) === "string")
//it's a string
else
//it's something else
Lihat lodash Dokumentasi _.isString() untuk lebih jelasnya.
Lihat jQuery Dokumentasi untuk $.jenis() untuk informasi lebih lanjut.
Cara terbaik:
var s = 'String';
var a = [1,2,3];
var o = {key: 'val'};
(s.constructor === String) && console.log('its a string');
(a.constructor === Array) && console.log('its an array');
(o.constructor === Object) && console.log('its an object');
(o.constructor === Number || s.constructor === Boolean) && console.log('this won\'t run');
Masing-masing telah dibangun oleh kelas yang sesuai fungsi, seperti "new Object()" dll.
Juga, Duck-Typing: "Jika terlihat seperti bebek, berjalan seperti bebek, dan bau seperti bebek - itu harus menjadi sebuah Array" Artinya, memeriksa sifat-sifatnya.
Semoga ini bisa membantu.
Ingat, anda selalu dapat menggunakan kombinasi dari pendekatan-pendekatan yang terlalu. Berikut ini's contoh penggunaan inline peta tindakan jenis:
var type = { 'number': Math.sqrt.bind(Math), ... }[ typeof datum ];
Berikut ini's lebih 'dunia nyata' contoh menggunakan inline-maps:
function is(datum) {
var isnt = !{ null: true, undefined: true, '': true, false: false, 0: false }[ datum ];
return !isnt;
}
console.log( is(0), is(false), is(undefined), ... ); // >> true true false
Fungsi ini akan menggunakan [ custom ] "type-casting" -- lebih tepatnya, "type-/-nilai-pemetaan" - untuk mengetahui apakah variabel sebenarnya "ada". Sekarang anda dapat membagi yang jahat rambut antara null
& 0
!
Berkali-kali anda don't peduli tentang jenis. Cara lain untuk menghindari mengetik adalah menggabungkan Bebek-Jenis set:
this.id = "998"; // use a number or a string-equivalent
function get(id) {
if (!id || !id.toString) return;
if (id.toString() === this.id.toString()) http( id || +this.id );
// if (+id === +this.id) ...;
}
Kedua Nomor.prototipe
dan String.prototipe
memiliki .toString() method
. Anda hanya memastikan bahwa string-setara dengan jumlah yang sama, dan kemudian anda memastikan bahwa anda lulus ke http
fungsi sebagai Nomor
. Dengan kata lain, kita tidak't bahkan perawatan apa jenis itu.
Harapan yang memberikan anda lebih banyak untuk bekerja dengan :)
Saya dapat't jujur melihat mengapa seseorang tidak akan hanya menggunakan jenis
dalam hal ini:
if (typeof str === 'string') {
return 42;
}
Ya itu akan gagal terhadap objek-dibungkus string (misalnya new String('foo')
) tapi ini secara luas dianggap sebagai praktek yang buruk dan paling modern alat-alat pengembangan yang mungkin untuk mencegah mereka gunakan. (Jika anda melihat satu, hanya memperbaikinya!)
Objek.prototipe.toString
trik ini adalah sesuatu yang semua front-end developer telah ditemukan bersalah melakukan satu hari dalam karir mereka tapi don't biarkan hal itu menipu anda dengan polandia pintar: itu akan istirahat sebagai segera sebagai sesuatu monyet-patch Objek prototipe:
const isString = thing => Object.prototype.toString.call(thing) === '[object String]';
console.log(isString('foo'));
Object.prototype.toString = () => 42;
console.log(isString('foo'));
Ini adalah contoh yang bagus tentang mengapa hal kinerja:
Lakukan sesuatu yang sederhana seperti tes untuk string dapat menjadi mahal jika tidak dilakukan dengan benar.
Misalnya, jika saya ingin menulis fungsi untuk menguji apakah sesuatu adalah string, aku bisa melakukannya di salah satu dari dua cara:
const isString = str => (Objek.prototipe.toString.panggilan(str) === '[objek String]');
const isString = str => ((typeof str === 'string') || (str instanceof String));
Kedua hal ini cukup lurus ke depan, sehingga apa yang mungkin bisa mempengaruhi kinerja? Secara umum, fungsi panggilan bisa mahal, terutama jika anda don't tahu apa yang's terjadi di dalam. Pada contoh pertama, ada fungsi panggilan untuk Objek's toString metode. Pada contoh kedua, tidak ada panggilan fungsi, sebagai typeof dan instanceof adalah operator. Operator secara signifikan lebih cepat daripada fungsi panggilan.
Ketika kinerja diuji, contoh 1 adalah 79% lebih lambat dari contoh 2!
Melihat tes: https://jsperf.com/isstringtype
Diambil dari lodash:
function isString(val) {
return typeof val === 'string' || ((!!val && typeof val === 'object') && Object.prototype.toString.call(val) === '[object String]');
}
console.log(isString('hello world!')); // true
console.log(isString(new String('hello world'))); // true
Saya berpikir bahwa @customcommander larutan harus cukup dalam 90% kasus anda:
typeof str === 'string'
Harus melayani anda dengan benar (hanya karena biasanya ada's tidak ada alasan untuk memiliki new String('sesuatu')
dalam kode anda).
Jika anda're tertarik pada penanganan String
objek (misalnya anda mengharapkan beberapa var dari pihak ke-3) kemudian menggunakan lodash sebagai @ClearCloud8 menyarankan sepertinya yang jelas, sederhana dan elegan solusi.
Namun saya akan menyarankan untuk berhati-hati dengan perpustakaan seperti lodash karena ukuran mereka. Bukannya melakukan
import _ from 'lodash'
...
_.isString(myVar)
Yang membawa seluruh besar lodash objek, I'd menyarankan sesuatu seperti:
import { isString as _isString } from 'lodash'
...
_isString(myVar)
Dan dengan sederhana bundling anda harus baik-baik saja (saya lihat di sini untuk kode klien).
Metode berikut akan memeriksa apakah setiap variabel string (termasuk variabel-variabel yang tidak ada).
const is_string = value => {
try {
return typeof value() === 'string';
} catch (error) {
return false;
}
};
let example = 'Hello, world!';
console.log(is_string(() => example)); // true
console.log(is_string(() => variable_doesnt_exist)); // false
Saya juga menemukan bahwa ini bekerja dengan baik juga, dan banyak yang lebih pendek dari contoh-contoh lainnya.
if (myVar === myVar + '') {
//its string
} else {
//its something else
}
Dengan menggabungkan kosong kutipan ternyata nilai ke string. Jika myVar
sudah sebuah string maka jika pernyataan ini sukses.
Saya menemukan teknik sederhana ini berguna untuk jenis pemeriksaan String -
String(x) === x // true, if x is a string
// false in every other case
const test = x =>
console.assert
( String(x) === x
, `not a string: ${x}`
)
test("some string")
test(123) // assertion failed
test(0) // assertion failed
test(/some regex/) // assertion failed
test([ 5, 6 ]) // assertion failed
test({ a: 1 }) // assertion failed
test(x => x + 1) // assertion failed
Teknik yang sama bekerja untuk Jumlah terlalu -
Number(x) === x // true, if x is a number
// false in every other case
const test = x =>
console.assert
( Number(x) === x
, `not a number: ${x}`
)
test("some string") // assertion failed
test(123)
test(0)
test(/some regex/) // assertion failed
test([ 5, 6 ]) // assertion failed
test({ a: 1 }) // assertion failed
test(x => x + 1) // assertion failed
Dan untuk RegExp -
RegExp(x) === x // true, if x is a regexp
// false in every other case
const test = x =>
console.assert
( RegExp(x) === x
, `not a regexp: ${x}`
)
test("some string") // assertion failed
test(123) // assertion failed
test(0) // assertion failed
test(/some regex/)
test([ 5, 6 ]) // assertion failed
test({ a: 1 }) // assertion failed
test(x => x + 1) // assertion failed
Yang sama untuk Obyek -
Object(x) === x // true, if x is an object
// false in every other case
NB, regexps, array, dan fungsi benda-benda yang dianggap terlalu.
const test = x =>
console.assert
( Object(x) === x
, `not an object: ${x}`
)
test("some string") // assertion failed
test(123) // assertion failed
test(0) // assertion failed
test(/some regex/)
test([ 5, 6 ])
test({ a: 1 })
test(x => x + 1)
Tapi, memeriksa Hotel sedikit berbeda -
Array.isArray(x) === x // true, if x is an array
// false in every other case
const test = x =>
console.assert
( Array.isArray(x)
, `not an array: ${x}`
)
test("some string") // assertion failed
test(123) // assertion failed
test(0) // assertion failed
test(/some regex/) // assertion failed
test([ 5, 6 ])
test({ a: 1 }) // assertion failed
test(x => x + 1) // assertion failed
Teknik ini tidak tidak bekerja Fungsi namun -
Function(x) === x // always false
Ini adalah cukup baik bagi saya.
PERINGATAN: Ini bukan solusi yang sempurna. Lihat bagian bawah dari posting saya.
Object.prototype.isString = function() { return false; };
String.prototype.isString = function() { return true; };
var isString = function(a) {
return (a !== null) && (a !== undefined) && a.isString();
};
Dan anda dapat menggunakan ini seperti di bawah ini.
//return false
isString(null);
isString(void 0);
isString(-123);
isString(0);
isString(true);
isString(false);
isString([]);
isString({});
isString(function() {});
isString(0/0);
//return true
isString("");
isString(new String("ABC"));
PERINGATAN: Ini bekerja secara tidak benar dalam hal:
//this is not a string
var obj = {
//but returns true lol
isString: function(){ return true; }
}
isString(obj) //should be false, but true
Hanya untuk memperluas @DRAX's jawaban, I'd lakukan ini:
function isWhitespaceEmptyString(str)
{
//RETURN:
// = 'true' if 'str' is empty string, null, undefined, or consists of white-spaces only
return str ? !(/\S/.test(str)) : (str === "" || str === null || str === undefined);
}
Ini akan memperhitungkan juga untuk null dan
undefinedjenis, dan itu akan mengambil perawatan non-string jenis, seperti
0`.
Sebuah Typechecker helper:
fungsi isFromType(variabel, tipe){ if (typeof jenis == 'string') res = (typeof variabel == jenis.toLowerCase()) lain res = (variable.konstruktor == tipe) kembali res }
penggunaan:
isFromType('cs', 'string') //benar isFromType('cs', String) //benar isFromType(['cs'], Array) //benar isFromType(['cs'], 'objek') //salah
Juga jika anda ingin menjadi rekursif(seperti Array yang merupakan Objek), anda dapat menggunakan instanceof
.
(['cs'] instanceof Objek //true
)