// 创建对象的方式
const obj = {}                    // 字面量
const obj2 = new Object()         // 构造函数
const obj3 = Object.create(null)  // 创建无原型对象

class MyClass extends Object {
  constructor() {
    super()
  }
}

// 作为函数：类型转换
Object(5)        // Number {5}
Object("hello")  // String {"hello"}
Object(true)     // Boolean {true}
Object(null)     // TypeError (规范规定)
Object(undefined) // TypeError (规范规定)

// 作为构造函数：创建新对象
new Object()     // {}
new Object(5)    // Number {5}

// 创建空对象，指定原型为 null（无原型对象）
const obj = Object.create(null)  // 干净的对象，没有 toString 等方法

// 创建对象并设置原型
const proto = { greet() { return 'hi' } }
const child = Object.create(proto)
child.greet()  // 'hi'

// 同时设置属性
const obj = Object.create({}, {
  name: { value: 'John', writable: true, enumerable: true, configurable: true },
  age: { value: 30 }
})

// 浅拷贝
const target = { a: 1 }
const source = { b: 2, c: 3 }
Object.assign(target, source)  // { a: 1, b: 2, c: 3 }

// 合并多个对象
const merged = Object.assign({}, { a: 1 }, { b: 2 }, { a: 3 })
// { a: 3, b: 2 } 后面覆盖前面

// 复制数组（会转为对象索引）
Object.assign([], { 0: 'a', 1: 'b' })  // ['a', 'b']

// 从二维数组
Object.fromEntries([['a', 1], ['b', 2]])  // { a: 1, b: 2 }

// 从 Map
const map = new Map([['a', 1], ['b', 2]])
Object.fromEntries(map)  // { a: 1, b: 2 }

// 配合 Object.entries 使用
const obj = { a: 1, b: 2 }
Object.fromEntries(
  Object.entries(obj).map(([k, v]) => [k, v * 2])
)  // { a: 2, b: 4 }

// 对象深拷贝（简单实现）
const deepClone = obj => Object.fromEntries(
  Object.entries(obj).map(([k, v]) =>
    [k, typeof v === 'object' && v ? deepClone(v) : v]
  )
)

const obj = {}

// 定义数据属性
Object.defineProperty(obj, 'name', {
  value: 'John',
  writable: false,     // 不可修改
  enumerable: false,    // 不可枚举（不在 for...in 中）
  configurable: false  // 不可删除/重新定义
})

// 定义访问器属性
let _age = 30
Object.defineProperty(obj, 'age', {
  get() { return _age },
  set(v) { _age = v },
  enumerable: true,
  configurable: true
})

Object.defineProperties(obj, {
  name: { value: 'John', enumerable: true },
  age: {
    get() { return this._age },
    set(v) { this._age = v }
  }
})

const obj = { name: 'John' }

Object.getOwnPropertyDescriptor(obj, 'name')
// { value: 'John', writable: true, enumerable: true, configurable: true }

// 访问器属性
let _age = 30
Object.defineProperty(obj, 'age', { get: () => _age })
Object.getOwnPropertyDescriptor(obj, 'age')
// { get: [Function: get], set: [Function: set], enumerable: false, configurable: false }

const obj = { a: 1 }
Object.getOwnPropertyDescriptors(obj)
// { a: { value: 1, writable: true, enumerable: true, configurable: true } }

const clone = Object.defineProperties({}, Object.getOwnPropertyDescriptors(obj))

const obj = { a: 1, b: 2 }
Object.defineProperty(obj, 'hidden', { value: 'secret', enumerable: false })

Object.getOwnPropertyNames(obj)  // ['a', 'b', 'hidden']

const sym = Symbol('mySymbol')
const obj = { [sym]: 'value', a: 1 }

Object.getOwnPropertySymbols(obj)  // [Symbol(mySymbol)]

const proto = { method() {} }
const obj = Object.create(proto)

Object.getPrototypeOf(obj) === proto  // true
Object.getPrototypeOf({})              // Object.prototype
Object.getPrototypeOf([])              // Array.prototype

const proto = { method() {} }
const obj = {}

// 旧方式（不推荐，影响性能）
Object.setPrototypeOf(obj, proto)

// 现代更推荐：Object.create 方式创建时指定原型
const obj2 = Object.create(proto)

const obj = { a: 1, b: 2 }
Object.defineProperty(obj, 'c', { value: 3, enumerable: false })

Object.keys(obj)  // ['a', 'b']

const obj = { a: 1, b: 2, c: 3 }
Object.values(obj)  // [1, 2, 3]

const obj = { a: 1, b: 2 }
Object.entries(obj)  // [['a', 1], ['b', 2]]

// 转为 Map
new Map(Object.entries(obj))  // Map { 'a' => 1, 'b' => 2 }

const proto = { inherited: 1 }
const obj = Object.create(proto)
obj.own = 2

obj.hasOwnProperty('inherited')  // false
Object.hasOwn(obj, 'inherited')  // false (更安全，不依赖原型链)

obj.hasOwnProperty('own')        // true
Object.hasOwn(obj, 'own')        // true

