Bagaimana untuk menentukan jenis pembolehubah dalam kemahiran javascript_javascript

Dalam JavaScript, terdapat 5 jenis data asas dan 1 jenis data kompleks Jenis data asas ialah: Undefined, Null, Boolean, Number dan String jenis data kompleks ialah Object, dan Object juga dibahagikan kepada banyak jenis tertentu . Jenis, seperti: Tatasusunan, Fungsi, Tarikh, dsb. Hari ini kita akan membincangkan cara menentukan jenis pembolehubah.

Sebelum menerangkan pelbagai kaedah, kami terlebih dahulu mentakrifkan beberapa pembolehubah ujian untuk melihat cara kaedah seterusnya boleh menghuraikan jenis pembolehubah berikut hampir termasuk jenis yang biasa kami gunakan dalam pengekodan sebenar.

var num = 123;
var str = 'abcdef';
var bool = true;
var arr = [1, 2, 3, 4];
var json = {name:'wenzi', age:25};
var func = function(){ console.log('this is function'); }
var und = undefined;
var nul = null;
var date = new Date();
var reg = /^[a-zA-Z]{5,20}$/;
var error= new Error();

1. Gunakan jenis pengesanan

Apa yang selalu kami gunakan ialah menggunakan typeof untuk mengesan jenis pembolehubah. Kali ini, kami juga menggunakan typeof untuk mengesan jenis pembolehubah:

console.log(
	typeof num, 
	typeof str, 
	typeof bool, 
	typeof arr, 
	typeof json, 
	typeof func, 
	typeof und, 
	typeof nul, 
	typeof date, 
	typeof reg, 
	typeof error
);
// number string boolean object	object function undefined object object object object

Berdasarkan hasil keluaran, arr, json, nul, date, reg, error semuanya dikesan sebagai jenis objek dan pembolehubah lain boleh dikesan dengan betul. Apabila anda perlu menentukan sama ada pembolehubah adalah daripada jenis nombor, rentetan, boolean, fungsi, tidak ditentukan atau json, anda boleh menggunakan typeof untuk menentukan. Jenis pembolehubah lain tidak boleh ditentukan, termasuk null.
Juga, typeof tidak dapat membezakan antara jenis tatasusunan dan json. Kerana apabila menggunakan pembolehubah jenis, kedua-dua tatasusunan dan json jenis objek output.

2. Gunakan pengesanan contoh

Dalam JavaScript, operator jenis sering digunakan untuk menentukan jenis pembolehubah Apabila menggunakan operator jenis, masalah timbul apabila menggunakan jenis rujukan untuk menyimpan nilai Tidak kira jenis objek yang dirujuk, ia mengembalikan "objek " ". ECMAScript memperkenalkan satu lagi contoh operator Java untuk menyelesaikan masalah ini. Operator instanceof adalah serupa dengan operator typeof dan digunakan untuk mengenal pasti jenis objek yang sedang diproses. Tidak seperti kaedah typeof, kaedah instanceof memerlukan pembangun untuk mengesahkan secara eksplisit bahawa objek adalah jenis tertentu. Contohnya:

function Person(){

}
var Tom = new Person();
console.log(Tom instanceof Person); // true

Mari lihat contoh berikut sekali lagi:

function Person(){

}
function Student(){

}
Student.prototype = new Person();
var John = new Student();
console.log(John instanceof Student); // true
console.log(John instancdof Person); // true

instanceof juga boleh mengesan perhubungan warisan berbilang peringkat.
Okey, mari gunakan instanceof untuk mengesan pembolehubah di atas:

console.log(
	num instanceof Number,
	str instanceof String,
	bool instanceof Boolean,
	arr instanceof Array,
	json instanceof Object,
	func instanceof Function,
	und instanceof Object,
	nul instanceof Object,
	date instanceof Date,
	reg instanceof RegExp,
	error instanceof Error
)
// num : false 
// str : false 
// bool : false 
// arr : true 
// json : true 
// func : true 
// und : false 
// nul : false 
// date : true 
// reg : true 
// error : true

Daripada hasil yang dijalankan di atas, kita dapat melihat bahawa jenis num, str dan bool belum dikesan, tetapi apabila kita mencipta num menggunakan kaedah berikut, jenis itu boleh dikesan:

var num = new Number(123);
var str = new String('abcdef');
var boolean = new Boolean(true);

Pada masa yang sama, kita juga perlu melihat bahawa und dan nul dikesan jenis Objek, jadi ia menghasilkan benar, kerana tiada jenis global Undefined dan Null dalam js Kedua-dua und dan nul tergolong dalam jenis Objek, jadi mereka adalah output benar.

3. Gunakan pembina untuk mengesan

