Object.defineProperty()浅析

1. 对象的定义与赋值

经常使用的定义与赋值方法 obj.prop = value 或者 obj[‘prop’] = value

   let  Person = {}
   Person.name = 'Jack'
   Persion['gender'] = 'female'
   console.log(Person.name)    //  Jack
   console.log(Person.gender)  //  female

Object.defineProperty()语法说明
Object.defineProperty()的作用就是直接在一个对象上定义一个新属性,或者修改一个已经存在的属性

Object.defineProperty(obj, prop, desc)
// 1. obj   需要定义属性的当前对象
// 2. prop 当前需要定义的属性名
// 3. desc  属性描述符

一般通过为对象的属性赋值的情况下,对象的属性可以修改也可以删除,但是通过Object.defineProperty()定义属性,通过描述符的设置可以进行精准的控制对象属性

属性的特性以及内部属性

javascript有三种类型的属性
1.命名数据属性: 拥有一个确定值的属性。这也是最常见的属性
2.命名访问器属性: 通过getter和setter进行读取和赋值的属性
3.内部属性:由JavaScript引擎内部使用的属性,不能通过JavaScript代码直接访问到,不过可以一些方法间接的读取和设置。比如,每个对象都有一个内部属性[[Prototype]],你不能直接访问这个属性,但可以通过Object.getPrototypeOf()方法间接的读取到他的值。虽然内部属性通常用一个双吕括号包围的名称来表示,但实际上着并不是他们的名字,他们是一种抽象操作,是不可见的,根本没有上面两种属性有的那种字符串类型的属性

属性描述符

通过Object.defineProperty()为对象定义属性,有两种形式,且不能混合使用,分别为数据描述符,存取描述符,下面分别描述下两者的区别:

数据描述符 --特有的两个属性(value,writable)

let  Person = {}
Object.defineProperty(Person, 'name', {
     value: 'jack',
     writable: true  //是否可以改变
})
======================================
//1.   属性writable     false
let  Person = {}
Object.defineProperty(Person, 'name', {
      name: 'Jack'
})
Person.name = 'rose'
//writeable默认是false,不能改变属性的值
console.log(Person.name)    //undefined
=======================================
//2. 属性writeable   true
let  Person = {}
Object.defineProperty(Person, 'name', {
     'name' : 'Jack',
     writeable : true
})
Person.name = 'rose'
console.log(Person.name)    //rose

注意: 如果描述符中的某些属性被省略,会使用以下默认规则

属性	默认值
value	undefined
get	undefined
set	undefined
writeable	false
enumerable	false
configurable	false

存取描述符 是由一对getter,setter函数功能来描述的属性
get : 一个给属性提供getter的方法,如果没有getter 则为undefined。该方法返回值被用作属性值。默认为undefined
set: 一个给属性提供setter的方法,如果没有setter则为undefined。该方法将接受唯一参数,并将该参数的新值分配给该属性。默认值为undefined

let  Person = {}
let  temp = null
Object.defineProperty(Person, 'name', {
       get:  function () {
             return  temp
        },
        set: function(val) {
               temp = val
        }
})

=========举例========
let  Person = {}
let  temp = null
Object.defineProperty(Person, 'name', {
      get: function () {
              return   temp
      },
      set: function() {
              temp = val
      }
})
Person.name = 'jack'
console.log(Person.name)     //jack

数据描述符和存取描述具有以下描述符

1. configrable描述属性是否配置,以及可否删除
2. enumerable 描述属性是否会出现在 for in 或者 Object.keys()的遍历中

configrable 代码片段分析

===========  configurable:false不能删除属性  ===============
'use   strict'
let  Person = {}
Object.defineProperty(Person, 'name', {
     value: 'jack',
     configurable: false,
     writable: true,
     enumerable
})
delete  Person.name   //Cannot  delete  property  'name'  of  #<Object>

configurable: false 不能重新定义属性

let  Person = {}
Object.defineProperty(Person, 'name', {
     value : 'jack',
     configurable: false
})
Object.defineProperty(Person, 'name', {
     value: 'rose'   //Cannot  redefine property: name
})

使用Object.defineProperty修改属性:

let  Person = {}
Object.defineProperty(Person, 'name', {
     value:'jack',
     configurable: true,
     writeable: false
})
Object.defineProperty(Person, 'name', {
     value: 'rose'
})
//通过属性定义的形式可以修改name的属性值
console.log(Person.name)   //rose

let  Person = {}
Object.defineProperty(Person, 'name', {
   value: 'jack',
   configurable: false,
   writable: true
})
Object.defineProperty(Person, 'name', {
   value: 'rose'
})
//通过属性定义的形式可以修改name的属性值
console.log(Person.name)   //rose

'use  strict'
let Person = {}
Object.defineProperty(Person, 'name', {
    value: 'jack',
    configurable: true,
    writable: true,
    enumerable: true
})
delete Person.name
console.log(Person.name)   //结果undefined

