对象方法

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

// 只返回自有可枚举属性
const obj2 = Object.create({ inherited: true })
obj2.own = 'property'

console.log(Object.keys(obj2))  // ['own']（不包含继承属性）

// 数组的 keys
const arr = ['a', 'b', 'c']
console.log(Object.keys(arr))  // ['0', '1', '2']

// 空对象
console.log(Object.keys({}))  // []

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

// 只返回自有可枚举属性的值
const obj2 = Object.create({ inherited: 'value' })
obj2.own = 'property'

console.log(Object.values(obj2))  // ['property']

// 结合解构使用
const { length } = Object.values(obj)
console.log(length)  // 3

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

// 遍历对象
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`)
}

// 转换对象（键大写，值翻倍）
const transformed = Object.fromEntries(
  Object.entries(obj).map(([key, value]) => [key.toUpperCase(), value * 2])
)
console.log(transformed)  // { A: 2, B: 4, C: 6 }

// 过滤属性
const filtered = Object.fromEntries(
  Object.entries(obj).filter(([key, value]) => value > 1)
)
console.log(filtered)  // { b: 2, c: 3 }

// 从 entries 创建对象
const entries = [['name', 'John'], ['age', 30]]
const obj = Object.fromEntries(entries)
console.log(obj)  // { name: 'John', age: 30 }

// 从 Map 转换
const map = new Map([['name', 'John'], ['age', 30]])
const objFromMap = Object.fromEntries(map)
console.log(objFromMap)  // { name: 'John', age: 30 }

// 对象转换示例：属性名大写
const obj1 = { a: 1, b: 2 }
const upper = Object.fromEntries(
  Object.entries(obj1).map(([k, v]) => [k.toUpperCase(), v])
)
console.log(upper)  // { A: 1, B: 2 }

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

console.log(Object.keys(obj))                     // ['a', 'b']
console.log(Object.getOwnPropertyNames(obj))      // ['a', 'b', 'secret']

const sym1 = Symbol('id')
const sym2 = Symbol('name')

const obj = {
  [sym1]: 123,
  [sym2]: 'John',
  age: 30
}

console.log(Object.keys(obj))                      // ['age']
console.log(Object.getOwnPropertySymbols(obj))     // [Symbol(id), Symbol(name)]

// 获取 Symbol 属性值
obj[Object.getOwnPropertySymbols(obj)[0]]  // 123

const obj = {
  name: 'John',
  [Symbol('id')]: 123
}
Object.defineProperty(obj, 'age', { value: 30, enumerable: false })

console.log(Reflect.ownKeys(obj))  // ['name', 'age', Symbol(id)]

// 等价于
const allKeys = [
  ...Object.getOwnPropertyNames(obj),
  ...Object.getOwnPropertySymbols(obj)
]

const obj = {}

// 定义数据属性
Object.defineProperty(obj, 'name', {
  value: 'John',
  writable: false,      // 不可写
  enumerable: true,     // 可枚举
  configurable: true    // 可配置
})

obj.name = 'Jane'  // 无效（严格模式报错）
console.log(obj.name)  // 'John'

// 定义访问器属性
let _age = 0
Object.defineProperty(obj, 'age', {
  get() {
    console.log('读取 age')
    return _age
  },
  set(value) {
    console.log('设置 age:', value)
    _age = value
  },
  enumerable: true,
  configurable: true
})

obj.age = 30  // 设置 age: 30
console.log(obj.age)  // 读取 age \n 30

// 使用 defineProperty 时，默认值为 false
Object.defineProperty(obj, 'key', {})
// 等价于
Object.defineProperty(obj, 'key', {
  value: undefined,
  writable: false,
  enumerable: false,
  configurable: false
})

// 使用字面量创建时，默认值为 true
const obj2 = { key: 'value' }
// 等价于
// { value: 'value', writable: true, enumerable: true, configurable: true }

const obj = {}

Object.defineProperties(obj, {
  name: {
    value: 'John',
    writable: true,
    enumerable: true
  },
  age: {
    value: 30,
    writable: false,
    enumerable: true
  },
  info: {
    get() {
      return `${this.name}, ${this.age} years old`
    },
    enumerable: true
  }
})

console.log(obj.name)  // 'John'
console.log(obj.info)  // 'John, 30 years old'

const obj = { name: 'John' }

const descriptor = Object.getOwnPropertyDescriptor(obj, 'name')
console.log(descriptor)
// {
//   value: 'John',
//   writable: true,
//   enumerable: true,
//   configurable: true
// }

// 访问器属性
Object.defineProperty(obj, 'fullName', {
  get() { return 'John Doe' }
})

const accessorDesc = Object.getOwnPropertyDescriptor(obj, 'fullName')
console.log(accessorDesc)
// {
//   get: [Function: get],
//   set: undefined,
//   enumerable: false,
//   configurable: false
// }

const obj = { name: 'John', age: 30 }

const descriptors = Object.getOwnPropertyDescriptors(obj)
console.log(descriptors)
// {
//   name: { value: 'John', writable: true, enumerable: true, configurable: true },
//   age: { value: 30, writable: true, enumerable: true, configurable: true }
// }

// 用于精确复制对象（包括 getter/setter）
const clone = Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
)

// 创建指定原型的对象
const proto = {
  sayHello() {
    console.log('Hello!')
  },
  greet() {
    console.log('Hi, I am ' + this.name)
  }
}

const obj = Object.create(proto)
obj.name = 'John'

  // ... 中间省略 ...

console.log(pureObj.toString)  // undefined（无继承方法）
console.log(pureObj instanceof Object)  // false

// 创建普通对象（默认原型）
const normalObj = Object.create(Object.prototype)
// 等价于 const normalObj = {}

const obj = {}
console.log(Object.getPrototypeOf(obj) === Object.prototype)  // true

const arr = []
console.log(Object.getPrototypeOf(arr) === Array.prototype)  // true

const obj2 = Object.create(null)
console.log(Object.getPrototypeOf(obj2))  // null

// 获取构造函数的原型
function Person(name) {
  this.name = name
}
const person = new Person('John')
console.log(Object.getPrototypeOf(person) === Person.prototype)  // true

const obj = {}
const proto = { 
  sayHello() { 
    console.log('Hello!') 
  }
}

Object.setPrototypeOf(obj, proto)
obj.sayHello()  // 'Hello!'

console.log(Object.getPrototypeOf(obj) === proto)  // true

// ❌ 不推荐
const obj = {}
Object.setPrototypeOf(obj, proto)

// ✅ 推荐
const obj = Object.create(proto)

// 合并对象
const target = { a: 1 }
const source = { b: 2, c: 3 }

const result = Object.assign(target, source)
console.log(result)  // { a: 1, b: 2, c: 3 }
console.log(result === target)  // true（修改原对象）

// 浅拷贝
const original = { a: 1, b: { c: 2 } }
const copy = Object.assign({}, original)
copy.b.c = 3
console.log(original.b.c)  // 3（浅拷贝，嵌套对象引用相同）

// 合并多个对象
const merged = Object.assign({}, { a: 1 }, { b: 2 }, { c: 3 })
console.log(merged)  // { a: 1, b: 2, c: 3 }

// 属性覆盖（后者覆盖前者）
const obj1 = { a: 1, b: 2 }
const obj2 = { b: 3, c: 4 }
const result = Object.assign({}, obj1, obj2)
console.log(result)  // { a: 1, b: 3, c: 4 }

// 浅拷贝
const obj = { a: 1, b: 2 }
const copy = { ...obj }
console.log(copy)            // { a: 1, b: 2 }
console.log(copy === obj)    // false（创建新对象）

// 合并对象
const obj1 = { a: 1 }
const obj2 = { b: 2 }
const merged = { ...obj1, ...obj2 }
console.log(merged)  // { a: 1, b: 2 }

// 覆盖属性
const obj3 = { a: 1, b: 2 }
const result = { ...obj3, b: 3, c: 4 }
console.log(result)  // { a: 1, b: 3, c: 4 }

// 条件属性
const hasPermission = true
const config = {
  name: 'John',
  ...(hasPermission && { role: 'admin' })
}
console.log(config)  // { name: 'John', role: 'admin' }

// 移除属性
const { age, ...rest } = { name: 'John', age: 30, city: 'NYC' }
console.log(rest)  // { name: 'John', city: 'NYC' }

const obj = { a: 1, b: 2 }

// Object.assign 修改目标对象
const result1 = Object.assign(obj, { c: 3 })
console.log(obj === result1)  // true（obj 被修改）

// 扩展运算符创建新对象
const result2 = { ...obj, c: 3 }
console.log(obj === result2)  // false（obj 未被修改）

const obj = { name: 'John', age: 30 }

Object.freeze(obj)

// 所有修改操作都无效
obj.name = 'Jane'  // 无效
delete obj.age     // 无效
obj.city = 'NYC'   // 无效

console.log(obj)  // { name: 'John', age: 30 }
console.log(Object.isFrozen(obj))  // true


  // ... 中间省略 ...

  return obj
}

const obj3 = { a: { b: { c: 1 } } }
deepFreeze(obj3)
obj3.a.b.c = 2  // 无效

const obj = { name: 'John' }
console.log(Object.isFrozen(obj))  // false

Object.freeze(obj)
console.log(Object.isFrozen(obj))  // true

// 冻结的对象也是密封和不可扩展的
console.log(Object.isSealed(obj))         // true
console.log(Object.isExtensible(obj))     // false

const obj = { name: 'John', age: 30 }

Object.seal(obj)

obj.name = 'Jane'  // 有效（可修改）
delete obj.age     // 无效（不可删除）
obj.city = 'NYC'   // 无效（不可添加）

console.log(obj)  // { name: 'Jane', age: 30 }
console.log(Object.isSealed(obj))  // true

// 密封对象不可扩展
console.log(Object.isExtensible(obj))  // false

const obj = { name: 'John' }
console.log(Object.isSealed(obj))  // false

Object.seal(obj)
console.log(Object.isSealed(obj))  // true

const obj = { name: 'John' }

Object.preventExtensions(obj)

obj.age = 30       // 无效（不可添加）
obj.name = 'Jane'  // 有效（可修改）
delete obj.name    // 有效（可删除）

console.log(obj)  // {}
console.log(Object.isExtensible(obj))  // false

const obj = { name: 'John' }
console.log(Object.isExtensible(obj))  // true

Object.preventExtensions(obj)
console.log(Object.isExtensible(obj))  // false

// 冻结和密封的对象也是不可扩展的
Object.freeze({})
console.log(Object.isExtensible({}))  // false（已冻结）

// 关系：freeze ⊂ seal ⊂ preventExtensions

// freeze 包含 seal 和 preventExtensions 的限制
Object.freeze(obj)
console.log(Object.isSealed(obj))         // true
console.log(Object.isExtensible(obj))     // false

// seal 包含 preventExtensions 的限制
Object.seal(obj)
console.log(Object.isExtensible(obj))     // false
console.log(Object.isFrozen(obj))         // false

// 与 === 的区别
console.log(NaN === NaN)           // false
console.log(Object.is(NaN, NaN))   // true

console.log(-0 === 0)              // true
console.log(Object.is(-0, 0))      // false

// 其他情况与 === 相同
console.log(Object.is('foo', 'foo'))  // true
console.log(Object.is({}, {}))        // false（不同引用）
console.log(Object.is(null, null))    // true
console.log(Object.is(undefined, undefined))  // true

// 对象比较（引用比较）
const obj = { a: 1 }
console.log(Object.is(obj, obj))   // true
console.log(Object.is(obj, { a: 1 }))  // false

const obj = { name: 'John' }

console.log(Object.hasOwn(obj, 'name'))      // true
console.log(Object.hasOwn(obj, 'toString'))  // false（继承属性）

// 比 hasOwnProperty 更安全
const obj2 = Object.create(null)  // 无原型对象
obj2.name = 'John'

// obj2.hasOwnProperty('name')  // TypeError: obj2.hasOwnProperty is not a function
console.log(Object.hasOwn(obj2, 'name'))  // true

// 属性值为 undefined 时仍返回 true
obj2.age = undefined
console.log(Object.hasOwn(obj2, 'age'))  // true

const obj = { name: 'John' }

console.log(obj.hasOwnProperty('name'))      // true
console.log(obj.hasOwnProperty('toString'))  // false（继承属性）

// 注意：可能被覆盖
const obj2 = {
  name: 'John',
  hasOwnProperty: () => false
}

console.log(obj2.hasOwnProperty('name'))  // false（被覆盖）

// 安全调用方式
console.log(Object.prototype.hasOwnProperty.call(obj2, 'name'))  // true

// 或使用 Object.hasOwn()（推荐）
console.log(Object.hasOwn(obj2, 'name'))  // true

const obj = { name: 'John' }
Object.defineProperty(obj, 'age', { 
  value: 30, 
  enumerable: false 
})

console.log(obj.propertyIsEnumerable('name'))  // true
console.log(obj.propertyIsEnumerable('age'))   // false

// 继承属性
console.log(obj.propertyIsEnumerable('toString'))  // false

const proto = { sayHello() { console.log('Hello!') } }
const obj = Object.create(proto)

console.log(proto.isPrototypeOf(obj))            // true
console.log(Object.prototype.isPrototypeOf(obj)) // true

// 检查原型链
function Animal() {}
function Dog() {}
Dog.prototype = Object.create(Animal.prototype)

const dog = new Dog()
console.log(Animal.prototype.isPrototypeOf(dog))  // true
console.log(Object.prototype.isPrototypeOf(dog))  // true

const obj = { name: 'John' }
console.log(obj.toString())  // '[object Object]'

// 自定义 toString
const person = {
  name: 'John',
  age: 30,
  toString() {
    return `Person: ${this.name}, ${this.age} years old`
  }
}


  // ... 中间省略 ...

  return Object.prototype.toString.call(value).slice(8, -1)
}

console.log(getType([]))        // 'Array'
console.log(getType(null))      // 'Null'
console.log(getType(new Map())) // 'Map'

const obj = { name: 'John', age: 30 }
console.log(obj.toLocaleString())  // '[object Object]'

// 数组的本地化
const arr = [1000, 2000, 3000]
console.log(arr.toLocaleString())  // '1,000,2,000,3,000'（根据地区）

// 日期的本地化
const date = new Date('2024-01-01')
console.log(date.toLocaleString())  // '2024/1/1 00:00:00'（根据地区）
console.log(date.toLocaleDateString())  // '2024/1/1'
console.log(date.toLocaleTimeString())  // '00:00:00'

// 数字格式化
const num = 1234567.89
console.log(num.toLocaleString())  // '1,234,567.89'
console.log(num.toLocaleString('zh-CN', { style: 'currency', currency: 'CNY' }))
// '¥1,234,567.89'

const obj = { name: 'John' }
console.log(obj.valueOf())  // { name: 'John' }（返回对象本身）

// 自定义 valueOf
const obj2 = {
  value: 10,
  valueOf() {
    return this.value
  }
}

console.log(obj2 + 5)  // 15（自动调用 valueOf）

// 结合 toString
const obj3 = {
  value: 10,
  valueOf() {
    return this.value
  },
  toString() {
    return `Value: ${this.value}`
  }
}

console.log(obj3 + 5)      // 15（数字上下文，优先 valueOf）
console.log(String(obj3))  // 'Value: 10'（字符串上下文，优先 toString）

// 映射对象的值
function mapObject(obj, mapper) {
  return Object.fromEntries(
    Object.entries(obj).map(([key, value]) => [key, mapper(value, key)])
  )
}

const obj = { a: 1, b: 2, c: 3 }
const doubled = mapObject(obj, value => value * 2)
console.log(doubled)  // { a: 2, b: 4, c: 6 }

const withPrefix = mapObject(obj, (value, key) => `${key}-${value}`)
console.log(withPrefix)  // { a: 'a-1', b: 'b-2', c: 'c-3' }

// 过滤对象的属性
function filterObject(obj, predicate) {
  return Object.fromEntries(
    Object.entries(obj).filter(([key, value]) => predicate(value, key))
  )
}

const obj = { a: 1, b: 2, c: 3, d: 4 }
const evens = filterObject(obj, value => value % 2 === 0)
console.log(evens)  // { b: 2, d: 4 }

// 过滤掉特定键
const excludeKeys = (obj, keys) => 
  filterObject(obj, (_, key) => !keys.includes(key))

const filtered = excludeKeys(obj, ['a', 'c'])
console.log(filtered)  // { b: 2, d: 4 }

// 浅合并
function mergeObjects(...objects) {
  return Object.assign({}, ...objects)
}

const obj1 = { a: 1 }
const obj2 = { b: 2 }
const obj3 = { c: 3 }

console.log(mergeObjects(obj1, obj2, obj3))  // { a: 1, b: 2, c: 3 }

// 深度合并

  // ... 中间省略 ...

}

const obj1 = { a: { b: 1, c: 2 } }
const obj2 = { a: { c: 3, d: 4 }, e: 5 }
const merged = deepMerge({}, obj1, obj2)
console.log(merged)  // { a: { b: 1, c: 3, d: 4 }, e: 5 }

// 简单深拷贝（JSON 方式，有局限）
function deepCloneSimple(obj) {
  return JSON.parse(JSON.stringify(obj))
}
// 局限：无法处理函数、undefined、Symbol、循环引用、Date、RegExp 等

// 完整深拷贝
function deepClone(obj, hash = new WeakMap()) {
  // null 或非对象类型
  if (obj === null || typeof obj !== 'object') return obj
  
  // 处理循环引用

  // ... 中间省略 ...

}

// 使用 structuredClone（现代浏览器，推荐）
const obj = { a: 1, b: { c: 2 }, date: new Date() }
const clone = structuredClone(obj)
console.log(clone)  // { a: 1, b: { c: 2 }, date: Date }

// 根据路径获取值
function getValueByPath(obj, path, defaultValue = undefined) {
  const keys = path.split('.')
  let result = obj
  
  for (const key of keys) {
    if (result === null || result === undefined) {
      return defaultValue
    }
    result = result[key]
  }
  

  // ... 中间省略 ...

  target[lastKey] = value
  return obj
}

setValueByPath(obj, 'user.profile.city', 'NYC')
console.log(obj.user.profile.city)  // 'NYC'

// 扁平化对象
function flatten(obj, prefix = '', result = {}) {
  for (const [key, value] of Object.entries(obj)) {
    const newKey = prefix ? `${prefix}.${key}` : key
    
    if (value && typeof value === 'object' && !Array.isArray(value)) {
      flatten(value, newKey, result)
    } else {
      result[newKey] = value
    }
  }
  

  // ... 中间省略 ...

  
  return result
}

const flat = { 'a.b.c': 1, 'a.b.d': 2, 'a.e': 3 }
console.log(unflatten(flat))  // { a: { b: { c: 1, d: 2 }, e: 3 } }

// ❌ 避免
if (obj.property) { }  // 值为 falsy 时误判

// ✅ 推荐
if ('property' in obj) { }              // 检查原型链
if (obj.hasOwnProperty('property')) { } // 只检查自有属性
if (Object.hasOwn(obj, 'property')) { } // ES2022，推荐

// ✅ 安全访问深层属性
const value = obj?.nested?.property ?? 'default'

// ❌ 避免 for...in（会遍历原型链）
for (const key in obj) {
  console.log(key)
}

// ✅ 使用 Object.keys()
Object.keys(obj).forEach(key => {
  console.log(key, obj[key])
})

// ✅ 使用 Object.entries()
for (const [key, value] of Object.entries(obj)) {
  console.log(key, value)
}

// ✅ 需要遍历包括不可枚举属性时
Reflect.ownKeys(obj).forEach(key => {
  console.log(key, obj[key])
})

// ❌ 修改原对象
Object.assign(obj, { a: 1 })

// ✅ 创建新对象（不可变）
const newObj = { ...obj, a: 1 }

// ✅ 深度合并使用库或自定义函数
// lodash.merge({}, obj1, obj2)

// ✅ 配置对象使用 Object.freeze()
const CONFIG = Object.freeze({
  API_URL: 'https://api.example.com',
  TIMEOUT: 5000
})

// ✅ 类内部属性使用 Symbol 或 WeakMap
const privateData = new WeakMap()

class Person {
  constructor(name, secret) {
    this.name = name
    privateData.set(this, { secret })
  }
}

// ❌ 避免使用 typeof 判断对象类型
typeof {}           // 'object'
typeof []           // 'object'
typeof null         // 'object'
typeof new Date()   // 'object'

// ✅ 使用 Object.prototype.toString
function getType(value) {
  return Object.prototype.toString.call(value).slice(8, -1)
}

getType({})         // 'Object'
getType([])         // 'Array'
getType(null)       // 'Null'
getType(new Date()) // 'Date'

// ✅ 使用 Array.isArray 判断数组
Array.isArray([])   // true
Array.isArray({})   // false

const obj = { a: 1, b: 2 }
Object.setPrototypeOf(obj, { c: 3 })

// for...in 遍历原型链
for (const key in obj) {
  console.log(key)  // 'a', 'b', 'c'
}

// Object.keys() 只返回自有可枚举属性
console.log(Object.keys(obj))  // ['a', 'b']

const obj = {}

// 方法1：Object.keys()
console.log(Object.keys(obj).length === 0)  // true

// 方法2：Reflect.ownKeys()（包含 Symbol）
console.log(Reflect.ownKeys(obj).length === 0)  // true

// 方法3：for...in
function isEmpty(obj) {
  for (const key in obj) {
    if (Object.hasOwn(obj, key)) {
      return false
    }
  }
  return true
}

// 方法4：JSON.stringify()
console.log(JSON.stringify(obj) === '{}')  // true（简单但有局限）

// 方法1：structuredClone（现代浏览器，推荐）
const clone = structuredClone(obj)

// 方法2：JSON（简单但有局限）
const clone = JSON.parse(JSON.stringify(obj))

// 方法3：递归实现（完整版见上文"深度拷贝"部分）
const clone = deepClone(obj)

// 方法4：使用库
// import { cloneDeep } from 'lodash'
// const clone = cloneDeep(obj)

const obj = { a: 1 }

// Object.assign：修改目标对象
const result1 = Object.assign(obj, { b: 2 })
console.log(obj === result1)  // true（obj 被修改）

// 扩展运算符：创建新对象
const result2 = { ...obj, c: 3 }
console.log(obj === result2)  // false（obj 未被修改）

// 推荐使用扩展运算符，更符合函数式编程原则

const obj1 = { a: 1, b: 2 }
const obj2 = { b: 3, c: 4 }

// 简单合并（后者覆盖前者）
const merged = { ...obj1, ...obj2 }
console.log(merged)  // { a: 1, b: 3, c: 4 }

// 自定义合并策略
function mergeWithStrategy(obj1, obj2, strategy) {
  const result = { ...obj1 }
  
  for (const [key, value] of Object.entries(obj2)) {
    if (key in result) {
      result[key] = strategy(result[key], value, key)
    } else {
      result[key] = value
    }
  }
  
  return result
}

// 数组值合并
const obj3 = { tags: ['js'] }
const obj4 = { tags: ['ts'] }
const merged = mergeWithStrategy(obj3, obj4, (v1, v2) => [...v1, ...v2])
console.log(merged)  // { tags: ['js', 'ts'] }

const user = {
  profile: {
    address: {
      city: 'NYC'
    }
  }
}

// ❌ 传统方式（冗长）
const city = user && user.profile && user.profile.address && user.profile.address.city

// ✅ 可选链操作符（ES2020）
const city = user?.profile?.address?.city  // 'NYC'
const country = user?.profile?.address?.country  // undefined

// ✅ 结合空值合并运算符
const city = user?.profile?.address?.city ?? 'Unknown'  // 'NYC'

// ✅ 使用工具函数（见上文"对象路径访问"部分）
const city = getValueByPath(user, 'profile.address.city', 'Unknown')