重学js —— 基本对象：普通对象(Object构造器上的属性一)

[lizhongzhen11]

基本对象：普通对象(Object构造器上的属性一)

• MDN —— Object

对象构造器

• 对应固有对象 %Object%
• 全局对象 Object 属性的初始值
• 当被用作 构造器 调用时创建一个新的 普通对象
• 当作为函数而不是 构造器 调用时，执行类型转换功能
• 可以被继承： class ExtendObject extends Object{}

Object( [ value ] )

1. 如果 NewTarget 既不是 undefined 也不是活动的函数，
   1. 返回 ? OrdinaryCreateFromConstructor(NewTarget, "%Object.prototype%")
2. 如果 value 为 undefined 或 null，返回 OrdinaryObjectCreate(%Object.prototype%)
3. 返回 ! ToObject(value)

Object 函数的 length 属性值为 1。

Object 构造器属性

• MDN —— Object 构造函数的方法

• 有 [[Prototype]] 内置插槽，其值为 %Function.prototype%

• 有 length 属性

• 有以下额外的属性：

Object.assign ( target, ...sources )

• MDN

const obj1 = { a: 1 }
const obj2 = Object.assign({}, obj1)
obj2 === obj1 // false

const obj3 = { a: { b : 'b'} }
const obj4 = Object.assign({}, obj3)
obj4 === obj3 // false
obj3.a.b = 'bb'
obj4.a.b // 'bb'

一个对象，其所有键值都是基本数据类型的话，Object.assign 可以当做深拷贝来用；但是如果某个键值是对象的话，那么 Object.assign 只能作为浅拷贝。

1. 定义 to 为 ? ToObject(target)
2. 如果只传了一个参数过来，返回 to
3. 定义 sources 为从第二个参数开始的参数值 列表
4. 遍历 sources 中的每个元素 nextSource，升序排列
   1. 如果 nextSource 既不是 undefined 又不是 null，
      1. 定义 from 为 ! ToObject(nextSource)
      2. 定义 keys 为 ? from.[[OwnPropertyKeys]]()
      3. 按 列表 顺序遍历 keys 中的每个元素 nextKey，
         1. 定义 desc 为 ? from.[[GetOwnProperty]](nextKey)
         2. 如果 desc 不是 undefined 且 desc.[[Enumerable]] 为 true，
            1. 定义 propValue 为 ? Get(from, nextKey)
            2. 执行 ? Set(to, nextKey, propValue, true)
5. 返回 to

该函数 length 属性值为2

Object.create ( O, Properties )

• MDN

// 注意第二个参数 Properties，
// 不熟悉的人会误以为和 Object.assign 一样，
// 其实不同，第二个参数是大对象，键值为属性描述符
Object.create (null, {
  a: {
    value: 'a'
  }
})

1. 如果 O 类型既不是 Object 又不是 Null，抛 TypeError 异常
2. 定义 obj 为 OrdinaryObjectCreate(O)
3. 如果 Properties 不是 undefined，
   1. 返回 ? ObjectDefineProperties(obj, Properties)
4. 返回 obj

Object.defineProperties ( O, Properties )

• MDN

Object.defineProperties({}, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
  // etc. etc.
});

1. 返回 ? ObjectDefineProperties(O, Properties)

ObjectDefineProperties( O, Properties )

1. 如果 O 类型不是 Object，抛 TypeError 异常
2. 定义 props 为 ? ToObject(Properties)
3. 定义 keys 为 ? props.[[OwnPropertyKeys]]()
4. 定义 descriptors 为新的空 List
5. 按顺序遍历 keys 中每个元素 nextKey，
   1. 定义 propDesc 为 ? props.[[GetOwnProperty]](nextKey)
   2. 如果 propDesc 不是 undefined 且 propDesc.[[Enumerable]] 为 true，
      1. 定义 descObj 为 ? Get(props, nextKey)
      2. 定义 desc 为 ? ToPropertyDescriptor(descObj)
      3. 向 descriptors 末尾添加 nextKey 和 desc 组成的对（包含两个元素的 List）
6. 按顺序遍历 descriptors 中的 pair，
   1. 定义 P 为 pair 中第一个元素
   2. 定义 desc 为 pair 中第二个元素
   3. 执行 ? DefinePropertyOrThrow(O, P, desc)
7. 返回 O

Object.defineProperty ( O, P, Attributes )

• MDN

注意和 Object.defineProperties 区别

Object.defineProperty({}, 'property1', {
  value: 42,
  writable: false
});

1. 如果 O 类型不是 Object，抛 TypeError 异常
2. 定义 key 为 ? ToPropertyKey(P)
3. 定义 desc 为 ? ToPropertyDescriptor(Attributes)
4. 执行 ? DefinePropertyOrThrow(O, key, desc)
5. 返回 O

Object.entries ( O )

• MDN

1. 定义 obj 为 ? ToObject(O)
2. 定义 nameList 为 ? EnumerableOwnPropertyNames(obj, key+value)
3. 返回 CreateArrayFromList(nameList)

Object.freeze ( O )

• MDN
• 重学js —— Operations on Objects and Operations on Iterator Objects

1. 如果 O 类型不是 Object，返回 O
2. 定义 status 为 ? SetIntegrityLevel(O, frozen)
3. 如果 status 为 false，抛 TypeError 异常
4. 返回 O

Object.fromEntries ( iterable )

• MDN

1. 执行 ? RequireObjectCoercible(iterable)
2. 定义 obj 为 OrdinaryObjectCreate(%Object.prototype%)
3. 断言：obj 是一个可扩展的且没有自己属性的 普通对象
4. 定义 stepsDefine 为 CreateDataPropertyOnObject Functions 中定义的算法步骤
5. 定义 adder 为 ! CreateBuiltinFunction(stepsDefine, « »)
6. 返回 ? AddEntriesFromIterable(obj, iterable, adder)

注意：为 adder 创建的函数不能被ECMAScript代码直接访问

CreateDataPropertyOnObject Functions

• 伴有参数 key 和 value

1. 定义 O 为 this 的值
2. 断言：O 是对象类型
3. 断言：O 是可扩展的 普通对象
4. 定义 propertyKey 为 ? ToPropertyKey(key)
5. 返回 ! CreateDataPropertyOrThrow(O, propertyKey, value)
6. 返回 undefined

篇幅过长，见下一篇

2020-07-29 补充

来自高级前端面试小程序第19题

var a = {}, b = '123', c = 123;
a[b] = 'b';
a[c] = 'c';
console.log(a[b]) // 'c'

// ------------------

var a = {}, b = Symbol('123'), c= Symbol('123');
a[b] = 'b';
a[c] = 'c';
console.log(a[b]) // 'b'

// ------------------

var a = {}; b = {key: '123'}, c = {key: '456'};
a[b] = 'b';
a[c] = 'c';
console.log(a[b]) // 'c'

我错在第三个，对象键名都能错！！！对象键名除了 String 就是 Symbol，其它都会默认转成 String ！！！详见 ToPropertyKey

这个问题说明我虽然写了《重学js》，但是不认真！