2.Object.assign() 可以把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。【// 如果数组元素是基本类型，就会拷贝一份，互不影响，而如果是对象或者数组，就会只拷贝对象和数组的引用，这样我们无论在新旧数组进行了修改，两者都会发生变化。这种叫浅拷贝】

var x = {
  a: 1,
  b: { f: { g: 1 } },
  c: [ 1, 2, 3 ]
var y = Object.assign({}, x);
console.log(y.b.f === x.b.f);     // true

合并对象 Object.assign()

如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。后面的源对象的属性将类似地覆盖前面的源对象的属性。

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };

const returnedTarget = Object.assign(target, source);

console.log(target);
// expected output: Object { a: 1, b: 4, c: 5 }

3.$.extend()

var obj1={'a':1};
var obj2={'b':{'b1':22,'b2':33}};
$.extend(obj1, obj2);   //obj1拷贝了obj2的属性
console.log(obj1)  // {'a':1,'b'{'b1':22,'b2':33}}
console.log(obj1.b.b1)  // 22
obj2.b.b1=44;   //obj2重新赋值
console.log(obj1.b.b1)  // 44  obj1.b仅拷贝了对象的指引，所以受原obj2的影响

深拷贝的实现

var obj1={'a':1};
var obj2={'b':{'b1':22,'b2':33}};
$.extend(true,obj1, obj2);   //第一个参数设为true表示深复制
console.log(obj1)  // {'a':1,'b'{'b1':22,'b2':33}}
console.log(obj1.b.b1)  // 22
obj2.b.b1=44;   //obj2重新赋值
console.log(obj1.b.b1)  

数组的合并

concat 方法 用于多个数组的合并。它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变。 // 如果数组元素是基本类型，就会拷贝一份，互不影响，而如果是对象或者数组，就会只拷贝对象和数组的引用，这样我们无论在新旧数组进行了修改，两者都会发生变化。这种叫浅拷贝

  const a = [1, 2, 3]
  const b = [4, 5, 6]
  const c = a.concat(b)
  c[0] = 9
 console.log(c)  // [ 9, 2, 3, 4, 5, 6 ]
  console.log(a) //[1,2,3]  //数组不是引用型则为深拷贝

如果数组成员包括对象，concat方法返回当前数组的一个浅拷贝。所谓“浅拷贝”，指的是新数组拷贝的是对象的引用。

var obj = { a: 1 };
var oldArray = [obj];

var newArray = oldArray.concat();

obj.a = 2;
newArray[0].a // 2

slice方法 // 如果数组元素是基本类型，就会拷贝一份，互不影响，而如果是对象或者数组，就会只拷贝对象和数组的引用，这样我们无论在新旧数组进行了修改，两者都会发生变化。这种叫浅拷贝

slice 方法实现数组的拷贝

slice() 方法可从已有的数组中返回选定的元素。

arrayObject.slice(start,end)

该方法返回一个新的数组，包含从 start 到 end （不包括该元素，数学上来讲是左闭右开，即包含左，不含右）的 arrayObject 中的元素。

1. 1 var arr1 = [1, 2, 3];

2. 2 var arr2 = arr1.slice(0);

3. 3 arr1[0] = 4;

4. 4 console.log(arr1); //4, 2, 3

5. 5 console.log(arr2); //1, 2, 3

for循环

var a = [ ] for (var i in b) { a.push(b[i]) }

• …扩展运算符

• const a1 = [1, 2];
  // 写法一
  const a2 = [...a1];
  // 写法二
  const [...a2] = a1;
  // ES6 的合并数组
  [...arr1, ...arr2, ...arr3]

递归实现深拷贝

