Object 上的一些办法

1. assign
2. create
3. defineProperties
4. defineProperty
5. keys
6. values
7. entries
8. freeze
9. isFrozen
10. seal
11. isSealed
12. getPrototypeOf
13. setPrototypeOf
14. is
15. isExtensible
16. preventExtensions
17. getOwnPropertyDescriptor
18. getOwnPropertyDescriptors
19. getOwnPropertySymbols
20. getOwnPropertyNames

1.Object.assign(target,source)

将 可枚举 属性的值从一个或对个对象 调配 到指标对象，返回指标对象

const target = {a: 1, b: 2}
const source = {b: { b1: 3}, c: 4 }
const result = Object.assign(target, source)
console.log(result, target);
target.b.b1 = 10

• 能够看出 assign 是一种 浅拷贝，没有开拓新的存储空间去存拷贝来的值，间接的援用

2.Object.create(proto,propertiesObject)

1. 创立 一个空对象
2. 第一个参数作为该对象的 原型

3. 第二个参数为该对象的默认属性

   function School(name) {this.name = name}
   let obj = Object.create(School.prototype, {
    p: {
        value: 4,
        enumerable: false,
        writable: false,
        configurable: false
    },
    length: {value: 0}
   })
   obj.q = 5
   obj.p = 5 //writable 为 false，不可批改
   delete obj.p //configurable 为 false，删除失败
   for (let i in obj) {console.log(i);//enumerable 为 false，p 不被枚举
   }
   console.log(obj);

   • 默认的属性能够配置属性，枚举，可写，可配置

3.Object.defindeProperty(obj,prop,descriptor)与 Object.defineProperties(obj,props)

1. Object.defindeProperty在一个对象上 定义或批改 一个属性，返回该对象

   • descriptor

     • writable 可写
     • enumerable 可枚举
     • configurable 可删除
     • value 值
     • get 读值
     • set 设置值

   let o = {
    a: {
        name: "张三",
        age: 18,
    }
   }
   var val = null
   Object.defineProperty(o.a, "rank", {
    configurable: false,
    enumerable: true,
    get() {console.log("获取张三排名");
        return val
    },
    set(newval) {console.log("新值：" + newval);
        val = newval
    }
   })
   o.a.rank = 1
   console.log(o.a.rank);
   console.log(o);

   • get set和 value writable 不能同时应用
   • 在增加 rank 值时 set 会监听到，能够赋值给一个 两头变量 或者该对象上的一个属性，get 会在 读rank 时执行
   • 点击 rank 的 三个点 也会监听到读的操作

2. Object.defineProperties(obj,props)
   defineProperty 有三个参数，然而只针对一个属性
   defineProperties 的第二个参数不是一个字符串，是一个对象
   它将 defineProperty 的第三个参数交融到第二个参数里
   能够去 配置多个属性

   let o = {
    a: {
        name: "张三",
        age: 18,
    }
   }
   var val = null
   let a = Object.defineProperties(o.a, {
    "rank": {value: 1,},
    "grade": {get() {console.log("读:" + val);
            return val
        },
        set(newval) {console.log("改" + newval);
            val = newval
        }
    }
   }
   )
   o.a.grade = 9
   console.log(o.a.rank, o.a.grade);
   console.log(a);

   • 属性的相干配置默认均为 false

4.Object.getOwnPropertyDescriptor(obj,prop)和 Object.getOwnPropertyDescriptors(obj)

• 获取 指定对象本身属性的 描述符

• 一个是获取 单个 ，一个获取 全副

  const o = {}
  let val = 0
  Object.defineProperties(o, {
    a: {
        value: 1,
        enumerable: true,
        configurable: false,
    },
    b: {
        configurable: false,
        enumerable: false,
        get() {return val},
        set(newval) {val = newval}
    }
  })
  let d1 = Object.getOwnPropertyDescriptor(o, "a")
  let d2 = Object.getOwnPropertyDescriptors(o)
  console.log(d1, d2);

  一般的 追加 对象属性，也会返回相干形容
  不过与 defineProperty 的默认值 false 正好 相同

5.Object.keys(obj) Object.values(obj) Object.entries(obj)

• keys: 返回给定对象可枚举 属性值 组成的 数组
• values: 返回给定对象可枚举 属性名 组成的 数组

• entries: 返回给定对象可枚举 键值对 组成的 数组

  const o = {
    a: 1,
    b: 2,
    fn() {}
  }
  for (const k of Object.keys(o)) {console.log(k);//a b fn
  }
  for (const v of Object.values(o)) {console.log(v);//1 2 fu(){}
  }
  for (const e of Object.entries(o)) {console.log(e);//["a",1] ["b",2] ["fn",fn()]
  }

  数组原型 上的 keys()办法 返回的是 Number 类型，Object 上返回的是 字符串

6.freeze(obj) isFrozen()、seal(obj) isSealed()、preventExtensions() isExtensible

• freeze 解冻一个对象，不可批改，不可加属性，不可删属性，其原型也不能批改
• seal 关闭一个对象，可 批改已有属性，不可加属性，不可删除属性，原型不可批改

