数据类型方法

创建数组

使用数组字面量表示法

var arr1 = []; // 创建一个新数组
var arr2 = [20];

使用 Array 构造函数

• 无参构造

var arr1 = new Array(); // 创建一个空数组

• 带参构造 如果只传一个数值参数，则表示创建一个初始长度为指定数值的空数组

var arr2 = new Array(20); // 创建一个包含20项的数组

如果传入一个非数值的参数或者参数个数大于 1，则表示创建一个包含指定元素的数组。

var arr3 = new Array("lili", "tom", "lucy"); // // 创建一个包含3个字符串的数组
var arr4 = new Array(23);

Array.of 方法创建数组(es6 新增)

Array.of()方法总会创建一个包含所有传入参数的数组，而不管参数的数量与类型。

let arr = Array.of(1, 2);
console.log(arr.length); // 2

let arr1 = Array.of(3);
console.log(arr1.length); // 1
console.log(arr1[0]); // 3

Array.from 方法创建数组(es6 新增)

在 ES6 中，将可迭代对象或者类数组对象作为第一个参数传入，Array.from()就能返回一个数组。

function arga(...args) {
  //...args剩余参数数组,由传递给函数的实际参数提供
  let arg = Array.from(args);
  console.log(arg);
}
arga(arr1, 26, from); // [ arr1 ,26, from ]

数组方法

join()

• join()方法用于把数组中的所有元素转换一个字符串。 元素是通过指定的分隔符进行分隔的。默认使用逗号作为分隔符

var arr = [23, 2, 3];
console.log(arr.join()); // '23', '2', '3'
var arr1 = [23];
console.log(typeof arr1.join()); // string

console.log(arr.join("-")); // 23-2-3
console.log(arr); // 原数组不变

通过 join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串

function repeat(str, n) {
  return new Array(n + 1).join(str); // 一个长度为n+1的空数组用string去拼接成字符串,就成了n个string的重复
}
console.log(repeat(2, 5)); // '22222'
console.log(repeat("li", 6)); // 'lililililili'

push() 和 pop()

push() 方法从数组末尾向数组添加元素，可以添加一个或多个元素，并返回新的长度。
pop() 方法用于删除数组的最后一个元素并返回删除的元素。

var arr = ["lili", "meng", "tian"];
var count = arr.push("aaa", 22222);
console.log(count); // 5
console.log(arr); // [ 'lili', 'meng', 'tian', 'aaa', 22222 ]
var item = arr.pop();
console.log(item); //22222
console.log(arr); // [ 'lili', 'meng', 'tian', 'aaa' ]

shift() 和 unshift()

shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。 unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

var arr = ["lucy", "lili", 22, { foo: "tian" }];
var count = arr.unshift("meng", 999);
console.log(count); // 6
console.log(arr); // [ 'meng', 999, 'lucy', 'lili', 22, { foo: 'tian' } ]
var item = arr.shift();
console.log(item); // 'meng'
console.log(arr); // [ 999, 'lucy', 'lili', 22, { foo: 'tian' } ]

sort()

sort() 方法用于对数组的元素进行排序。 排序顺序可以是字母或数字，并按升序或降序。 默认排序顺序为按字母升序。

var arr1 = ["a", "c", "b", "e", "d"];
console.log(arr1.sort()); //[ 'a', 'b', 'c', 'd', 'e' ]
var arr2 = [23, 6, 99, 43, -1];
console.log(arr2.sort()); //[ -1, 23, 43, 6, 99 ]
console.log(arr2); //[ -1, 23, 43, 6, 99 ]   (原数组被改变)

function sortNumber(a, b) {
  return a - b; //这里返回的是他们的差值，如果是小于0的值，就会将a排在前面，如果大于0,就会将b排在前面，如果是0的话，就随便。（冒泡排序法！！）
}
// 比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。
function compare(num1, num2) {
  if (num1 > num2) {
    return 1;
  } else if (num1 < num2) {
    return -1;
  } else {
    return 0;
  }
}

arr = [2, 65, 3, 54, 6];
console.log(arr.sort(compare)); // [ 2, 3, 6, 54, 65 ]
// 如果需要通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可
function compare(value1, value2) {
  if (value1 < value2) {
    return 1;
  } else if (value1 > value2) {
    return -1;
  } else {
    return 0;
  }
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare)); // [51, 24, 13, 3]

