跳到主要内容

Object 对象

对象方法​

1. Object.assign() 对象复制拼接​

Object.assign() 静态方法将一个或者多个源对象中所有可枚举的自有属性复制到目标对象，并返回修改后的目标对象。

语法：Object.assign(target, ...sources)
const target = { a: 1, b: 2 }
const source = { b: 4, c: 5 }
const returnedTarget = Object.assign(target, source)
console.log(target)
// Object { a: 1, b: 4, c: 5 }
console.log(returnedTarget === target)
// true

英语​

  • assign 分派，布置；
  • assignment 作业，任务；
  • assignment(美式)==homework(英式) 都是 作业，任务 的意思；

2. Object.create() 以一个现有对象作为原型，创建一个新的空对象​

  • Object.create() 静态方法以一个现有对象作为原型，创建一个新对象。
  • 会继承旧对象方法属性
语法：Object.create(proto, propertiesObject)
const person = {
  isHuman: false,
  printIntroduction: function () {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`)
  },
}
// person 将作为 me 的原型
const me = Object.create(person)
me.name = 'Matthew' // 这个 "name" 属性是在新 me 对象上, 但不在 "person" 对象上
me.isHuman = true // 可以覆盖继承的属性
me.printIntroduction()
// output: "My name is Matthew. Am I human? true"

3. Object.defineProperties() 定义属性​

Object.defineProperties() 静态方法直接在一个对象上定义新的属性或修改现有属性，并返回该对象。

语法：Object.defineProperties(obj, props)
const object1 = {}

Object.defineProperties(object1, {
  property1: {
    value: 42,
    writable: true,
  },
  property2: {},
})

console.log(object1.property1)
// 42

4. Object.defineProperty() 定义属性​

Object.defineProperty() 静态方法会直接在一个对象上定义一个新属性，或修改其现有属性，并返回此对象。

语法：Object.defineProperty(obj, prop, descriptor)
const object1 = {}
Object.defineProperty(object1, 'property1', {
  value: 42,
  writable: false,
})
object1.property1 = 77
// Throws an error in strict mode
console.log(object1.property1)
// output: 42

5. Object.entries() 对象键值对转数组​

  • Object.entries() 静态方法返回一个数组，包含给定对象自有的可枚举字符串键属性的键值对。
语法：Object.entries(obj)
const object1 = {
  a: 'somestring',
  b: 42,
}

for (const [key, value] of Object.entries(object1)) {
  console.log(`${key}: ${value}`)
}
// "a: somestring"
// "b: 42"

6. Object.freeze() 冻结一个对象​

  • Object.freeze() 静态方法可以使一个对象被冻结。冻结对象可以防止扩展，并使现有的属性不可写入和不可配置。被冻结的对象不能再被更改：不能添加新的属性，不能移除现有的属性，不能更改它们的可枚举性、可配置性、可写性或值，对象的原型也不能被重新指定。freeze() 返回与传入的对象相同的对象。

  • 冻结一个对象是 JavaScript 提供的最高完整性级别保护措施。

语法：Object.freeze(obj)
const obj = {
  prop: 42,
}
Object.freeze(obj)
obj.prop = 33
// Throws an error in strict mode
console.log(obj.prop)
// output: 42

7. Object.fromEntries() 键值对 转 对象​

  • Object.fromEntries() 静态方法将键值对列表转换为一个对象。
语法：Object.fromEntries(iterable)
const entries = new Map([
  ['foo', 'bar'],
  ['baz', 42],
])
const obj = Object.fromEntries(entries)
console.log(obj)
// output: Object { foo: "bar", baz: 42 }

8. Object.getOwnPropertyDescriptor() 获取自己的属性描述符​

  • Object.getOwnPropertyDescriptor() 静态方法返回一个对象，该对象描述给定对象上特定属性（即直接存在于对象上而不在对象的原型链中的属性）的配置。返回的对象是可变的，但对其进行更改不会影响原始属性的配置。
语法：Object.getOwnPropertyDescriptor(obj, prop)
const object1 = {
  property1: 42,
}
const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1')
console.log(descriptor1)
// output: Object { value: 42, writable: true, enumerable: true, configurable: true }
console.log(descriptor1.configurable)
// output: true
console.log(descriptor1.value)
// output: 42

9. Object.getOwnPropertyDescriptors() 获取自己的所有属性描述符​

  • Object.getOwnPropertyDescriptors() 静态方法返回给定对象的所有自有属性描述符。
语法：Object.getOwnPropertyDescriptors(obj)
const object1 = {
  property1: 42,
  property2: 33,
}
const descriptors1 = Object.getOwnPropertyDescriptors(object1)
console.log(descriptors1)
// output: Object { property1: Object { value: 42, writable: true, enumerable: true, configurable: true }, property2: Object { value: 33, writable: true, enumerable: true, configurable: true } }
console.log(descriptors1.property1)
// output: Object { value: 42, writable: true, enumerable: true, configurable: true }
console.log(descriptors1.property1.writable)
// output: true
console.log(descriptors1.property1.value)
// output: 42

10. Object.getOwnPropertyNames() 将对象属性键值转成数组​

  • Object.getOwnPropertyNames() 静态方法返回一个数组，其包含给定对象中所有自有属性（包括不可枚举属性，但不包括使用 symbol 值作为名称的属性）。
  • getOwnPropertyNames 获取自己的属性名称
语法：Object.getOwnPropertyNames(obj)
const object1 = {
  a: 1,
  b: 2,
  c: 3,
}
console.log(Object.getOwnPropertyNames(object1))
// output: Array ["a", "b", "c"]

11. Object.getOwnPropertySymbols() 将对象 Symbol 属性键值转成数组​

  • Object.getOwnPropertySymbols() 静态方法返回一个包含给定对象所有自有 Symbol 属性的数组。
语法：Object.getOwnPropertySymbols(obj)
const object1 = {}
const a = Symbol('a')
const b = Symbol.for('b')

object1[a] = 'localSymbol'
object1[b] = 'globalSymbol'

const objectSymbols = Object.getOwnPropertySymbols(object1)
console.log(objectSymbols)
// output: Array [Symbol(a), Symbol(b)]
console.log(objectSymbols.length)
// output: 2

12. Object.getPrototypeOf() 查找对象原型​

  • Object.getPrototypeOf() 静态方法返回指定对象的原型（即内部 Prototype 属性的值）。
语法：Object.getPrototypeOf(obj)
const prototype1 = {}
// 以prototype1为原型创建object1这个对象
const object1 = Object.create(prototype1)
console.log(Object.getPrototypeOf(object1) === prototype1)
// output: true

13. Object.hasOwn() 判断属性是否是自己的属性​

  • 如果指定的对象自身有指定的属性，则静态方法 Object.hasOwn() 返回 true。如果属性是继承的或者不存在，该方法返回 false。
  • 备注： Object.hasOwn() 旨在取代 Object.prototype.hasOwnProperty()。
语法：Object.hasOwn(obj, prop)
const object1 = {
  prop: 'exists',
}
console.log(Object.hasOwn(object1, 'prop'))
// output: true
console.log(Object.hasOwn(object1, 'toString'))
// output: false
console.log(Object.hasOwn(object1, 'undeclaredPropertyValue'))
// output: false

14. Object.is() 确定两个值是否为相同值；​

  • Object.is() 静态方法确定两个值是否为相同值。
语法：Object.is(value1, value2)
console.log(Object.is('1', 1))
// output: false
console.log(Object.is(NaN, NaN))
// output: true
console.log(Object.is(-0, 0))
// output: false
const obj = {}
console.log(Object.is(obj, {}))
// output: false

15. Object.isExtensible() 判断对象是否可扩展​

  • Object.isExtensible() 静态方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。
语法：Object.isExtensible(obj)
const object1 = {}
console.log(Object.isExtensible(object1))
// output: true

Object.preventExtensions(object1)
console.log(Object.isExtensible(object1))
// output: false

16. Object.preventExtensions() 防止对象被扩展​

  • Object.preventExtensions() 静态方法可以防止新属性被添加到对象中（即防止该对象被扩展）。它还可以防止对象的原型被重新指定。
语法：Object.preventExtensions(obj)
const object1 = {}
Object.preventExtensions(object1)

try {
  Object.defineProperty(object1, 'property1', {
    value: 42,
  })
} catch (e) {
  console.log(e)
  // output: TypeError: Cannot define property property1, object is not extensible
}

17. Object.isFrozen() 判断对象是否被冻结了；​

  • Object.isFrozen() 静态方法判断一个对象是否被冻结。
语法：Object.isFrozen(obj)
const object1 = {
  property1: 42,
}
console.log(Object.isFrozen(object1))
// output: false
Object.freeze(object1)
console.log(Object.isFrozen(object1))
// output: true

18. isPrototypeOf() 判断是否在另一个对象的原型链中；​

  • 全称：Object.prototype.isPrototypeOf()
  • isPrototypeOf() 方法用于检查一个对象是否存在于另一个对象的原型链中。
语法：isPrototypeOf(object)
function Foo() {}
function Bar() {}
Bar.prototype = Object.create(Foo.prototype)
const bar = new Bar()
console.log(Foo.prototype.isPrototypeOf(bar))
// output: true
console.log(Bar.prototype.isPrototypeOf(bar))
// output: true

19. Object.isSealed() 是否被密封​

  • Object.isSealed() 静态方法判断一个对象是否被密封。
语法：Object.isSealed(obj)
const object1 = {
  property1: 42,
}
console.log(Object.isSealed(object1))
// output: false
Object.seal(object1)
console.log(Object.isSealed(object1))
// output: true

20. Object.seal() 密封一个对象​

  • Object.seal() 静态方法密封一个对象。
  • 密封一个对象会阻止其扩展并且使得现有属性不可配置。
  • 密封对象有一组固定的属性：
  • 不能添加新属性、
  • 不能删除现有属性
  • 或更改其可枚举性和可配置性、
  • 不能重新分配其原型。
  • 现有属性的值是可写的，它们仍然可以更改。
  • seal() 返回传入的同一对象。

我的理解：密封一个对象阻止扩展，但本身属性值可修改

语法：Object.seal(obj)
const object1 = {
  property1: 42,
}
Object.seal(object1)
object1.property1 = 33
console.log(object1.property1)
// output: 33

delete object1.property1 // 密封时无法删除
console.log(object1.property1)
// output: 33

21. Object.keys() 将对象属性键 转 数组​

  • Object.keys() 静态方法返回一个由给定对象自身的可枚举的字符串键属性名组成的数组。
语法：Object.keys(obj)
const object1 = {
  a: 'somestring',
  b: 42,
  c: false,
}
console.log(Object.keys(object1))
// output: Array ["a", "b", "c"]

22. Object.values() 将对象属性值 转 数组​

  • Object.values() 静态方法返回一个给定对象的自有可枚举字符串键属性值组成的数组。
语法：Object.values(obj)
const object1 = {
  a: 'somestring',
  b: 42,
  c: false,
}
console.log(Object.values(object1))
// output: Array ["somestring", 42, false]

23. propertyIsEnumerable() 判断属性是否可枚举的​

  • 全称 Object.prototype.propertyIsEnumerable()
  • propertyIsEnumerable() 方法返回一个布尔值，表示指定的属性是否是对象的可枚举自有属性。
语法：propertyIsEnumerable(prop)
const object1 = {}
const array1 = []
object1.property1 = 42
array1[0] = 42

console.log(object1.propertyIsEnumerable('property1'))
// output: true
console.log(array1.propertyIsEnumerable(0))
// output: true
console.log(array1.propertyIsEnumerable('length'))
// output: false

24. Object.setPrototypeOf() 将一个对象设置成另外一个对象的原型。​

  • Object.setPrototypeOf() 静态方法可以将一个指定对象的原型（即内部的 [[Prototype]] 属性）设置为另一个对象或者 null。
  • 由于性能问题不建议使用，可以使用 Object.create()实现该功能
语法：Object.setPrototypeOf(obj, prototype)
const obj = {}
const parent = { foo: 'bar' }
console.log(obj.foo)
// output: undefined
Object.setPrototypeOf(obj, parent)
console.log(obj.foo)
// output: "bar"

25. toLocaleString()​

  • toLocaleString() 方法返回一个表示对象的字符串。该方法旨在由派生对象重写，以达到其特定于语言环境的目的。
  • 全称：Object.prototype.toLocaleString()
语法：toLocaleString()
const date1 = new Date(Date.UTC(2012, 11, 20, 3, 0, 0))
console.log(date1.toLocaleString('ar-EG'))
// output: "٢٠‏/١٢‏/٢٠١٢ ٤:٠٠:٠٠ ص"
const number1 = 123456.789
console.log(number1.toLocaleString('de-DE'))
// output: "123.456,789"

26. toString()​

  • 全称：Object.prototype.toString()
  • toString() 方法返回一个表示该对象的字符串。该方法旨在重写（自定义）派生类对象的类型转换的逻辑。
语法：toString()
function Dog(name) {
  this.name = name
}
const dog1 = new Dog('Gabby')
Dog.prototype.toString = function dogToString() {
  return `${this.name}`
}
console.log(dog1.toString())
// output: "Gabby"

27. valueOf()​

  • Object 实例的 valueOf() 方法将 this 值转换成对象。该方法旨在被派生对象重写，以实现自定义类型转换逻辑。
  • Object.prototype.valueOf()
语法：valueOf() 
function MyNumberType(n) {
  this.number = n
}
MyNumberType.prototype.valueOf = function () {
  return this.number
}
const object1 = new MyNumberType(4)
console.log(object1 + 3)
// output: 7