function deepClone(obj) {
 if (typeof obj !== 'object') return;
    let objClone = Array.isArray(obj) ? []:{}
        for (key in obj) {
            if(obj.hasOwnObjectProperty(key)) {
             objClone[key] = typeof obj[key] === "object" ? deepClone(obj[key]) : obj[key]
JSON对象的parse和stringify实现深拷贝
 
function deepClone(obj){
    let _obj = JSON.stringify(obj),
        objClone = JSON.parse(_obj);
    return objClone
                    深拷贝：开辟一个新的内存地址，浅拷贝指针指向同一片内存空间浅复制只复制一层对象的属性，而深复制则递归复制了所有层级浅拷贝的实现1.引用复制var obj = { a:1, arr: [2,3] };var shallowObj = shallowCopy(obj);function shallowCopy(src) {    var dst= {}     for ( var prop in src) {        if (src.hasOwnProperty(prop) 
        // Arrays.copyOf()
        String[] b = Arrays.copyOf(a, a.length);
        System.out.println("Arrays.copyOf(): " + Arrays.toString(b));
        // 方法二
        // Objec
				
JavaScript 数组之浅复制与深复制
什么是浅复制？
当一个数组赋给另外一个数组时，只是为被赋值的数组增加了一个新的引用。当你通过原引用修改了数组的值，另外一个引用也会感知到这个变化，新数组依然指向原来的数组，这种行为被称为浅复制。举例如下：
var nums = [];
for (var i = 0; i < 100; ++i) {
	nums[i] = i+1;
var sam...
				
1.什么是深拷贝和浅拷贝？
因为javascript有原始值和引用值之分，所以当浅拷贝复制数组或者对象的时候就是复制的引用，这样复制后的两个值会相互影响，深拷贝则相当于重新开辟了一快内存去存储复制的值，两个不会互相影响。
2.数组
数组的浅拷贝
            let arr = [1,2,3,4,5];
            let copyArr = arr;
				
拷贝:顾名思义就是复制嘛,不过，深浅拷贝之间的差别在于拷贝的第三方数值的改变会不会对原对象产生影响.
就是新对象复制的是已有对象中非对象属性的值和对象属性的引用,对象属性不会复制到内存
obj ={name:‘dress’,{color:‘red’}}     newObj浅拷贝obj,复制name的值,当新对象的name发生改变时,原对象(也就是obj)的name不会发生改变;color为对象属性,只会拷贝一份相同的内存地址,新对象中的color值发生改变,原对象中color的值也要改变
1. 数组方法:
- Array.unshift(): 将一个或多个元素添加到数组的开头，并返回数组。这会改变数组的长度。
- Array.isArray(): 用来判断一个对象是否为数组。如果是数组则返回true，否则返回false。
- Array.push(): 将一个或多个元素添加到数组的末尾，并返回新的数组长度。
- Array.pop(): 删除数组的最后一个元素，并返回被删除的元素。这会改变数组的长度。
- Array.shift(): 删除数组的第一个元素，并返回被删除的元素。这会改变数组的长度。
- Array.concat(): 将多个数组合并成一个新的数组。
- Array.toString(): 将数组转换为字符串形式。
- Array.join(): 将数组转换为字符串形式，可以设置元素之间的间隔。
- Array.splice(start, deleteCount, item): 在指定位置对数组进行增、删、改操作。可以删除数组中的元素、添加新的元素或替换数组中的元素。
- Array.slice(start, end): 返回指定起始下标到结束下标之间的子数组，原数组不受影响。
2. 对象方法:
- Object.keys(): 返回一个由对象的所有可枚举属性组成的数组。
- Object.values(): 返回一个由对象的所有可枚举属性值组成的数组。
- Object.entries(): 返回一个由对象的所有可枚举属性键值对组成的数组。
- Object.assign(target, ...sources): 用于将一个或多个源对象的所有可枚举属性复制到目标对象。
以上是一些常用的数组和对象方法，可以根据需要选择合适的方法进行操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
-  *1* *2* *3* [常用js的数组方法和对象方法](https://blog.csdn.net/qq_44890872/article/details/103324937)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]