js中判断对象具体类型 - 推酷
js中判断对象具体类型
大家可能知道js中判断对象类型可以用typeof来判断。看下面的情况
alert(typeof 1);//number
alert(typeof &2&);//string
alert(typeof [1,2,3]);//object
alert(typeof {&name&:&zhuhui&})//object
从上面中我们可以看出数组和普通对象用typeof判断出来都是object,但是现在我们有这个需求，我们要明确判断出这个对象是具体的哪个对象（比如数组对象，日期对象，正则表达式对象，其他自定义对象，DOM对象等等）那怎么办呢。其实js中有个方法可以准备的判断出
Object.prototype.toString.call
var type=function(v){
return Object.prototype.toString.call(v);
alert(type(null));//[object Null]
alert(type(undefined));//[object Undefined]
alert(type(1));//[object Number]
alert(type(true));//[object Boolean]
alert(type(&2&));//[object String]
alert(type([1,2,3]));//[object Array]
alert(type({&name&:&zhuhui&}));//[object Object]
alert(type(type));//[object Function]
alert(type(new Date()));//[object Date]
alert(type(/^\d+$/));//[object Regexp]
关于这个方法更深入的说明请参考
下面是以前做项目封装判断常见数据类型的js
* type.js 数据类型检测函数
* @author 朱辉
* @version 0.1
(function(window, undefined){
xjo = window.xjo ||
plugin: {}
xjo.type = {};
//检测v的类型 辅助函数
var type = function(v){
return Object.prototype.toString.call(v);
* 是否为数组对象类型
如果是就返回true 如果不是就返回false
* @namespace xjo.type
* @method isArray
* @param {Any} v 被检测的变量
* @return {Boolean} 结果
xjo.type.isArray = function(v){
return type(v) === '[object Array]';
* 是否为参数管理器Arguments 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isArguments = function(v){
return v.callee !=
* 是否为迭代序列 包含Array与Arguments 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isIterable = function(v){
return xjo.type.isArray(v) || xjo.type.isArguments(v);
* 是否为空对象 null和undefined和数组的长度为0或空字符串(&&) 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @param {Boolean} allowBlank [可选] 默认false 空字符串认为是空对象 反之 空字符串不认为是空对象
* @return {Boolean}
xjo.type.isEmpty = function(v, allowBlank){
return v === null || v === undefined ||
(xjo.type.isArray(v) && !v.length) ||
(!allowBlank ? v === '' : false);
* 是否为字符串类型 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isString = function(v){
return typeof v === 'string';
* 是否为数字类型(为Number且不为正负无穷大数字) 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isNumber = function(v){
return typeof v === 'number' && isFinite(v);
* 是否为布尔值类型
如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isBoolean = function(v){
return typeof v === 'boolean';
* 是否为函数类型 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isFuntion = function(v){
return type(v) === '[object Function]';
* 是否为对象类型
* @param {Any} v 被检测的变量
* @return {boolean}
xjo.type.isObject = function(v){
return !!v && type(v) === '[object Object]';
* 是否为日期类型
如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {boolean}
xjo.type.isDate = function(v){
return type(v) === '[object Date]';
* 是否为正则表达式类型
如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isRegexp = function(v){
return type(v) == '[object RegExp]';
* 是否为原始数据类型 如果是就返回true 如果不是就返回false
* @param {Any} v 被检测的变量
* @return {Boolean}
xjo.type.isPrimitive = function(v){
return xjo.type.isString(v) || xjo.type.isNumber(v) ||
xjo.type.isBoolean(v);
* 返回数据类型的字符串形式&br&
数字类型:&number& &br&
布尔类型:&boolean& &br&
字符串类型:&string& &br&
数组类型:&array&&br&
日期类型:&date&&br&
正则表达式类型:&regexp& &br&
函数类型:&function&&br&
对象类型:&object&&br&
参数管理器类型:&arguments&&br&
其他类型:&unknow&
* @param {Any} v 被检测的变量
* @return {String}
xjo.type.type = function(v){
var result = &unknow&;
if (xjo.type.isNumber(v)) {
result = &number&;
if (xjo.type.isBoolean(v)) {
result = &boolean&;
if (xjo.type.isString(v)) {
result = &string&;
if (xjo.type.isArray(v)) {
result = &array&;
if (xjo.type.isDate(v)) {
result = &date&;
if (xjo.type.isRegexp(v)) {
result = &regexp&;
if (xjo.type.isFuntion(v)) {
result = &function&;
if (xjo.type.isObject(v)) {
result = &object&;
if (xjo.type.isArguments(v)) {
result = &argumetns&;
xjo.plugin[&jo/type&] =
})(window);
已发表评论数()
请填写推刊名
描述不能大于100个字符!
权限设置： 公开
仅自己可见
正文不准确
标题不准确
排版有问题
主题不准确
没有分页内容
图片无法显示
视频无法显示
与原文不一致> js中定义对象的几种形式
js中定义对象的几种形式
jxfz889 & &
发布时间： & &
浏览：44 & &
回复：0 & &
悬赏：0.0希赛币
js中定义对象的几种方式
　　1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)：
　　var obj = new Object();
　　obj.name="userObject";
　　obj.printName = function(name){
　　this.name =
　　alert(this.name);
　　obj.printName("newUserObject");
　　2.工厂方式创建对象(每次创建一个object后，其中对应的方法(本例中是get)也被创建一次，方法不能被所创建的所有对象(本例中是obj1和obj2)共享)：
　　function createObject(){
　　var obj = new Object();
　　obj.name="userObject";
　　obj.password = "12345";
　　obj.get = function(){
　　alert(this.name + ", " + this.password);
　　var obj1 = createObject();
　　var obj2 = createObject();
　　obj1.get();
　　obj2.get();
　　b.带参数的构造方法：
　　function createObject(username,password){
　　var obj = new Object();
　　obj.username =
　　obj.password =
　　obj.get = function(){
　　alert(this.username + ", " + this.password);
　　var obj1 = createObject("zhangsan","123456");
　　obj1.get();
　　c.让函数被多个创建的对象所共享，而不是每一个对象都创建一个相同的函数(缺点:对象定义本身和方法分离了)：
　　function get(){
　　alert(this.username + ", " + this.password);
　　function createObject(username,password){
　　var obj = new Object();
　　obj.username =
　　obj.password =
　　obj.get =
　　var obj1 = createObject("zhangsan","123456");
　　var obj2 = createObject("lisi","54321");
　　obj1.get();
　　obj2.get();
　　3.构造函数方式：
　　function Person(){
　　this.username = "zhangsan";
　　this.password = "123";
　　this.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　var person = new Person();
　　person.getInfo();
　　b.可以在构造函数是传递参数：
　　function Person(username,password){
　　this.username =
　　this.password =
　　this.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　var person = new Person("zhangsan","123");
　　person.getInfo();
　　4.使用原型(prototype)方式创建对象：
　　优点：创建的多个对象共享同一个方法(getInfo)
　　缺点：创建的多个对象在共享同一个方法的同时也共享了同样的属性(username,password)，实际开发中这样儿是
　　不行的，必须是多个对象都要有自己的属性。
　　采用该方式创建对象通常是用来扩展已有对象的某一个方法。
　　function Person(){}
　　Person.prototype.username = "zhangsan";
　　Person.prototype.password = "123";
　　Person.prototype.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　var person = new Person();
　　var person2 = new Person();
　　person.username = "lisi";
　　person.getInfo();
　　person2.getInfo();
　　b.如果使用原型方式创建对象，那么生成的所有对象将会共享原型中的属性，这样儿一个对象改变了该属性也会反应到其他的对象上：
　　function Person(){}
　　Person.prototype.username = new Array(0;
　　Person.prototype.password = "123";
　　Person.prototype.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　var person = new Person();
　　var person2 = new Person();
　　person.username.push("zhangsan");
　　person.username.push("lisi");
　　person.password = "456";
　　person.getInfo();
　　person2.getInfo();
　　c.使用原型和构造函数方式来创建对象：
　　function Person(){
　　this.username = new Array();
　　this.password = "123"
　　Person.prototype.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　var person = new Person();
　　var person2 = new Person();
　　person.username.push("zhangsan");
　　person.username.push("lisi");
　　person.getInfo();
　　person2.getInfo();
　　5.动态原型方式：在构造函数中通过标志量让所有对象共享一个方法，而每个对象拥有自己的属性。
　　function Persion(){
　　this.username = "zhangsan";
　　this.password = "123";
　　if(typeof Person.flag == "undefined"){
　　Person.prototype.getInfo = function(){
　　alert(this.username + ", " + this.password);
　　Person.flag =
　　var p = new Person();
　　var p2 = new Person();
　　p.getInfo();
　　p2.getInfo();
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&JS 对象属性相关(检查属性、枚举属性等)
栏目: Javascript教程 来源: 　
&1.删除属性
delete运算符可以删除对象的属性
delete person.age
//即person不再有属性age
delete person['age'] //或者这样
delete只是断开属性和宿主对象的联系，而不会去操作属性中的属性 看到delete a.p之后b.x仍然为1
var a = {p:{x:1}};
var b = a.p;
console.log(a.p.x); //1
delete a.p;
console.log(a.p.x); //TypeError a.p is undefined
console.log(a.p); //undefined
console.log(b.x); //1
delete只能删除自有属性，不能删除继承属性（要删除继承属性必须从定义这个属性的原型对象上删除它，当然，这会影响到所有继承来自这个原型的对象）
function inherit(p){
if(p == null){
// 不能从null中继承
throw TypeError();
if(Object.create){
//如果有这个方法就直接使用
return Object.create(p);
if(t !== &object& || t !== &function&){
//要继承的对象 类型要符合
throw TypeError();
function f(){ }; //定义一个空的构造函数
f.prototype = //原型指向要继承的对象p
return new f();
//创建f对象，此对象继承自p
var obj = {x:1};
var obj1 = inherit(obj);
obj1.y = 2;
console.log(&x = &+obj1.x+& y = &+obj1.y); //x = 1 y = 2
delete obj1.x;
delete obj1.y;
console.log(&x = &+obj1.x+& y = &+obj1.y); //x = 1 y = undefined
当然了，可配置的属性才能用到delete
delete Object. // 不能删除 不可配置
var x = 1;
delete this.x; //不能删除
this.y = 1;
//这样可以删除
function f(){ }
delete this.f; //不能删除
2.检测属性
in 运算符希望它的左操作数是一个字符串或者可以转换为字符串，希望它的右操作数是一个对象
var data = [5,6,7];
console.log(&0& in data); //有下标0
console.log(1 in data);
//1可以转换成&1&
console.log(&4& in data); //下标只有 1 2 3
var obj = {x:1};
console.log(&x& in obj); //true
console.log(&y& in obj); //false
console.log(&toString& in obj); //true 因为obj继承了这个方法
使用hasOwnProperty()或者propertyIsEnumerable() --- 后者是前者的增强
var obj = {x:1};
console.log(obj.hasOwnProperty(&x&)); //true
console.log(obj.hasOwnProperty(&y&)); //false
console.log(obj.hasOwnProperty(&toString&)); //false 因为obj继承了这个方法,但不是它自己的
只有检测到是自由属性并是可枚举的属性时，后者才返回true
var obj = {x:1};
console.log(obj.propertyIsEnumerable(&x&)); //true
console.log(obj.propertyIsEnumerable(&y&)); //false
console.log(obj.propertyIsEnumerable(&toString&)); //false 因为obj继承了这个方法,但不是它自己的
console.log(Object.prototype.propertyIsEnumerable(&toString&)); //false 因为最原始的的 toString就是不可枚举的
当然，也可以直接用 &!==&运算符判断
var obj = {x:1};
console.log(obj.x !== undefined);//true
console.log(obj.y !== undefined);//false
console.log(obj.toString !== undefined); //true
3.枚举属性
var obj = {x:1,y:2};
for(p in obj){
console.log(p);//x y
console.log(obj.p);// undefined undefined
console.log(obj[p]);//1 2
每个对象都有与之相关的原型（prototype）、类（class）、可扩展性(extensible)
要检测一个对象是否是另一个对象的原型（或处于原型链中），可以使用isPrototypeOf()方法
var p = {x:1}; //p原型对象继承自Object.prototype
var o = Object.create(p); //o对象继承自p
console.log(p.isPrototypeOf(o));//true
console.log(Object.prototype.isPrototypeOf(o));//true
console.log(Object.prototype.isPrototypeOf(p));//true
当然，isPrototypeOf()方法和instanceof运算符非常类似
instanceof运算符希望它的左操作数是一个对象，右操作数标识对象的类。如果左侧的对象是右侧类的实例，则表达式返回true,否则返回false
var p = {x:1};
console.log(p instanceof Object);//true
var d = new Date();
console.log(d instanceof Date);//true
console.log(d instanceof Object);//true
console.log(d instanceof Number);//false
对象的类属性是一个字符串，用以表示对象的类型信息
一般调用toString()方法后返回形如 [object class]的形式
{x:1,y:2};
console.log(obj.toString());//[object Object]
所以要想获取对象的类，就可以通过返回的字符串中找出 &class&字段
使用 slice（8，-1）
function classOf(obj){ // 找出类名
if(obj === null){
return &Null&;
if(obj === undefined){
return &Undefined&;
return Object.prototype.toString.call(obj).slice(8,-1);
console.log(classOf(1)); //Number
//注意，实际上是这些类型的变量调用toString()方法，而不是通过他们自身直接调用
//console.log(1.toString()); //会报错
var a = 1;
console.log(Number(1).toString()); //1
console.log(a.toString()); //1
console.log({x:1}.toString()); //[object Object]
console.log(classOf(1)); //Number
console.log(classOf(&&)); //String
console.log(classOf(&str&)); //String
console.log(classOf(null)); //Null
console.log(classOf(false)); //Boolean
console.log(classOf({})); //Object
console.log(classOf([])); //Array
console.log(classOf(new Date())); //Date
function f(){}
console.log(classOf(new f())); //Object
04-06 04-06 04-02 04-02 04-02 04-02 04-01 04-01对象可枚举和不可枚举属性 - 范学会 - 博客园
&在JavaScript中，对象的属性分为可枚举和不可枚举之分，它们是由属性的enumerable值决定的。可枚举性决定了这个属性能否被for…in查找遍历到。
一、怎么判断属性是否可枚举
& js中基本包装类型的原型属性是不可枚举的，如Object, Array, Number等，如果你写出这样的代码遍历其中的属性：
var&num = new&Number();
for(var&pro in&num) {
&&&&console.log("num."&+ pro + " = "&+ num[pro]);
它的输出结果会是空。这是因为Number中内置的属性是不可枚举的，所以不能被for…in访问到。
Object对象的propertyIsEnumerable()方法可以判断此对象是否包含某个属性，并且这个属性是否可枚举。
需要注意的是：如果判断的属性存在于Object对象的原型内，不管它是否可枚举都会返回false。
二、枚举性的作用
属性的枚举性会影响以下三个函数的结果：
Object.keys()
JSON.stringify
先看一个例子，按如下方法创建kxy对象：
function&Person() {
&&&&this.name = "KXY";
Person.prototype = {
&&&&constructor: Person,
&&&&job: "student",
var&kxy = new&Person();
Object.defineProperty(kxy, "sex", {
&&&&value: "female",
&&&&enumerable: false
其中用defineProperty为对象定义了一个名为”sex”的不可枚举属性
接下来做以下验证：
for(var&pro in&kxy) {
&&&&console.log("kxy."&+ pro + " = "&+ kxy[pro]);
遍历结果：
可以看到除了”sex“之外的属性都遍历到了
console.log(Object.keys(kxy));
只包含”name”属性，说明该方法只能返回对象本身具有的可枚举属性。
console.log(JSON.stringify(kxy));
此方法也只能读取对象本身的可枚举属性，并序列化为JSON对象。
阅读(...) 评论()