• preventExtensions 不可扩大，可 删除 ，可 批改，不可加属性，原型不可批改

  const o1 = {a: 1, b: 2, fn() {}}
  Object.freeze(o1)
  console.log(Object.isFrozen(o1));//true
  o1.a = 2
  console.log(o1.a);// 1
  
  const o2 = {a: 1, b: 2, fn() {}}
  Object.seal(o2)
  console.log(Object.isSealed(o2));//true
  o2.a = 2
  console.log(o2.a);//2
  
  const o3 = {a: 1, b: 2, fn() {}}
  Object.preventExtensions(o3)
  console.log(Object.isExtensible(o3));//false
  o3.a = 2
  console.log(delete o3.b);//true
  console.log(o3.a);//2

  freeze 与 seal 都 不可扩大 且不可删除，isExtensible 的值也为false

7.Object.setPrototypeOf(obj,prototype) Object.getPrototypeOf(obj)

• 设置 对象的原型与 获取 对象的 原型

  const obj = {
    name: "obj",
    getName() {console.log(this.name)
    }
  }
  let o = {name: "o"}
  Object.setPrototypeOf(o, obj)
  Object.getPrototypeOf(o).getName()//obj
  o.getName()//o

  不倡议 应用这种形式以及__proto__去批改原型
  应用 Object.create() 来创立一个指定原型的新对象

8.Object.is(value1,value2)

• 判断两个值是否为 同一个值

const o1 = {a: 1}
const o2 = {b: { c: 2} }
const o3 = {b: { c: 2} }
Object.assign(o1, o2)
console.log(Object.is(o1.b, o2.b));//true
console.log(Object.is(o1.b, o3.b));//false

援用的地址 不同会检测出是不同的值
对于原始类型，只有值雷同即可
能够看出 Object.assign()是 浅拷贝，对用援用类型并没有开拓新的内存空间去存储，只是复制了栈指针的指向

9.Object.getOwnPropertyNames(obj)和 Object.getOwnPropertySymbols(obj)

• getOWnPropertyNames 返回指定对象的属性名组成的 数组，包含不可枚举的属性，但不包含 Symbol 值的属性名

• getOwnPropertySymbols 返回指定对象所有以 Symbol 为属性名的 数组

  let f = Symbol("foo")
  const o = {[f]: 1,
    "a": 2,
    b: 3
  }
  const n = Object.getOwnPropertyNames(o)
  const s = Object.getOwnPropertySymbols(o)
  console.log(n, s);//["a","b"] [Symbol(foo)]

原型上的办法

1.hasOwnProperty
2.isPrototypeOf
3.propertyIsEnumerable
4.toLocalString
5.toString
6.ValueOf
7.__defineGetter__(已废除)
8.__defineSetter__(已废除)
9.__lookupSetter__(已废除)
10.__lookupSetter__(已废除)
11.__proto__(属性 已废除)
12.toSource()(非标准)

1.Object.prototype.hasOwnProperty(prop)

• 检测指定属性是否有某个属性，能够检测到 Symbol 类型

  const a = [1]
  console.log(a.hasOwnProperty(0));//true
  let s = Symbol("foo")
  const o = {[s]: "a",
  }
  console.log(o.hasOwnProperty(s));//true

2.Object.prototype.isPrototypeOf(obj)

• 检测一个对象是否在另一个对象的 原型链 上

  function School(name) {this.name = name}
  School.prototype = {
    constructor: School,
    getName() {console.log(this.name);
    }
  }
  function Student(name) {School.call(this, name)
  }
  Student.prototype = Object.create(School.prototype)
  Student.prototype.constructor = Student
  const std1 = new Student("张三")
  std1.getName() // 张三
  console.log(School.prototype.isPrototypeOf(std1));//true

  下面用 组合寄生 的形式实现的继承
  能够检测出 父类的原型 在子类实例 的原型链上

3.Object.prototype.peopertyIsEnumerable(prop)

• 检测指定对象的某属性是否 可枚举

  let s1 = Symbol("s1")
  let s2 = Symbol("s2")
  const o = {[s1]: 0,
  }
  Object.defineProperties(o, {[s2]: {
        value: 1,
        enumerable: true
    },
    p: {value: 3,}
  })
  console.log(o.propertyIsEnumerable(s1));//true
  console.log(o.propertyIsEnumerable(s2));//true
  console.log(o.propertyIsEnumerable("p"));//false

4.toLocalString() toString() valueOf()

• toLocalString 返回的是 本地环境 字符串，适宜解决工夫类型
• toString 返回 惟一 字符串，不会因为环境的扭转而变动
• valueOf 返回对象的 原始值

对立办法

function transform(o) {console.log(Object.prototype.toLocaleString.call(o));
    console.log(Object.prototype.toString.call(o));
    console.log(Object.prototype.valueOf.call(o));
}

根本数据类型

transform(1000)
//"1000" "[object Number]" {1000}
transform(true)
//"true" "[object Boolean]" {true}
transform(Symbol("smb"))
//"Symbol('smb')" "[object Symbol]" {Symbol(smb)}
transform(1000n)
//"1000" "[object BigInt]" {1000n}
transform("str")
//"str" "[object String]" {"str"}

援用数据类型

transform([0, 1])
//"0,1" "[object Array]" [0,1]
transform({a: 0, b: 1})
//"[object Object]" "[object Object]" {a:0,b:1}
transform(new Date())
//"规范工夫" "[object Date]" "规范工夫"
transform(function () {})
//"function () {}" "[object Function]" f () {}
transform(new Error("e"))
// "Error:e" "[object Error]" Error: e

• 能够看出 toLocalString 返回其内容的 字符串
• toString 返回值惟一 都是方括号 object + 数据类型的 字符串
• valueOf 根本类型会返回一个 对象 援用类型返回其 自身