Object API

Object API
目录
- Object API
  创建对象
  其中对于descriptor属性符可以设置的值如下显示
Object API

创建对象
1. 对象字面量
```
let obj = {}
```
  语法糖,最终会被引擎转化为 let obj = new Object()
2. 原型继承的方式
```
let obj2 = Object.create({})
```
  通过原型继承的方式来创建对象,创建出的对象o是一个空对象,并且o的原型指向了{}
```
Object.create = function(obj2){
     let F = function(){}
     f.prototype = obj2
    return new F()
}
理解为F为一个空的构造函数,F原型指向传入的参数,返回F的实例
通过Object.create生成的对象的原型指向了传入的参数,实现原型继承
```
  这种方式下,
```
obj2._proto_指向{}空对象
obj2._proto_._proto_指向对象的原型
obj2._proto_._proto_ == Object.prototype
```
3. new 构造函数
  
  当用new运算符调用一个函数时,函数返回一个对象,通过构造函数内this指向要返回的对象
```
function Person (name){
    this.name = name
}
let a = new Person('cici')
//此时a = Person{name:'cici'}


function Person2 (name){
    let obj = {}
    this.name = name
    return obj
}
let a2 = new Person('cici')
//此时a2 = person{name:'cici'}

function Person3 (name){
    this.name = name
    return 'xixi'
}
let a3 = new Person3('cici')

//此时a3 = person{name:'cici'}
//console.log(Person3()) //xixi
//console.log(a3()) // a3 is not a function
//console.log(a3)  //Person3 {name: "cici"}
```
1. Object.entries
将对象中的所有key:value转为[key,value]格式，返回包含所有健值对的二维数组
```
    let obj = {name: 'derek',age:18}
    let result = Object.entries(obj) 
    console.log(result) // => [['name','derek'],['age',18]]
```
1. Object.fromEntries()
把Object.entries转换后的二维数组重新转换为对象
```
    let obj = {a:1,b:2}
    let entrise = Object.entries(obj)//[[a:1],[b:2]]
    let obj2 = Object.fromEntries(entries)   // {x:3,y:4}
```
6.Object.assign()

将多个对象合并到目标的属性合并到目标对象中，相同属性的值以最后一个合并对象的为准，返回目标对象，不改变被合并对象，可以实现浅克隆
- 语法: Object.assign(obj,obj1,obj2...)
- obj: 目标对象，可传{}
- obj1,obj2...: 被合并的对象，一个或多个
- PC端IE全不兼容，移动端只有少量浏览器兼容
```
  let obj = {name: 'derek',age: 18}
  let obj1 ={ name: 'tom', sex: 'F' }
  let result = Object.assign({},obj,obj1,{aa:1})
  console.log(result)   // => {name:'tom',age:18,sex: 'F',aa:1}
  console.log(obj)     // => {name: 'derek',age: 18}
  console.log(obj1)   // => { name: 'tom', sex: 'F' }
```
1. Object.defineProperty()
Object.defineProperty(obj,prop,descriptor):对obj对象上对prop属性进行定义或修改，其中descriptor为被定义或修改的属性符。

其中对于descriptor属性符可以设置的值如下显示
- value:表示属性的值，默认为undefined
- writable:该属性是否为可写，如果直接在对象上定义属性，则默认为true。如果设置为false，则属性仅为可读。
- configurable: 如果为false的话，则不能修改（writabel,configurable,enumerable），如果直接在对象上定义属性，则默认为true
- enumerable:是否能够被枚举，如果直接在对象上定义属性，则默认为true
- get:当对象访问prop属性的时候，会调用这个方法，并返回结果。默认为undefined
- set:当对象设置该属性的时候，会调用这个方法，默认为undefined 注意：兼容性不错，移动端几乎全兼容，PC端兼容IE9以上，IE8也能运行，但是只能传dom对象
```
      var obj = {}, value = null;
  Object.defineProperty(obj, "num", {
      get: function(){
          console.log('执行了 get 操作')
          return value;
      },
      set: function(newValue) {
          console.log('执行了 set 操作')
          value = newValue;
      }
  })
 
  obj.num = 1 // 执行了 set 操作
 
  console.log(obj.num) // 1 执行了 get 操作
```
1. Object.getOwnPropertySymbols()
Object.getOwnPropertySymbols(obj): 返回一个对象中所有以Symbol类型为key的的数组
```
  let obj = {name: 'derek'}
  let a =Object.getOwnPropertySymbols(obj)
  console.log(a) // => []
  let sys = Symbol()
  obj[sys] = 'test'
  let b =Object.getOwnPropertySymbols(obj)
  console.log(b) // => [Symbol()]
```
1. Object.freeze()`
Object.freeze(obj):浅冻结一个对象，使其不能做任何修改，深层级的还是可以修改

如果要实现深度冻结，可以通过递归来实现
```
  let obj = {name: 'derek',child:{age:18}}
  Object.freeze(obj)
  obj.name = 'tom' // 不能修改原有属性对应的值
  console.log(obj) // => {name:'derek'}  
  obj.test = 'test' // 不能给对象添加新属性
  console.log(obj)  // => {name: 'derek'}
  delete obj.name   // 不能删除对象的属性
  console.log(obj)  // => {name: 'derek'}
 
  obj.child.age=22 // 可以对深层级的进行修改
  console.log(obj.child) // => {age:22}
```
1. Object.isFrozen()
判断一个对象是否被冻结,是放回true，反之返回false
```
  let obj = {name: 'derek'}
  Object.isFrozen(obj) //=> false
  Object.freeze(obj)
  Object.isFrozen(obj) //=> true