const obj = { hasOwnProperty: 'oops' }
// obj.hasOwnProperty('x')  // TypeError!
Object.hasOwn(obj, 'x')          // 正确

Object.is(5, 5)           // true
Object.is(5, '5')         // false
Object.is(NaN, NaN)       // true  (=== 返回 false!)
Object.is(0, -0)          // false (=== 返回 true!)
Object.is(+0, -0)         // false

// === 的问题
NaN === NaN               // false
0 === -0                  // true

const obj = { a: 1 }
Object.freeze(obj)

obj.a = 2        // 静默失败（非严格模式）或 TypeError（严格模式）
obj.b = 3        // 同上
delete obj.a     // 同上

Object.isFrozen(obj)  // true

// 冻结配置对象
const config = Object.freeze({
  apiUrl: 'https://api.example.com',
  maxRetries: 3
})

// 冻结数组
const arr = Object.freeze([1, 2, 3])
// arr.push(4)  // TypeError

const obj = { a: 1 }
Object.seal(obj)

obj.a = 2        // 可以
obj.b = 3        // 不行
delete obj.a     // 不行

Object.isSealed(obj)  // true

const obj = { a: 1 }
Object.preventExtensions(obj)

obj.b = 2        // 不行
obj.a = 2        // 可以
delete obj.a     // 可以

Object.isExtensible(obj)  // false

const obj = {}
Object.isExtensible(obj)  // true
Object.isSealed(obj)      // false
Object.isFrozen(obj)      // false

Object.freeze(obj)
Object.isFrozen(obj)      // true
Object.isSealed(obj)      // true
Object.isExtensible(obj)  // false

const arr = [1, 2, 3, 4, 5, 6]

Object.groupBy(arr, x => x % 2 === 0 ? 'even' : 'odd')
// { even: [2, 4, 6], odd: [1, 3, 5] }

Object.groupBy(['apple', 'banana', 'cherry'], s => s.length)
// { 5: ['apple'], 6: ['banana', 'cherry'] }

const obj = { a: 1 }
obj.hasOwnProperty('a')   // true
obj.hasOwnProperty('toString')  // false (继承自原型)

const proto = { a: 1 }
const child = Object.create(proto)

proto.isPrototypeOf(child)     // true
Object.prototype.isPrototypeOf(child)  // true
({}).isPrototypeOf(child)      // false

const obj = { a: 1 }
Object.defineProperty(obj, 'b', { value: 2, enumerable: false })

obj.propertyIsEnumerable('a')  // true
obj.propertyIsEnumerable('b')  // false

({}).toString()              // "[object Object]"
([1, 2]).toString()          // "1,2"
(function(){}).toString()     // "function (){}"
(new Date()).toString()       // "Tue Mar 03 2026 ..."

// 判断类型（古老但有用）
Object.prototype.toString.call([])   // "[object Array]"
Object.prototype.toString.call({})   // "[object Object]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(undefined) // "[object Undefined]"

// 自定义类的 toString
class Person {
  constructor(name) { this.name = name }
  toString() { return this.name }
}
new Person('John').toString()  // "John"

new Number(5).valueOf()   // 5
new String('hi').valueOf() // "hi"
new Date().valueOf()      // 1706745600000 (时间戳)

// 默认返回 toString
({}).toLocaleString()  // "[object Object]"

// Array 有自己的实现
[1, 2, 3].toLocaleString()  // "1, 2, 3" (逗号可能因地区不同)

// Date 有自己的实现
new Date().toLocaleString()  // "2026/3/3 下午4:30:00"

const proto = { method() {} }
const obj = {}

// 获取
obj.__proto__ === Object.prototype  // true

// 设置（不推荐）
obj.__proto__ = proto
obj.method()  // 现在可以调用了

obj.__defineGetter__('age', function() { return this._age })

// 现代替代
Object.defineProperty(obj, 'age', {
  get() { return this._age }
})

{
  value: 'hello',           // 属性值
  writable: true,           // 是否可修改
  enumerable: true,        // 是否可枚举
  configurable: true       // 是否可删除/重新配置
}

{
  get: function() { return this._name },
  set: function(v) { this._name = v },
  enumerable: true,
  configurable: true
}

// 简单深拷贝
function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj
  if (Array.isArray(obj)) return obj.map(deepClone)
  return Object.fromEntries(
    Object.entries(obj).map(([k, v]) => [k, deepClone(v)])
  )
}

// 使用 structuredClone（现代API）
const clone = structuredClone(original)  // 支持更多类型

class Counter {
  #count = 0  // 私有字段

  get count() {
    return this.#count
  }

  increment() {
    this.#count++
  }
}

const frozen = Object.freeze({
  nested: Object.freeze({ value: 1 })
})
// 嵌套对象也被冻结

const handler = {
  get(target, prop) {
    console.log(`Getting ${prop}`)
    return target[prop]
  },
  set(target, prop, value) {
    console.log(`Setting ${prop} to ${value}`)
    target[prop] = value
  }
}

const proxy = new Proxy({}, handler)