对象属性

defineProperty()

详细定义对象的属性

Object.defineProperty(obj, prop, descriptor)

 

var obj={};
Object.defineProperty(obj,“属性名”,{
   enumerable: false,
   configurable: false,
   writable: false,
   value: 属性值
})

 

 

//Object.defineProperty(对象,"属性名(字符型,数值型,Symbol)",属性描述对象)
        Object.defineProperty(obj,"d",{
            configurable:false,//是否可以删除属性或者可以重定义属性描述对象
            enumerable:false,//是否可以枚举
            writable:false,//是否可写(是否只读)
            value:100,//该属性的值
        })

        后面介绍
        Object.defineProperty(obj,"e",{
            configurable:false,
            enumerable:false,
            set:function(_value){
                this._d=value;
            },
            get:function(){
                return this._d;
            }
        })
 
 
 
1、configurable  是否可删除或者是否可修改对象属性的描述对象
            Object.defineProperty(obj,"b",{
                configurable:false,
                writable:true,
                enumerable:true,
                value:30
            });
            delete obj.a;
            delete obj.b;//b属性不能被删除

            b属性的描述对象不能重新定义,也就是说前面设置不可删除,这里就不能修改为可删除
            但是b属性的值是可以通过直接赋值修改的
            Object.defineProperty(obj,"b",{
                configurable:true,
                writable:true,
                enumerable:true,
                value:30
            })
            obj.b=100;
            console.log(obj);

2、 writable是否可修改,可写,只读

                Object.defineProperty(obj,"b",{
                    configurable:true,
                    writable:false,
                    enumerable:true,
                    value:30
                });

                obj.b=10;//无法进行直接赋值修改
                但是如果configurable没有设置为false,可以通过
                设置对象属性描述对象的value值来修改该属性
                Object.defineProperty(obj,"b",{
                    configurable:true,
                    writable:false,
                    enumerable:true,
                    value:100
                });
                console.log(obj);

3、 enumerable属性是不可枚举属性

                该属性或者方法是不暴露的
                Object.defineProperty(obj,"b",{
                    configurable:true,
                    writable:true,
                    enumerable:false,
                    value:30
                });
                console.log(obj);
                不可遍历
                for(var prop in obj){
                    console.log(prop);
                }
                
                不可以复制
                var o=Object.assign({},obj);
                var o={...obj};
                var o=JSON.parse(JSON.stringify(obj));
                不可枚举属性不可以通过JSON.stringify转换为字符串
                console.log(o);
                obj.b=100;
                console.log(obj.b);
 
 
 
 
4、不可枚举,不可修改,不可删除,不可以复制(现在)
                Object.defineProperty(obj,"b",{
                    // 没有设置的属性都是false
                    value:10
                });
                console.log(obj);
 
 
对象属性的设置
 
      // 设置对象的多个属性的描述的对象
                Object.defineProperties(obj,{
                    b:{
                        value:10
                    },
                    c:{
                        enumerable:true,//默认是false,做限制,写true,是该项不限制
                        value:20
                    },
                    d:{
                        configurable:true,
                        value:100
                    },
                    e:{
                        value:function(){
                            console.log("aa");
                        }
                    }
                })

                // obj.f=10;
                // console.log(obj);
 

            for(var prop in obj){
                console.log(prop);
            }//只能获取ac
 
 
 
 
 
 
 
 
getOwnPropertyNames
 
获取对象下所有属性的名称,并返回一个数组,
该数组的内容就是这些属性名,该数组对元素是 obj 自身拥有的枚举或不可枚举属性名称字符串。 数组中枚举属性的顺序与通过 for...in 循环(或 Object.keys)迭代该对象属性时一致。 数组中不可枚举属性的顺序未定义。
 
 
var obj={a:1,b:2,c:3}
var arr=Object.getOwnPropertyNames(obj);
打印显示的是[a,b,c]
举例:
 获取对象中的所有属性名,并且返回这个属性名组成的数组,不包含原型链
            var arr=Object.getOwnPropertyNames(obj);
            console.log(arr.includes("a"));//可以看到可枚举或者不可枚举的属性
            console.log(arr,obj)
            
            console.log("a" in obj);
            console.log("d" in obj);
 
 
getOwnPropertyDescriptor
Object.getOwnPropertyDescriptor(obj, prop)
获取对象下属性的描述,也就是使用defineProperty定义的所有属性的描述内容
举例:

                希望根据属性名,获取描述对象
                var desc=Object.getOwnPropertyDescriptor(obj,"b");
                console.log(desc);
            for(var i=0;i<arr.length;i++){
                var desc=Object.getOwnPropertyDescriptor(obj,arr[i]);
                console.log(arr[i],desc);
            }
                
 
 
那么现在就可以解决 上面没解决的问题了
把对象原样复制下来
Object.defineProperties(obj,{
                    b:{
                        value:10
                    },
                    c:{
                        enumerable:true,//默认是false,做限制,写true,是该项不限制
                        value:20
                    },
                    d:{
                        configurable:true,
                        value:100
                    },
                    e:{
                        value:function(){
                            console.log("aa");
                        }
                    }
                })
 
 
var arr=Object.getOwnPropertyNames(obj);
            var o={};
            for(var i=0;i<arr.length;i++){
                var desc=Object.getOwnPropertyDescriptor(obj,arr[i]);
                Object.defineProperty(o,arr[i],desc);
            }
            // obj.a=1000;//无变化
            // o.b=1000;//无变化
            // console.log(o);  
 
这就完成了一个复杂对象的复制
 
 
 
 
 
freeze()
Object.freeze(obj)
冻结对象,使用该方法以后,不能修改该对象的所有属性,不能删除所有属性。冻结对象,使用该方法以后,不能修改该对象的所有属性,不能删除所有属性。
 
 
        冻结 冻结后的对象无法修改属性,也无法删除属性,也不能添加属性
        冻结后的对象再通过复制后,源对象无法修改,但是复制后的新对象可以修改
        通过Object.create根据冻结对象创建的对象,原型链的属性无法修改
        Object.freeze(obj);
        obj.a=10;
        delete obj.a
        var o=Object.assign({},obj);
        o.a=10;

        var o=Object.create(obj);
        o.__proto__.a=10;
        console.log(o);
 
 
 
 判断是否冻结
 
        console.log(Object.isFrozen(obj));
 
 // 是否可以扩展,添加新的属性
        console.log(Object.isExtensible(obj));
 
 
 
Object.is
     
        Object.is()和===  相似
        Object.is(a,b)判断a和b如果不是引用类型,是不是完全一样
        console.log(Object.is([],[]));//false
        console.log(Object.is(1,"1"));//两个类型是不同


        console.log(Object.is("a","a"));//true
        console.log("a"==="a");//true

        console.log(+0===-0);//true
        console.log(Object.is(+0,-0));//false

        console.log(NaN===NaN);//false
        console.log(Object.is(NaN,NaN));//true
 
 
    var num=Number("a");
        if(isNaN(num)){

        }

        if(Object.is(num,NaN)){

        }
posted @ 2020-05-13 14:51  我是乐呀  阅读(188)  评论(0)    收藏  举报