```
1. Object.getOwnPropertySymbols()
返回一个对象中所有以Symbol类型为key的的数组
```
  let obj = {name: 'derek'}
  let a =Object.getOwnPropertySymbols(obj)
  console.log(a) // => []
  let sys = Symbol()
  obj[sys] = 'test'
  let b =Object.getOwnPropertySymbols(obj)
  console.log(b) // => [Symbol()]
```
1. Object.keys()
查找目标对象的所有key值，并返回一个包含所有key值的数组，和Object.getOwnPropertyNames()效果一致
```
  let obj = {name: 'derek',age:22,sex:'M'} 
  let a = Object.keys(obj)
  console.log(a) //=> ['name','age','sex']
```
1. Object.values()
返回一个对象的所有value值的数组集合
```
  let obj = {name: 'derek',age:18}
  let result = Object.values(obj) 
  console.log(result) // => ['derek',18]
```
1. Object.seal()
对一个对象进行密封，并返回被密封的对象，这些对象都是不能够添加属性，不能删除已有属性，以及不能够修改已有属性的可枚举型、可配置型、可写性
```
  let obj = {name: 'derek'}
  Object.seal(obj)
  obj.name = 'tom' // 可以修改原有属性对应的值
  console.log(obj) // => {name:'tom'}  
  obj.test = 'test' // 不能给对象添加新属性
  console.log(obj)  // => {name: 'tom'}
  delete obj.name   // 不能删除对象的属性
  console.log(obj)  // => {name: 'tom'}
```
1. Object.isSealed()
判断一个对象是否被密封,是放回true，反之返回false
```
  let obj = {name: 'derek'}
  Object.isSealed(obj) //=> false
  Object.freeze(obj)
  Object.isSealed(obj) //=> true
```
1. Object.preventExtensions()
让一个对象永远不能添加新的属性，严格模式下会报错
```
  let obj = {name: 'derek'}
  obj.age = 22 
  console.log(obj.age) // => 22
  Object.preventExtensions(obj)
  obj.sex = 'M'  // 报错
  obj._proto_.sex = 'M'  //可以在原型对象上添加属性
  console.log(obj.sex) // => 'M'
```
1. Object.isExtensible()
判断一个对象是否可以修改属性,是放回true，反之返回false
```
    let obj = {name: 'derek'}
    Object.isExtensible(obj) //=> true
```
1. Object.is(val1,val2)
确定两个值是否是相同的值
- 注意：与=相比，其会将-0和+0看成不等，并且对于两个NaN的比较，Object.is()会看成是相等的，而=会将0、-0、+0看成相等的，两个NaN看成不等
```
  Object.is(0,-0) // => false
  Object.is(0,0) // => true
  Object.is(NAN,0/0) // => true
  Object.is(3,3/1) // => true
```
1. Object.getPrototypeOf(obj):
该方法返回对象的原型对象，如果没有的话，则返回null。
```
  let obj = {name: 'derek',age:22,sex:'M'} 
  let a = Object.getPrototypeOf(obj)
```
1. Object.getOwnPropertyDescriptor(obj,prop)
查询prop属性存是否在对象obj上，在则返回其属性描述符，如果不存在就返回undefined

属性描述符包括：
- value:表示属性的值，默认为undefined
- writable:该属性是否为可写，如果直接在对象上定义属性，则默认为true。如果设置为false，则属性仅为可读。
- configurable: 如果为false的话，则不能修改（writabel,configurable,enumerable），如果直接在对象上定义属性，则默认为true
- enumerable:是否能够被枚举，如果直接在对象上定义属性，则默认为true
- get:当对象访问prop属性的时候，会调用这个方法，并返回结果。默认为undefined
- set:当对象设置该属性的时候，会调用这个方法，默认为undefined
```
  let obj = {name: 'derek',age:22,sex:'M'}
  let a = Object.getOwnPrepertyDescriptor(obj,'name')
  let b = Object.getOwnPrepertyDescriptor(obj,'test')
  console.log(a) // => {value:'derek',writable: true,enumerable: true,configurable: true}
  console.log(b) // => undefined
```
1. Object.getOwnPropertyNames(obj)
查找目标对象的所有key值，并返回一个包含所有key值的数组，和Object.keys()效果一致
- 枚举的顺序,返回一个数组，枚举出来对象的属性
- 对象的顺序其实是浏览器厂商自行规定
  先排数字，升序再排其他，按照书写顺序、
```
  let obj = {name: 'derek',age:22,sex:'M'} 
  let a = Object.getOwnPropertyNames(obj)
  console.log(a) //=> ['name','age','sex']
```
1. hasOwnProperty(propertyName String)
检查指定的属性是不是自有属性的

区分对象的那些属性是自己的，那些是共有

属性（从父对象哪里继承来的）？

如果要检查是共有属性的话，还需要排除没有这个属性共有属性是指在原型对象中声明的属性

参数：
propertyName String类型指定的属性名称

返回值:
函数的返回值为Boolean类型。如果对象object具有名称为propertyName的属性，则返回true，否则返回false。
1. Object.setPrototypeOf()
设置某个对象的隐式原型 proto
```
    let obj1 = {a:1}
    let obj2 = {b:2}

    Object.setPrototypeOf(obj1,obj2)
    console.log(obj1.__proto__)//{b:2}
```
相关阅读:
VS2015预览版中的C#6.0 新功能（一）
REST总结
 MVC和传统的以模板为中心的web架构比较
 实现两个select list box间item的移动和过滤
 异步编程
 简述System.Windows.Forms.Timer 与System.Timers.Timer用法区别
 C#导出EXCEL，并生成charts表
 CRC16位校验
 c# 后台GET、POST、PUT、DELETE传输发送json数据
 UDP通讯
原文地址：https://www.cnblogs.com/dudududadada/p/15339367.html

Object API

创建对象

其中对于descriptor属性符可以设置的值如下显示