let Person = {}
Object.defineProperty(Person, 'name', {
   value: 'jack',
   configurable: true,
   writable: false
})
Object.defineProperty(Person, 'name', {
   value: 'rose'
})
//通过属性定义的形式可以修改name的属性值
cosole.log(Person.name)   //rose
//通过赋值的形式,不可以修改,因为writable为false
Person.name = 'tom'
console.log(Person.name)  //rose

let Person = {}
Object.defineProperty(Person, 'name', {
    value: 'jack',
    configurable: false,
    writable: true
})
Object.defineProperty(Person, 'name', {
    value: 'rose'
})
//通过属性定义的形式可以修改name的属性值
console.log(Person.name)   //rose
//通过赋值的形式,可以修改,因为writable为true
Person.name = 'tom'
console.log(Person.name)  //tom

从以上代码运行结果分析总结可知

1. configurable: false时,不能删除当前属性,且不能重新配置当前属性的描述符(有一个小小的意外:可以把writable的状态由true改为false,但是无法由false改为true),但是在writable:true的情况下,可以改变value的值
2. configurable:true时,可以删除当前属性,可以配置当前属性所有描述符

enumerable代码段分析

let Person = {}
Object.defineProperty(Person, 'name', {
    value: 'Jack',
    enumerable: false
})
Person.gender = 'male'
Object.defineProperty(Person,'age', {
     value: '26',
     enumerable: true
})
console.log(Object.keys(Person))     ['gender', 'age']
for(let   k  in Person)  {console.log(k)}    gender, age

console.log(Person.propertyIsEnumerable('name'))     //false
console.log(Person.propertyIsEnumerable('gender'))   //true
console.log(Person.propertyIsEnumerable('age'))        //true

注意:以下两种区别

let  Person = {}
Person.gender = 'male'
//等价于
Object.defineProperty(Person, 'gender', {
   value: 'male',
   configurable: true,
   writable: true,
   enumerable: true,
})

Object.defineProperty(Person, 'age', {
    value: '26',
})
//等级于
Object.defineProperty(Person,'age', {
    value: '26',
    configurable: false,
    writable:false,
    enumerable: false
})

不变性

1.对象属性
结合writeable: false和configurable:false 就可以创建一个真正的常量属性(不可修改,不可重复定义或者删除)

let  Person = {}
Object.defineProperty(Person, 'name', {
  value: 'Jack',
  writeable: false,
  configurable: false
})
delete  Person.name  //不可删除
Person.name = 'rose' //不可重复赋值
console.log(Person.name)   //Jack
//通过赋值,还可以添加新属性
Person.gender = 'male'
console.log(Person.gender)   //male
//不可重新定义
Object.defineProperty(Person, 'name', {
value : 'rose'   //Canot  redefine property:name
})

2. 禁止扩展
   如果你想禁止一个对象添加新属性并且保留已有属性,就可以使用
   Object.preventExtensions(…)

   'use  strict'
    var  Person = {
         name : 'Jack'
    }
   Object.preventExtensions(Person)
   Person.gender = 'male'   //Can't  add  property gender,object  is  not  extensible
   console.log(Person.gender)

var  Person = {
    name: 'Jack'
}
Object.preventExtensions(Person)  //禁止扩展
//仍然可以进行配置
Object.defineProperty(Person,'name',  {
     value: 'rose',
     writeable: false,
     configurable: false
})
//输出配置后的结果
console.log(Person.name)    //rose
//不能进行扩展
Person.gender = 'male'
console.log(Person.gender)   //undefined

在非严格模式下,创建属性gender会静默失败,在严格模式下,将会抛出异常

3. 密封
   Object.seal()会创建一个密封的对象,这个方法实际上会在一个现有对象上调用
   object.preventExtensions(…) 并把所有现有属性标记为configurable:false

var   Person = {
    name: 'Jack'
}
Object.seal(Person)
Person.gender = 'male'
//不能扩展属性
console.log(Person.gender)   //undefined
//再次验证
console.log(Object.keys(Person))   //  ['name']
//不能再次配置属性
Object.defineProperty(Person, 'name', {
    name: 'rose',   //Cannot  redefine  property:name
    configurable: true
})

所以,密封之后不能添加新属性,也不能重新配置或者删除任何现有属性(虽然可以改属性的值)

4. 冻结
   Object.freeze() 会创建一个冻结对象,这个方法实际上会有一个现有对象上调用Object.seal()，并把所有属性标记为writable: false ,这样就无法修改他们的值

var  Person = {
    name: 'Jack',
}
Object.freeze(Person)
Person.gender = 'male'
//不能扩展属性
console.log(Person.gender)   //undefined
//再次验证
console.log(Object.keys(Person))  //['name']
Person.name = 'Tom'
//不能再次修改已有属性的值
console.log(Person.name)   //Jack
//不能再次配置属性
Object.defineProperty(Person, 'name', {
   name: 'rose',  //Cannot  redefine  property:name
   configurable: true
})