reverse()

reverse() 方法用于颠倒数组中元素的顺序。

var arr = [2, 33, 4, 5, 6];
console.log(arr.reverse()); // [ 6, 5, 4, 33, 2 ]
console.log(arr); // [ 6, 5, 4, 33, 2 ]  (原数组改变)

concat()

concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。

var arr = [1, 3, 57, 8, 9];
var arrCopy = arr.concat(99, [33, 2]);
console.log(arrCopy); // [ 1,  3, 57, 8, 9, 99, 33, 2]
console.log(arr); // [ 1, 3, 57, 8, 9 ] (原数组未被修改)
// 传入的不是数组，则直接把参数添加到数组后面，如果传入的是数组，则将数组中的各个项添加到数组中。
// 如果传入的是二维数组，如下：

var arr2 = arr.concat([9, [555, 666]]);
console.log(arr2); // [ 1, 3, 57, 8, 9, 9, [ 555, 666 ] ]
console.log(arr2[6]); //[ 555, 666 ]

slice()

slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。 slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。

var arr = [1, 3, 5, 7, 9, 10];
// 在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。
var arr1 = arr.slice(1);
console.log(arr1); // [ 3, 5, 7, 9, 10 ]
console.log(arr); // [ 1, 3, 5, 7, 9, 10 ] (原数组不变)
// 如果有两个参数，该方法返回起始和结束位置之间的项，但不包括结束位置的项。
var arr2 = arr.slice(1, 4);
console.log(arr2); //[ 3, 5, 7 ]
// 当出现负数时，将负数加上数组长度的值（length）来替换该位置的数
var arr3 = arr.slice(-3, -1); // 相当于（3，5）
console.log(arr3); // [ 7, 9 ]

splice()

可以实现删除、插入和替换

删除元素,并返回删除的元素

可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。

var arr = [1, 5, 7, 8, 9, 11];
var arr1 = arr.splice(0, 2);
console.log(arr1); //[ 1, 5 ]
console.log(arr); //[ 7, 8, 9, 11 ]

向指定索引处添加元素

可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。

var arr = [1, 5, 7, 8, 9, 11];
var arr2 = arr.splice(1, 0, 99, 88);
console.log(arr); // [1, 99, 88, 5, 7, 8, 9, 11]
console.log(arr2); // []

替换指定索引位置的元素

可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。

var arr = [1, 5, 7, 8, 9, 11];
var arr2 = arr.splice(1, 1, 99, 88);
console.log(arr); // [1, 99, 88, 7, 8, 9, 11]
console.log(arr2); // [5]

indexOf() 和 lastIndexOf()

接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。
indexOf()：从数组的开头（位置 0）开始向后查找。 可返回某个指定的字符串值在字符串中首次出现的位置
lastIndexOf：从数组的末尾开始向前查找。可返回一个指定的字符串值最后出现的位置

这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符。且这俩方法的第二个参数都是规定在字符串中开始检索的位置。它的合法取值是 0 到 string.length - 1。

var arr = [1, 5, 7, 8, 9, 11];
console.log(arr.indexOf(8)); // 3
console.log(arr.lastIndexOf(7)); // 2
console.log(arr.indexOf(7, 2)); // 2  表示从索引2开始向后查找7
console.log(arr.indexOf(7, 3)); // -1  表示从索引3开始向后查找7,找不到返回-1
console.log(arr.lastIndexOf(8, 4)); // 3
console.log(arr.lastIndexOf(8, 2)); // 3 表示从索引2开始向前查找8

forEach() 和 map()

相同点

都是循环遍历数组中的每一项。 每次执行匿名函数都支持三个参数，参数分别为item(当前每一项)，index(索引值)，arr(原数组)。 匿名函数中的this都是指向window。 只能遍历数组。

let arr1 = ['a', 'b', 'c']
arr1.forEach((item,index,arr) =>{
    console.log(item,index,arr);
})
// a 0 [ 'a', 'b', 'c' ]
// b 1 [ 'a', 'b', 'c' ]
// c 2 [ 'a', 'b', 'c' ]

