JavaScript的Object.assign方法是什么？如何使用？

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const mergedObj = Object.assign({}, obj1, obj2);
console.log(mergedObj); // { a: 1, b: 3, c: 4 }
// 注意：b的值被obj2覆盖了

const user = { name: '张三', age: 25 };
const updates = { age: 26, city: '北京' };
Object.assign(user, updates);
console.log(user); // { name: '张三', age: 26, city: '北京' }
// user对象本身被修改了

let num = 123;
let result = Object.assign(num, { a: 1 });
console.log(result); // [Number: 123] (一个Number对象，但并没有复制属性，因为num作为目标时会被包装，但复制操作本身不会改变原始值)

const sourceNull = null;
const sourceUndefined = undefined;
const obj = {};
Object.assign(obj, sourceNull, { x: 1 }, sourceUndefined, { y: 2 });
console.log(obj); // { x: 1, y: 2 }
// null和undefined源被忽略了

const original = {
  name: 'Alice',
  info: { age: 30, city: 'New York' },
  hobbies: ['reading', 'coding']
};

const copied = Object.assign({}, original);

console.log(copied);
// {
//   name: 'Alice',
//   info: { age: 30, city: 'New York' },
//   hobbies: ['reading', 'coding']
// }

// 现在，我们尝试修改copied对象中的嵌套属性
copied.name = 'Bob'; // 原始类型，互不影响
copied.info.age = 31; // 引用类型，修改会影响original
copied.hobbies.push('hiking'); // 引用类型，修改会影响original

console.log('--- 修改后 ---');
console.log('Original:', original);
// Original: {
//   name: 'Alice',
//   info: { age: 31, city: 'New York' }, // 注意：age被修改了
//   hobbies: ['reading', 'coding', 'hiking'] // 注意：hiking被添加了
// }
console.log('Copied:', copied);
// Copied: {
//   name: 'Bob',
//   info: { age: 31, city: 'New York' },
//   hobbies: ['reading', 'coding', 'hiking']
// }

const originalUser = { name: 'Alice', age: 30 };
const clonedUser = Object.assign({}, originalUser);

clonedUser.age = 31; // 修改克隆对象
console.log(originalUser.age); // 30 (原始对象未受影响)
console.log(clonedUser.age); // 31

function processConfig(options) {
  const defaultOptions = {
    timeout: 5000,
    retries: 3,
    debugMode: false
  };
  // 将传入的options合并到defaultOptions上，如果options有同名属性，会覆盖默认值
  const finalConfig = Object.assign({}, defaultOptions, options);
  // 或者直接修改传入的options对象（如果允许）
  // Object.assign(options, defaultOptions); // 这样会把defaultOptions的属性合并到options上，但如果options有同名属性，options的会保留
  // 如果是希望options覆盖defaultOptions，那么顺序是 Object.assign({}, defaultOptions, options)
  // 如果是希望defaultOptions作为兜底，传入的options优先，那么顺序是 Object.assign({}, options, defaultOptions)
  // 个人经验，一般是传入的options优先，所以是 Object.assign({}, defaultOptions, options)
  console.log(finalConfig);
}

processConfig({ retries: 5, debugMode: true });
// { timeout: 5000, retries: 5, debugMode: true }

processConfig({});
// { timeout: 5000, retries: 3, debugMode: false }

const canWalk = {
  walk() {
    console.log('I can walk!');
  }
};

const canFly = {
  fly() {
    console.log('I can fly!');
  }
};

class Bird {
  constructor(name) {
    this.name = name;
  }
}

// 将canWalk和canFly的属性混入到Bird的原型上
Object.assign(Bird.prototype, canWalk, canFly);

const myBird = new Bird('Sparrow');
myBird.walk(); // I can walk!
myBird.fly(); // I can fly!

// 展开运算符的例子
const objA = { x: 1 };
const objB = { y: 2 };
const mergedWithSpread = { ...objA, ...objB }; // { x: 1, y: 2 }

// Object.assign 也能做到
const mergedWithAssign = Object.assign({}, objA, objB); // { x: 1, y: 2 }

const proto = { protoProp: 'I am from prototype' };
const source = Object.create(proto);
source.ownProp = 'I am own';
Object.defineProperty(source, 'hiddenProp', {
  value: 'I am not enumerable',
  enumerable: false
});

const target = {};
Object.assign(target, source);
console.log(target); // { ownProp: 'I am own' }
// protoProp 和 hiddenProp 都没有被复制

const sourceWithAccessor = {
  _value: 10,
  get value() {
    console.log('Getter called!');
    return this._value * 2;
  },
  set value(v) {
    console.log('Setter called!');
    this._value = v;
  }
};

const target = {};
Object.assign(target, sourceWithAccessor);

console.log(target); // { _value: 10, value: 20 }
// 注意：target.value 是 20，而不是一个getter函数。
// 并且在复制过程中，getter被调用了。
// target现在没有了setter，直接给target.value赋值会覆盖掉它，而不是触发原始的setter逻辑。
target.value = 50; // 这只是一个普通的赋值操作，不会触发原始sourceWithAccessor的setter
console.log(target.value); // 50

const result = Object.assign(123, { a: 1 });
console.log(result); // [Number: 123]
console.log(typeof result); // object
console.log(result.a); // 1

const obj = {};
Object.assign(obj, null, { a: 1 }, undefined, { b: 2 });
console.log(obj); // { a: 1, b: 2 }

const defaults = { color: 'red', size: 'medium' };
const userPrefs = { size: 'large' };
const finalSettings = Object.assign({}, defaults, userPrefs);
console.log(finalSettings); // { color: 'red', size: 'large' }
// size 被 userPrefs 覆盖了