这个方法你可以应用在对象上级别最高的不可变性,他会禁止对于对象本身机器任意直接属性的修改(但是这个对象引用的其他对象是不受影响的)
你可以深度冻结一个对象,具体方法为,首先这个对象上调用Object.freeze()然后遍历它引用的所有对象,并在这些对象上调用Object.freeze()。 但是一定要小心,因为这么做有可能会无意中冻结其它共享对象

属性的定义和属性赋值

属性定义,通过Object.defineProperty()形式

1. 如果Obj没有名为Prop的自身属性的话: 如果Obj是可扩展的话,则创建Prop这个自身属性,否者拒绝
2. 如果Obj已经有了名为Prop的自身属性:则按照下面的步骤重新配置这个属性
3. 如果这个已有的属性是不可配置,则进行下面的操作会被拒绝

1: 将一个数据属性转换成访问器属性，反之变然
2: 改变[[Configurable]]或[[Enumerable]]
3: 改变[[Writable]]由false变为true
4: 在[[Writable]]为false时改变[[Value]]
5: 改变[[Get]]或[[Set]]

4. 否则这个已有的属性可以被重新配置

属性赋值,通过obj.prop = 'prop’形式

1. 如果在原型链上存在一个名为P的只读属性（只读的数据属性或者没有setter的访问器属性），则拒绝
2. 如果在原型链上存在一个名为P的且拥有setter的访问器属性，则调用这个setter
3. 如果没有名为P的自身属性，则如果这个对象是可扩展的，就创建一个新属性，否则，如果这个对象是不可扩展的，则拒绝
4. 如果已经存在一个可写的名为P的自身属性，则调用Object.defineProperty(),该操作只会更改P属性的值，其他的特性（比如可枚举性）都不会改变

作用已经影响

属性的定义操作和赋值操作各自有自己的作用和影响。
赋值可能会调用原型上的setter，定义会创建一个自身属性。
原型链中的同名只读属性可能会阻止赋值操作，但不会阻止定义操作。如果原型链中存在一个同名的只读属性，则无法通过赋值的方式在原对象上添加这个自身属性，必须使用定义操作才可以。这项限制是在ECMAScript 5.1中引入的

'use  strict'
let  proto = {
    get  bar() {
          console.log('Getter!')
          return  'a' 
    }
}
let  obj = Object.create(proto)
//Cannot  set  property  bar  of #<Object> which  has  only  a getter
obj.bar = 'hello'  
console.log(obj.bar)

let  proto = {
    get  bar() {
          console.log('Getter!')    //Getter!,  Getter!
          return   'a'
    }
}
let  obj = Object.create(proto)
obj.bar = 'hello'   //直接赋值操作会失败
cosole.log(obj.bar)   //a
//通过定于操作
Object.defineProperty(obj, 'bar', {
    value: 'hello'
})
console.log(obj.bar)   //hello
console.log(proto.bar)  //a

'use  strict'
let  proto = Object.defineProperties({}, {
    foo: {
    //foo属性的特性
    value: 'a',
    //foo属性的值
    writable: false,
     //只读
     configurable: true
     //可配置
    }
})
let  obj = Object.create(proto)
console.log(obj)    //{}
obj.foo = 'hello'   //Cannot assign  to read  only  property 'foo' of object '#<Object>'

'use  strict'
let  proto = Object.defineProperties({}, {
     foo: {
       //foo属性的特性
       value: 'a',
        //foo属性的值
        writable: false,
         //只读
        configurable: true
        //可配置
     }
})
let  obj = Object.create(proto)
console.log(obj)   //{}
Object.defineProperty(obj, 'foo', {
     value: 'b'  //通过定义的形式,创建了自身属性
})
console.log(obj.foo)    //b
console.log(proto.foo)  //a
obj.foo = 'hello'   //Cannot  assign  to  read only  property 'foo' of  object

赋值运算符不会改变原型链上的属性
不能通过为obj.foo赋值来改变proto.foo的值。这种操作只会在obj上新建一个自身属性

'use  strict'
let  proto = {
    foo: 'a'
}
let  obj = Object.create(proto)
console.log(obj)   {}
obj.foo = 'b'
console.log(obj.foo)    //b
console.log(proto.foo)  //a
console.log(obj.hasOwnProperty('foo'))   //true

对象自变量中的属性是通过定于操作添加的

let  obj = {
     name: 'Jack'
}
//等同于
let  obj = new  Object()
Object.defineProperties(obj, {
      name: {
           value: 'Jack',
           enumerable: true,
           configurable: true,
           writable: true
      }
})

再次啰嗦一次，记住以下两种形式的区别：

let  obj = {}
obj.name = 'Jack'

上面的代码等同于:

let  obj = {}
Object.defineProperty(obj, 'name', {
    value: 'Jack',
    writable: true,
    configurable: true,
    enumerable: true
})

另一方面:

Object.defineProperty(obj, 'name', {
    value: 'Jack'
})

上面的代码等同于:

Object.defineProperty(obj, 'name', {
    value: '大漠',
    writable: false,
    configurable: false,
    enumerable: false
})