let arr2 = ['a', 'b', 'c']
arr2.map((item,index,arr) =>{
    console.log(item,index,arr);
})
// a 0 [ 'a', 'b', 'c' ]
// b 1 [ 'a', 'b', 'c' ]
// c 2 [ 'a', 'b', 'c' ]

不同点

map()会分配内存空间存储新数组并返回，forEach()不会返回数据。 forEach()允许callback更改原始数组的元素，map()返回新的数组，map() 不会对空数组进行检测。

//forEach
let arr1 = ['a', 'b', 'c']
let _item = arr1.forEach((item,index,arr) =>{
    console.log(item,index,arr);
    return item
})
console.log(_item); // undefined

// map
let arr1 = ['a', 'b', 'c']
let _item = arr1.map((item,index,arr) =>{
    console.log(item,index,arr);
    return item
})
console.log(_item); // [ 'a', 'b', 'c' ]

filter()

“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。

var arr = [1, 2, 3, 4, 5, , 7, 9, 66, 77, 88, 99];
var arr1 = arr.filter(function (x, index) {
  return index % 3 === 0 || x > 9;
});
console.log(arr1); // [1,  4,  7, 66, 77, 88, 99]

fill() es6 新增

fill()方法能使用特定值填充数组中的一个或多个元素。当只是用一个参数时，该方法会用该参数的值填充整个数组。
如果不想改变数组中的所有元素，而只是想改变其中一部分，那么可以使用可选的起始位置参数与结束位置参数（不包括结束位置的那个元素）
3 个参数： 填充数值，起始位置参数，结束位置参数（不包括结束位置的那个元素）

let arr = [1, 2, 3, 4, 666, "lili"];
arr.fill(8);
console.log(arr); // [ 8, 8, 8, 8, 8, 8 ]
arr.fill(8, 3);
console.log(arr); // [ 1, 2, 3, 8, 8, 8 ]
arr.fill(8, 3, 5);
console.log(arr); // [ 1, 2, 3, 8, 8, 'lili' ]

every()

判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回 true。

var arr = [3, 6, 8, 99, 10];
var arr1 = arr.every(function (x) {
  return x > 6;
});
console.log(arr1); // false
var arr2 = arr.every(function (y) {
  return y < 100;
});
console.log(arr2); // true

some()

判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回 true。

var arr = [1, 3, 4, 5, 7];
var arr1 = arr.some(function (x) {
  return x > 6;
});
console.log(arr1); // true
var arr2 = arr.some(function (y) {
  return y < 0;
});
console.log(arr2); // false

includes()

用来判断一个数组是否包含一个指定的值，如果是返回 true，否则 false。 参数有两个，其中第一个是（必填）需要查找的元素值，第二个是（可选）开始查找元素的位置

let arr = [3,6,56,45,99]
let arr1 = arr.includes(6)
console.log(arr1); // true
let arr2 = arr.includes(3, 1)
console.log(arr2); // false

includes使用===运算符来进行值比较，仅有一个例外：NaN 被认为与自身相等。

let arr = [5,NaN,10,11]
console.log(arr.indexOf(NaN)); // -1
console.log(arr.includes(NaN)); // true

reduce() 和 reduceRight()

这两个方法都会实现迭代数组的所有项(即累加器)，然后构建一个最终返回的值。 reduce()方法从数组的第一项开始，逐个遍历到最后。 reduceRight()则从数组的最后一项开始，向前遍历到第一项。 这两个方法都接收两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。 传给这两个方法的函数接收四个参数：前一个值、当前值、项的索引和数组对象

let arr = [1,2,3,4,5,6]
// 只传一个函数，不设置归并初始值
var sum1 = arr.reduce(function(prev, cur, index, array){
    return prev - cur
})
console.log(sum1); // -19  1-2-3-4-5-6
// 传两个参数，给定归并初始值
var sum2 = arr.reduce(function(prev, cur, index, array){
    return prev - cur 
},10)
console.log(sum2); // -11 10-1-2-3-4-5-6

var sum3 = arr.reduceRight(function(prev, cur, index, array){
    return prev - cur
})
console.log(sum3);  // -9  6-5-4-3-2-1

