tipo de
Si usa typeof para determinar el tipo de datos, los resultados son los siguientes:
console.log(
typeof 123, //"number"
typeof 'dsfsf', //"string"
typeof false, //"boolean"
typeof [1,2,3], //"object"
typeof {
a:1,b:2,c:3}, //"object"
typeof function(){
console.log('aaa');}, //"function"
typeof undefined, //"undefined"
typeof null, //"object"
typeof new Date(), //"object"
typeof /^[a-zA-Z]{
5,20}$/, //"object"
typeof new Error() //"object"
);
Los resultados anteriores son el resultado de la ejecución en el navegador Chrome, puede encontrar las siguientes reglas
Array, Object, null, Date, RegExp, Error se juzgan como objetos por typeof, por lo que si desea juzgar estos tipos, no puede usar typeof.
Number, String, Boolean, Function, undefined, si desea juzgar estos tipos, puede usar typeof.
en vez de
Además de usar typeof para juzgar, también puede usar instanceof. El operador instanceof necesita especificar un constructor, o especificar un tipo específico, que se usa para determinar si el prototipo de este constructor está en la cadena de prototipos de un objeto dado.
Los resultados son los siguientes:
console.log(
123 instanceof Number, //false
'dsfsf' instanceof String, //false
false instanceof Boolean, //false
[1,2,3] instanceof Array, //true
{
a:1,b:2,c:3} instanceof Object, //true
function(){
console.log('aaa');} instanceof Function, //true
undefined instanceof Object, //false
null instanceof Object, //false
new Date() instanceof Date, //true
/^[a-zA-Z]{
5,20}$/ instanceof RegExp, //true
new Error() instanceof Error //true
)
Se pueden encontrar las siguientes reglas:
Number, String, Boolean no detectó sus tipos, pero se pueden detectar si usa la siguiente notación:
var num = new Number(123);
var str = new String('dsfsf');
var boolean = new Boolean(false);
También tenga en cuenta que tanto el valor nulo como el indefinido devuelven falso, esto se debe a que su tipo es él mismo, no el objeto que los creó, por lo que se devuelve falso.
constructor
El constructor es una propiedad del objeto prototipo que apunta al constructor. Según el orden en que se busquen los atributos de los objetos de instancia, si no hay atributos o métodos de instancia en los objetos de instancia, se buscarán en la cadena de prototipos, por lo que los objetos de instancia también pueden utilizar el atributo constructor.
Si genera un constructor de una instancia de un tipo, se ve así:
console.log(new Number(123).constructor)
//ƒ Number() { [native code] }
Puede ver que apunta al constructor de Número. Por lo tanto, puede usar num.constructor == Número para determinar si una variable es de tipo Número.
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();
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
A excepción de undefined y null, otros tipos se pueden juzgar por el atributo constructor.
Utilice toString () para detectar el tipo de objeto
Puede obtener el tipo de cada objeto a través de toString (). Para que cada objeto sea detectado por Object.prototype.toString (), debe llamarse en la forma de Function.prototype.call () o Function.prototype.apply (), pasando el objeto a comprobar como el primer parámetro, llamado thisArg.
var toString = Object.prototype.toString;
toString.call(123); //"[object Number]"
toString.call('abcdef'); //"[object String]"
toString.call(true); //"[object Boolean]"
toString.call([1, 2, 3, 4]); //"[object Array]"
toString.call({
name:'wenzi', age:25}); //"[object Object]"
toString.call(function(){
console.log('this is function'); }); //"[object Function]"
toString.call(undefined); //"[object Undefined]"
toString.call(null); //"[object Null]"
toString.call(new Date()); //"[object Date]"
toString.call(/^[a-zA-Z]{5,20}$/); //"[object RegExp]"
toString.call(new Error()); //"[object Error]"
Se puede ver que usar Object.prototype.toString.call () para determinar el tipo de variable es el método más preciso.
Encapsular una función para obtener el tipo exacto de variable
function gettype(obj) {
var type = typeof obj;
if (type !== 'object') {
return type;
}
//如果不是object类型的数据，直接用typeof就能判断出来
//如果是object类型数据，准确判断类型必须使用Object.prototype.toString.call(obj)的方式才能判断
return Object.prototype.toString.call(obj).replace(/^\[object (\S+)\]$/, '$1');
}
Es muy conveniente juzgar el tipo de datos de una variable de esta manera.