Apabila menggunakan instanceof untuk mengesan jenis pembolehubah, kami tidak dapat mengesan jenis nombor, 'rentetan' dan bool. Oleh itu, kita perlu mencari jalan lain untuk menyelesaikan masalah ini.
pembina pada asalnya adalah harta pada objek prototaip, menunjuk kepada pembina. Walau bagaimanapun, mengikut susunan objek contoh mencari atribut, jika tiada atribut contoh atau kaedah pada objek contoh, ia akan dicari pada rantaian prototaip Oleh itu, objek contoh juga boleh menggunakan atribut pembina.
Mari kita keluarkan kandungan num.constructor, iaitu, rupa bentuk pembolehubah jenis angka:

fungsi Nombor() { [kod asli] }

Kita dapat melihat bahawa ia menunjuk kepada pembina Nombor Oleh itu, kita boleh menggunakan num.constructor==Number untuk menentukan sama ada num adalah jenis Number

function Person(){

}
var Tom = new Person();

// undefined和null没有constructor属性
console.log(
	Tom.constructor==Person,
	num.constructor==Number,
	str.constructor==String,
	bool.constructor==Boolean,
	arr.constructor==Array,
	json.constructor==Object,
	func.constructor==Function,
	date.constructor==Date,
	reg.constructor==RegExp,
	error.constructor==Error
);
// 所有结果均为true

Walau bagaimanapun, menggunakan pembina adalah tidak selamat, kerana atribut pembina boleh diubah suai, yang akan menyebabkan keputusan yang dikesan menjadi salah, contohnya:

function Person(){

}
function Student(){

}
Student.prototype = new Person();
var John = new Student();
console.log(John.constructor==Student); // false
console.log(John.constructor==Person); // true

Pada masa yang sama, apabila menggunakan instanceof dan constructor, tatasusunan yang dinilai mesti diisytiharkan pada halaman semasa! Sebagai contoh, halaman (halaman induk) mempunyai bingkai, dan halaman (halaman anak) dirujuk dalam bingkai Tatasusunan diisytiharkan dalam halaman anak dan diberikan kepada pembolehubah halaman induk dinilai, Array == object.constructor; 1. Array ialah data rujukan Semasa proses pemindahan, ia hanyalah pemindahan alamat rujukan.
2. Alamat yang dirujuk oleh objek asli Array setiap halaman adalah berbeza Pembina tatasusunan yang sepadan yang diisytiharkan pada sub-halaman ialah objek Array bagi halaman induk membuat pertimbangan, dan Array yang digunakan ialah tidak sama dengan Array subhalaman; jika tidak, ia akan menjadi sukar untuk mengesan masalah!

4. Gunakan Object.prototype.toString.call
Mari kita tidak peduli tentang perkara ini, mari kita lihat dahulu cara ia mengesan jenis pembolehubah:

console.log(
	$.type(num),
	$.type(str),
	$.type(bool),
	$.type(arr),
	$.type(json),
	$.type(func),
	$.type(und),
	$.type(nul),
	$.type(date),
	$.type(reg),
	$.type(error)
);
// number string boolean array object function undefined null date regexp error

// 实例对象是能直接使用原型链上的方法的
var class2type = {};
var toString = class2type.toString;

// 省略部分代码...

type: function( obj ) {
	if ( obj == null ) {
		return obj + "";
	}
	// Support: Android<4.0, iOS<6 (functionish RegExp)
	return (typeof obj === "object" || typeof obj === "function") &#63;
		(class2type[ toString.call(obj) ] || "object") :
		typeof obj;
},

// 省略部分代码... 

// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
});

// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
});

//循环之后，`class2type`的值是： 
class2type = {
	'[object Boolean]' : 'boolean', 
	'[object Number]' : 'number',
	'[object String]' : 'string',
	'[object Function]': 'function',
	'[object Array]'  : 'array',
	'[object Date]'  : 'date',
	'[object RegExp]' : 'regExp',
	'[object Object]' : 'object',
	'[object Error]'  : 'error'
}

// type的实现
type: function( obj ) {
	// 若传入的是null或undefined，则直接返回这个对象的字符串
	// 即若传入的对象obj是undefined，则返回"undefined"
	if ( obj == null ) {
		return obj + "";
	}
	// Support: Android<4.0, iOS<6 (functionish RegExp)
	// 低版本regExp返回function类型；高版本已修正，返回object类型
	// 若使用typeof检测出的obj类型是object或function，则返回class2type的值，否则返回typeof检测的类型
	return (typeof obj === "object" || typeof obj === "function") &#63;
		(class2type[ toString.call(obj) ] || "object") :
		typeof obj;
}