var sum4 = arr.reduceRight(function(prev, cur, index, array){
    return prev - cur
},10)
console.log(sum4);  // -11  10-6-5-4-3-2-1

toLocaleString() 和 toString()

toLocaleString()：这个方法返回一个表示当前数字的字符串，该字符串根据宿主环境的当前区域设置格式化数字。它可以用于数字、日期和货币等类型的对象。该方法根据不同的区域设置，可以自动添加千位分隔符、小数位数等。 toString()：这个方法返回一个表示给定对象的字符串。对于数字类型，toString() 可以带一个参数指定基数（进制），默认为十进制。

const number = 1234567.89;
console.log(number.toLocaleString()); // 输出: "1,234,567.89"（取决于当前区域设置）
const number1 = 123;
console.log(number1.toString()); // 输出: "123"
console.log(number1.toString(2)); // 输出: "1111011"（二进制）

需要注意的是，toLocaleString() 和 toString() 方法返回的都是字符串类型。toLocaleString() 在不同的区域设置下可能返回不同的格式化结果，而 toString() 则根据传入的基数返回相应进制的字符串表示。

find() 和 findIndex()

find()与 findIndex()方法均接受两个参数：一个回调函数，一个可选值用于指定回调函数内部的 this。 该回调函数可接受三个参数：数组的某个元素，该元素对应的索引位置，以及该数组本身。 该回调函数应当在给定的元素满足你定义的条件时返回 true，而 find()和 findIndex()方法均会在回调函数第一次返回 true 时停止查找。 二者的区别是：find()方法返回匹配的值，而 findIndex()返回匹配位置的索引。

let arr1 = [3,6,56,'lili',45,99]
console.log(arr1.find((value, keys, arr1)=>{
    return value > 10
})); // 56  返回匹配的值
console.log(arr1.findIndex((value, keys, arr1)=>{
    return value > 10
})); // 2 返回匹配位置的索引

copyWithin() es6新增

用于从数组的指定位置拷贝元素到数组的另一个指定位置中 该方法会改变现有数组 语法：array.copyWithin(target, start, end) target：必需，表示从该位置开始替换数据。如果为负数，则表示从数组的末尾开始计数。 start：可选，表示复制起始位置。如果为负数，则表示从数组的末尾开始计数，默认为 0。 end：可选，表示复制结束位置（不包含该位置的元素）。如果为负数，则表示从数组的末尾开始计数，默认为数组长度。 该方法将会用从 start 到 end (不包括 end) 的元素替换从 target 开始的元素。如果 end 参数被省略，则复制元素直到数组的末尾。

let arr = [1,2,3,5,6,8]
let arr1 = arr.copyWithin(2,3)
console.log(arr1); // [ 1, 2, 5, 6, 8, 8 ] 从 索引2开始粘贴，索引3开始复制
console.log(arr); //  [ 1, 2, 5, 6, 8, 8 ] 原数组已被更改
let arr2 = arr1.copyWithin(3,1)
console.log(arr2); // [ 1, 2, 5, 2, 5, 6 ]
let arr3 = arr2.copyWithin(2,3,4) // 从 索引2开始粘贴，索引3开始复制,遇到索引4时停止
console.log(arr3); // [ 1, 2, 2, 2, 5, 6 ]

flat() 和 flatMap() es6新增

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。 该方法返回一个新数组，对原数据没有影响。 参数： 指定要提取嵌套数组的结构深度，默认值为 1。

let arr = [1,2,4,5,[7,8]]
let arr1 = arr.flat()
console.log(arr1); // [ 1, 2, 4, 5, 7, 8 ]
console.log(arr); // [ 1, 2, 4, 5, [ 7, 8 ] ]  不改变原数组
let arr2 = [2,3,4,5,[[[9,8]]]]
console.log(arr2.flat()); // [ 2, 3, 4, 5, [ [ 9, 8 ] ] ]
console.log(arr2.flat(2)); // [ 2, 3, 4, 5, [ 9, 8 ] ]
let arr3 = [4,5,6,[[[[[6,7,8]]]]]]
console.log(arr3.flat(Infinity)); // [ 4, 5, 6, 6, 7, 8 ]  使用 Infinity，可展开任意深度的嵌套数组
// 扁平化数组空项,如果原数组有空位，flat()方法会跳过空位
let arr4 = [1,3, , 5]
console.log(arr4.flat()); // [ 1, 3, 5 ]

