JavaScript Object 对象-数据类型#

1Object.create(prototype, [descriptors])

1const newObj = Object.create(obj, {
2  sex: {
3    // 键名
4    value: '男', // 键值，默认 undefined
5    writable: true, // 是否可以被修改。默认 false
6    configurable: true, // 是否可以被删除。默认 false
7    enumerable: true, // 是否支持可枚举(for in 访问)。默认值是 false
8  },
9})

1Object.defineProperty(obj, [propName], descriptor)

1const obj = { sex1: '' }
2
3Object.defineProperties(obj, {
4  sex: {
5    // 也可以有 Object.create() 的配置
6    set(value) {
7      // 赋值时调用
8      this.sex1 = value
9    },
10    get() {
11      // 获取值时调用
12      return this.sex1
13    },
14  },
15})

1const obj = {}
2Object.defineProperties(obj, {
3  property1: {
4    value: true,
5    writable: true,
6  },
7  property2: {
8    value: 'Hello',
9    writable: false,
10  },
11})

1Object.assign(target, ...sources)

1const target = { a: 1, b: 2 }
2const source = { b: 4, c: 5 }
3const returned = Object.assign(target, source)
4
5console.log(target) // Object { a: 1, b: 4, c: 5 }
6console.log(returned) // Object { a: 1, b: 4, c: 5 }

1const user = {
2  name: 'tom',
3  age: 25,
4}
5
6const keys = Object.keys(user) // ['name','age'] 返回键的数组，参数可以是原型对象
7
8// 只遍历键
9for (const key of Object.keys(obj))
10  console.log(key)

1const user = {
2  name: 'tom',
3  age: 25,
4}
5const keys = Object.values(user) // ["tom", 25]
6
7// 只遍历值
8
9for (const item of Object.values(obj))
10  console.log(item)

1for (const [key, item] of Object.entries(obj))
2  console.log(item, key)

1Object.getOwnPropertyNames(Person.prototype) // ["constructor", "name", "job", "sayName"] 返回键的数

1Object.getOwnPropertySymbols(obj)
2// 参数：要返回 Symbol 属性的对象。
3// 返回值：对象自身上找到的所有 Symbol 属性的数组。
4
5var obj = {}
6const a = Symbol('a')
7const b = Symbol.for('b')
8
9obj[a] = 'localSymbol'
10obj[b] = 'globalSymbol'
11
12const objectSymbols = Object.getOwnPropertySymbols(obj)
13console.log(objectSymbols.length) // 2
14console.log(objectSymbols) // [Symbol(a), Symbol(b)]
15console.log(objectSymbols[0]) // Symbol(a)

1Object.getOwnPropertyDescriptors({ a: 1 })
2/* {
3  a:{
4    configurable: true
5    enumerable: true
6    value: 1
7    writable: true
8  }
9} */

1Object.is(value1, value2)
2// 比较两个值是否相等，与 == 和 === 不一样。返回 true/false
3
4Object.is('foo', 'foo') // true
5Object.is(window, window) // true
6Object.is([], []) // false
7
8const foo = { a: 1 }
9const bar = { a: 1 }
10Object.is(foo, foo) // true
11Object.is(foo, bar) // false
12Object.is(null, null) // true
13
14// 特例
15Object.is(0, -0) // false
16Object.is(0, +0) // true
17Object.is(-0, -0) // true
18Object.is(Number.NaN, 0 / 0) // true

1Object.getPrototypeOf(object) // 返回参数的原型对象，没有继承属性则返回 null
2Object.getPrototypeOf(Object) // ƒ () { [native code] }
3Object.getPrototypeOf(Function) // ƒ () { [native code] }
4Object.getPrototypeOf(Object) === Function.prototype // true
5
6const obj = new Object()
7Object.prototype === Object.getPrototypeOf(obj) // true
8Object.prototype === Object.getPrototypeOf({}) // true

1Object.freeze(obj) // 返回被冻结的对象; 返回传递的对象，不是创建一个被冻结的副本
2// 冻结一个对象，冻结后不能添加删除，包括配置，可枚举，可写性等;也包括原型上的属性

1Object.seal(obj) // 返回被封闭的对象的引用
2// 阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。
3// 不会影响从原型链上继承的属性。但 __proto__ 属性的值也会不能修改。

1const obj = {}
2obj.prop = 42
3console.log(obj.hasOwnProperty('prop')) // true
4console.log(obj.hasOwnProperty('toString')) // false