flatMap()方法对原数组的每个成员执行一个函数，相当于执行Array.prototype.map(),然后对返回值组成的数组执行flat()方法。 该方法返回一个新数组，不改变原数组。 语法：array.flatMap(callback(currentValue, index, array), thisArg) callback：必需，一个可以生成新数组元素的函数，该函数接收三个参数： currentValue：当前元素的值 index：当前元素的索引 array：原始数组对象 thisArg：可选，执行回调函数时使用的 this 值

let arr = [2,3,4]
// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
let arr1 = arr.flatMap((x) => [x, x * 2])
console.log(arr1); // [ 2, 4, 3, 6, 4, 8 ]
// 需要注意的是，flatMap() 方法只会扁平化一层，如果回调函数的返回值本身是一个数组，该数组不会被递归地扁平化到新数组中。
let arr3 = [2,3,4,[7,8]]
let arr2 = arr3.flatMap((x) => [x, x * 2])
console.log(arr2); // [ 2, 4, 3, 6, 4, 8, [ 7, 8 ], NaN ]

entries(),keys() 和 values() es6新增

entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for...of循环进行遍历 区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历

// entries(): 这个方法返回一个新的数组迭代器对象，迭代器中包含数组中每个索引位置的键值对。
const array = ['a', 'b', 'c'];
const iterator = array.entries();

console.log(iterator.next().value); // 输出: [0, 'a']
console.log(iterator.next().value); // 输出: [1, 'b']
console.log(iterator.next().value); // 输出: [2, 'c']
// entries() 方法返回一个迭代器对象，每个迭代器对象的值是一个包含索引和对应的元素的键值对数组。

// keys(): 这个方法返回一个新的数组迭代器对象，迭代器中包含数组中每个索引位置的键。
const array = ['a', 'b', 'c'];
const iterator = array.keys();

console.log(iterator.next()); // 输出: {value: 0, done: false}
console.log(iterator.next()); // 输出: {value: 1, done: false}
console.log(iterator.next()); // 输出: {value: 2, done: false}
// keys() 方法返回的迭代器对象，每个迭代器对象的值是一个索引位置。

// values(): 这个方法返回一个新的数组迭代器对象，迭代器中包含数组中每个索引位置的值。
const array = ['a', 'b', 'c'];
const iterator = array.values();

console.log(iterator.next().value); // 输出: 'a'
console.log(iterator.next().value); // 输出: 'b'
console.log(iterator.next().value); // 输出: 'c'
// values() 方法返回的迭代器对象，每个迭代器对象的值就是对应的数组元素的值。

需要注意的是，这些方法返回的是迭代器对象，可以通过调用 next() 方法迭代访问数组的键值对、键和值。当迭代器到达数组的末尾时，next() 方法的结果的 done 属性将为 true。

对象常见方法

创建对象

对象字面量

let obj = {}

构造函数

function obj(name,age,gender){
  this.name = name
  this.age = age
  this.gender = gender
}
let  person = new obj('tian', 20, 'male')

使用Object.create() 方法

let personPrototype = {
  sayHello: function() {
    console.log('Hello!')
  }
}
let person = Object.create(personPrototype)
person.name = 'tian'
person.age = 20
person.gender = 'male'

常用对象方法

访问和修改对象属性

const person = {
  name: 'Alice',
  age: 30,
  gender: 'female'
};

console.log(person.name); // 输出: 'Alice'
person.age = 31; // 修改属性值
person.city = 'New York'; // 添加属性
console.log(person.age); // 31

删除对象属性 delete

const person = {
    name: 'Alice',
    age: 30,
    gender: 'female'
  };
  
  delete person.gender;
  console.log(person); //{ name: 'Alice', age: 30 }

遍历对象属性

const person = {
    name: 'Alice',
    age: 30,
    gender: 'female'
  };
  
  for (let key in person) {
    console.log(key + ': ' + person[key]);
  } 
//   name: Alice
//   age: 30
//   gender: female

判断对象是否包含某个属性

是 JavaScript 对象的一个方法，用于检查对象自身是否具有指定名称的属性（不包括原型链上的属性） 语法：object.hasOwnProperty(propertyName) object：要检查的对象。 propertyName：要检查是否存在的属性名称。 hasOwnProperty 方法返回一个布尔值，如果指定名称的属性存在于对象的自身属性中，返回 true，否则返回 false。

const person = {
    name: 'Alice',
    age: 30,
    gender: 'female'
  };
  
  console.log(person.hasOwnProperty('name')); // 输出: true
  console.log(person.hasOwnProperty('city')); // 输出: false

将对象转换为字符串

1.使用 JSON.stringify() 方法：

const person = {
  name: 'Alice',
  age: 30,
  gender: 'female'
};

const jsonString = JSON.stringify(person);
console.log(jsonString); // 输出: '{"name":"Alice","age":30,"gender":"female"}'

JSON.stringify() 方法将对象转换为对应的 JSON 字符串表示形式。

注意：该方法会忽略对象的函数属性以及原型链上的属性。

2.使用 toString() 方法：

const person = {
  name: 'Alice',
  age: 30,
  gender: 'female',
  toString() {
    return `My name is ${this.name}, I'm ${this.age} years old.`;
  }
};

const stringRepresentation = person.toString();
console.log(stringRepresentation); // 输出: 'My name is Alice, I'm 30 years old.'

自定义对象的 toString() 方法，可以在对象需要被转换为字符串时进行自定义逻辑。 有关以上两种方法的选择，可以看情况而定：

如果你希望将对象转换为可传输或存储的标准字符串表示形式，JSON.stringify() 是一个常用且方便的选择。 如果你希望自定义对象的字符串表示形式或者对象是自定义类的实例，你可以重写对象的 toString() 方法。 需要注意的是，如果对象中包含循环引用，使用 JSON.stringify() 会导致 TypeError，因此需要小心处理循环引用的情况。

Object.assign()

用于将一个或多个源对象的属性复制到目标对象中。它接收一个目标对象和一个或多个源对象作为参数，并返回修改后的目标对象。 语法：Object.assign(target, ...sources) target：目标对象，即要将属性复制到的对象。 sources：一个或多个源对象，即要从中复制属性的对象。 Object.assign() 方法将源对象的所有可枚举属性复制到目标对象中，如果目标对象中已有相同属性名，则会覆盖目标对象的属性。它会按顺序处理源对象，后面的源对象属性将覆盖前面的。

const target = { a: 1, b: 2 };
const source = { b: 3, c: 4 };
const result = Object.assign(target, source);
console.log(result); // 输出: { a: 1, b: 3, c: 4 }
console.log(target); // 输出: { a: 1, b: 3, c: 4 }

需要注意的是，Object.assign() 方法进行的是浅拷贝，如果源对象的属性值是对象或数组等引用类型，复制的是引用而非创建新的副本。如果需要深拷贝对象，可以使用其他方法，如通过 JSON 序列化和反序列化实现深拷贝(JSON.stringify + JSON.parse)。 Object.assign() 方法可以用于合并多个对象或创建对象的副本，同时也可以将对象属性复制到空对象中创建新对象。

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

// 合并多个对象
const mergedObj = Object.assign({}, obj1, obj2, obj3);
console.log(mergedObj); // 输出: { a: 1, b: 2, c: 3 }

// 创建对象的副本
const clone = Object.assign({}, obj1);
console.log(clone); // 输出: { a: 1 }

(在处理对象属性复制、合并和创建副本等场景中非常实用。)

浅拷贝和深拷贝

浅拷贝是指创建一个新对象，这个对象有着与原始对象相同的键值对。但是，如果原始对象的属性值是引用类型（比如数组或对象），那么浅拷贝只会复制引用地址，而不会创建一个新的独立的引用对象。这意味着，新对象和原始对象的引用类型属性会指向同一个内存地址，改变其中一个对象的属性值会影响到另一个对象。

深拷贝是指创建一个全新的对象，新对象与原始对象完全独立，互不影响。无论原始对象的属性值是原始类型还是引用类型，深拷贝都会创建一个新的值来复制到新对象中，而不是简单地复制引用地址。