精华内容
下载资源
问答
  • 数组深克隆比较灵巧的几种方式 扩展运算符扩展运算符可以将数组转换为一个用逗号分隔的参数序列; 由此延伸的克隆方式; let arr = [...[1, 2, 3]]; concat()数组的连接返回被连接后数组的一个副本; 通过这种方式也...

    数组深克隆比较灵巧的几种方式

    1. 扩展运算符
      扩展运算符可以将数组转换为一个用逗号分隔的参数序列;

    由此延伸的克隆方式;

    let arr =  [...[1, 2, 3]];
    1. concat()
      数组的连接返回被连接后数组的一个副本;

    通过这种方式也可以进行克隆;

     let arr = [1, 2, 3].concat();
    1. slice()
      slice可以从已有的数组中返回选定的元素;

    并且在不改变原数组的情况下返回一个新的数组;
    那么在不删除任何元素的情况下返回的不就是和原数组一样的新数组么;

    let arr = [1, 2, 3].slice();

    如果数组内的值是对象的情况下;以上所有方式全部报废;这个时候就需要换个思路

    1. 转换为json字符串

      let arr = JSON.parse(JSON.stringify([a: 1]));
    展开全文
  • 克隆克隆是指:只克隆数组/对象的第一层级内容(开辟新的堆内存),而第二层级及以上层级的内容则直接引用(使用原来第二层级及以上层级的堆内存)。如果对克隆后对象的二级或以上层级进行修改,那么克隆前对象的二...

    浅克隆

    浅克隆是指:只克隆数组/对象的第一层级内容(开辟新的堆内存),而第二层级及以上层级的内容则直接引用(使用原来第二层级及以上层级的堆内存)。如果对克隆后对象的二级或以上层级进行修改,那么克隆前对象的二级或以上层级也会跟着被修改。 例如:现有一个对象obj1对应堆内存地址0x000,obj1对象中还有个子对象obj1_1对应堆内存0x001,现在想对obj1对象进行浅克隆,则会创建一个新的对象obj2对应新的堆内存地址0x002,对于对象obj1中的基本类型数据则会直接拷贝到obj2中,而obj1中的引用类型也就是子对象obj1_1则会直接被新对象obj2引用,而不是创建新的堆内存。后面如果通过操作obj2对obj2中的子对象obj1_1进行更改,那么obj1中的obj1_1也会随着变化,因为它们用的是同一个堆内存。来看下面的图会更直观一些

    实现浅克隆的几种方案

    对象的浅克隆方案一:基于循环实现

    let obj1 = {

    python: "python",

    java: "java"

    fontend: {

    javascript: "javascript",

    html: "html"

    }

    }

    let obj2 = {};//创建一个新对象(开辟新的堆内存)

    //把obj1中私有的key和Symbol类型的key存在数组中

    let keys = [

    ...Object.keys(obj1),//展开运算符

    ...Object.getOwnPropertySymbols(obj1)

    ]

    keys.forEach(key => {

    obj2[key] = obj1[key];

    });

    console.log(obj1 === obj2); //false

    console.log(obj1.fontend === obj2.fontend);// true

    对象的浅克隆方案二: 展开运算符

    let obj1 = {

    python: "python",

    java: "java"

    fontend: {

    javascript: "javascript",

    html: "html"

    }

    }

    let obj2 = {

    ...obj1

    };

    console.log(obj1 === obj2); //false

    console.log(obj1.fontend === obj2.fontend);// true

    对象的浅克隆方案三:基于Object.assign()函数

    Object.assign([obj1], …[obj2]):该方法接收多个参数,执行后会将obj2中的键值对合并到obj1中,并将obj1的堆内存地址返回。注意:这里返回的不是新的对象,而是把第一个参数作为返回值返回。 所以我们可以利用这个特点进行对象的浅克隆

    let obj1 = {

    python: "python",

    java: "java"

    fontend: {

    javascript: "javascript",

    html: "html"

    }

    }

    //因为assign方法默认会把第一个参数返回,所以这里传一个空对象进去,执行asign方法将obj1合并后,再将合并后的对象返回,就达到了克隆目的

    let obj2 = Object.assign({}, obj1);

    console.log(obj1 === obj2); //false

    console.log(obj1.fontend === obj2.fontend);// true

    数组浅克隆方案一:基于forEach或map

    let arr = [12,3,[4,50]];

    let arr2 = [];

    arr.forEach((item, index) => {

    arr2[index] = item;

    });

    arr2 = arr.map(item => item);

    数组浅克隆方案二:基于展开运算符或Object.asing(),与对象相同

    let arr = [12,3,[4,50]];

    let arr2 = [

    ...arr

    ];

    arr2 = Object.assign([], arr);

    数据浅克隆方案三:基于数组的slice方法,不传参数默认从数组第一项开始截取到数组的最后一项

    let arr = [12,3,[4,50]];

    let arr2 = arr.slice();

    数组和对象的浅克隆 - 通用方案:自己撸代码

    //定义一个用于检测数据类型的通用方法

    function toType(value){

    let obj = {};

    ['Number','String','Boolean','Null','Undefined','Symbol','BigInt','Function','GeneratorFunction','Date','RegExp','Object','Error'].forEach(item => {

    obj["[object "+item+"]"] = item.toLowerCase()

    });

    return obj[Object.prototype.toString.call(value)];

    }

    //定义一个获取对象/数组所有私有属性(包括Symbol类型)的方法

    function getOwnProperties(obj){

    //数据类型检测

    if(obj == null) return [];

    //获取所有私有属性包括Symbol类型

    let keys = [

    ...Object.keys(obj),

    ...Object.getOwnPropertySymbols(obj)

    ]

    return keys;

    }

    function shallowClone(obj){

    //如果是基本数据类型值,则传啥就返回啥

    let type = toType(obj);

    if(/^(number|string|boolean|null|undefined|symbol|bigint)$/.test(type)) return obj;

    if(type === 'function') {

    //返回一个不同函数,但最后执行效果跟原始函数一致

    return function proxy(){

    obj();

    }

    }

    //if(type === 'regexp') return new RegExp(obj);

    //if(type === 'date') return new Date(obj);

    if(/^(regexp|date)$/.test(type)) return new obj.constructor(obj);

    if(type === 'error') return new Error(obj.message);

    let keys = getOwnProperties(obj);

    let clone = {};

    Array.isArray(obj) ? clone = [] : null;

    keys.forEach(item => {

    clone[item] = obj[item];

    });

    return clone;

    }

    数组和对象的深克隆

    相信经过前面对数组和对象的浅克隆的了解,深克隆也就不难理解了; 前面说浅克隆是只克隆数组或对象的第一层级,二级及以上层级是直接引用;那么深克隆则是克隆数组或对象的每个层级,不管一个对象或数组有多少层级,那么当我们进行深克隆时每一个层级都会开辟一块新的堆内存地址。对于克隆后对象/数组的任何层级做任何修改都不会影响到克隆前的对象/数组,因为它们都是独立的不同的堆内存。如下图所示

    数组和对象的深克隆方案一:基于JSON.stringfiy、JSON.parse实现深克隆

    原理:先将数组或对象基于JSON.stringify转换为字符串,然后再基于JSON.parse把字符串转换为对象,此时对象中对应每个层级都会开辟一块全新的堆内存来存储 缺点:因为JSON.stringify变为字符串,很多类型是不支持的

    正则/Math数学函数会被处理为空对象具备函数/Symbol/undefined属性值的属性会被直接删除掉BigInt无法处理,会报错日期对象转换后变为字符串

    let obj1 = {

    python: "python",

    java: "java"

    fontend: {

    javascript: "javascript",

    html: "html"

    }

    }

    let obj2 = JSON.parse(JSON.stringify(obj1));

    数组/对象深克隆方案二:自己撸代码

    function toType(value){

    let obj = {};

    ['Number','String','Boolean','Null','Undefined','Symbol','BigInt','Function','GeneratorFunction','Date','RegExp','Object',"Error"].forEach(item => {

    obj["[object "+item+"]"] = item.toLowerCase()

    });

    return obj[Object.prototype.toString.call(value)];

    }

    //定义一个获取对象/数组所有私有属性(包括Symbol类型)的方法

    function getOwnProperties(obj){

    //数据类型检测

    if(obj == null) return [];

    //获取所有私有属性包括Symbol类型

    let keys = [

    ...Object.keys(obj),

    ...Object.getOwnPropertySymbols(obj)

    ]

    return keys;

    }

    function deepClone(obj, cache = new Set()){

    /*

    if(/^(number|string|boolean|null|undefined|symbol|bigint)$/.test(type)) return obj;

    if(type === 'function') {

    //返回一个不同函数,但最后执行效果跟原始函数一致

    return function proxy(){

    obj();

    }

    }

    //if(type === 'regexp') return new RegExp(obj);

    //if(type === 'date') return new Date(obj);

    if(/^(regexp|date)$/.test(type)) return new obj.constructor(obj);

    if(type === 'error') return new Error(obj.message);

    */

    //如果是基本数据类型值,则传啥就返回啥

    let type = toType(obj);

    //如果不是数组或对象则直接按浅克隆处理

    if(!/^(array|object)$/.test(type)) return shallowClone(obj);

    let keys = getOwnProperties(obj);

    let clone = {};

    Array.isArray(obj) ? clone = [] : null;

    if(cache.has(obj)) return obj;

    cache.add(obj);

    keys.forEach(item => {

    //if(/^(array|object)$/.test(toType(obj[item]))){

    //    clone[item] = deepClone(obj[item]);

    //}

    clone[item] = deepClone(obj[item], cache);

    });

    return clone;

    }

    展开全文
  • 二维数组深克隆

    2020-08-11 10:38:58
    今天在写一道算法题时,发现二维数组使用clone和arraycopy两种方法进行数组复制只能实现浅克隆。起初有点疑惑,但仔细思考了一下这两种方式的实现原理就能...那么如何实现多维数组间的深克隆呢?有两种方式: 多次遍历

    今天在写一道算法题时,对二维数组错误使用了clone和arraycopy两种方法进行数组复制。起初有点疑惑,但仔细思考了一下这两种方式的实现原理就能明白这两种方法只能实现‘浅复制’。
    首先,这两种方式都会对基本类型的值进行复制,但是对于引用变量来说,它们也仅仅只是将引用的变量的‘值’克隆一份,也就是引用变量的地址。因此对于二维数组来说,其实际为一个元素值为一维数组地址的一维数组,故在使用上述方法克隆数组时,新的二维数组仅仅只将原有的一维引用地址复制了一份。
    那么如何实现多维数组间的深克隆呢?有两种方式:

    • 多次遍历,按位赋值
    for(int i = 0; i < m; ++i){//行数为m
         for(int j = 0; j < n; ++j){//列数为n
            copy[i][j] = matrix[i][j];
         }
    }
    
    • 从最低维开始依次使用clone或arraycopy方法,实现深克隆
    for(int i = 0; i < m; ++i){
    	copy[i] = matrix[i].clone();
    	//System.arraycopy(matrix[i],0,copy[i],0,n);//使用arraycopy实现
    }
    
    展开全文
  • vue数组深克隆和浅克隆

    千次阅读 2020-01-02 14:48:31
    这就是浅克隆的写法,因为后端返回的data是一个数组,而数组是引用数据类型(自行了解基本数据类型和引用数据类型) 如果我们接下来的代码对 _data 进行的处理操作,res.data也会一起改变,这是因为浅克隆克隆的...

    在开发过程中,前端获取到后端的数据之后,通常直接复制后就使用,比如:

    var _data = res.data; //浅克隆   data是一个数组

    这就是浅克隆的写法,因为后端返回的data是一个数组,而数组是引用数据类型(自行了解基本数据类型和引用数据类型)
    如果我们接下来的代码对 _data 进行的处理操作,res.data也会一起改变,这是因为浅克隆, 克隆的是一个地址,而不是实际变量值。

    下面我用我的实际项目,演示下 深克隆和浅克隆的区别:

    浅克隆:源数据与克隆数据一起改变

       

    现在我们克隆数据的时候改成 深克隆,其他的不变

    深克隆:源数据没有随克隆数据一起改变

       

      从上面可以看到,我使用了JSON.stringify+JSON.parse 进行深克隆,这能满足很大一部分开发需求了,当然,深克隆的方法还有很多,比如:递归、 jQuery中的 $.extend、slice(0)、object.assign、for循环遍历赋值、new Object() 等都是可以的
     

    开发过程的记录,若有不恰当之处,欢迎指正!

    展开全文
  • 关键词克隆;复制;浅拷贝;拷贝;浅拷贝slice();concat();扩展运算符;Object.assign()/ slice() /slice()方法返回一个新的数组对象,这一对象是一个由 begin 和 end 决定的原数组的浅拷贝(包括 begin,不包括end...
  • 关键词克隆;复制;浅拷贝;拷贝;浅拷贝slice();concat();扩展运算符;Object.assign()/ slice() /slice()方法返回一个新的数组对象,这一对象是一个由 begin 和 end 决定的原数组的浅拷贝(包括 begin,不包括end...
  • js深克隆数组和对象

    2020-11-05 19:42:32
    this.kelongList = JSON.parse(JSON.stringify(被克隆的数组));深克隆数组 this.kelongObj = JSON.parse(JSON.stringify(被克隆的对象)); 深克隆对象
  • Java 浅/深克隆、克隆数组

    千次阅读 2019-05-30 13:55:10
    Java 浅/深克隆、克隆数组。及,示例代码演示。
  • 复制一个数组内容且两个...使用拷贝就可以避免操作新B数组时影响原数组A。使两个数组相互独立。使用for循环、forEach()、slice()、concat()、map()、Array.from()、Array.of()、扩展运算符等方式实现数组拷贝。
  • 数组克隆及对象的、浅克隆
  • 关于数据的深克隆方法 随便写写,实际克隆对象类型请自行用`typeof`或`Object.prototype.toString.call`判断,你可以将下面的方法封装 深克隆: 1、数组 public deepClone(arr) { let res = []; for (let i = 0;...
  • //深克隆 function deepClone(obj){ var cloneObj //当obj是一个简单值时 if(obj && typeof obj!=='object'){ cloneObj=obj console.log("plain value") } //当obj是对象或者数组的时候 else if(obj...
  • 首先我要得到的数据长这样 如果这样写就会导致 在这里使用深克隆改变指针指向就可以实现
  • (1)浅克隆:只克隆数据/对象的第一层级内容开辟新的堆内存,而第二层及以下的内容则直接引用(使用原来第二层级以下层级的堆内容),如果对其克隆后的对象二层级及以下层级进行修改时,原对象也会跟着被修改。...
  • 经过改造,我自己重新实现了数组拷贝,同时支持多重数组拷贝。 因为Object的clone方法声明成protected,在使用泛型的时候,无法调用clone方法,所以我们自己重新定义个克隆的接口 package demo; public ...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 351
精华内容 140
关键字:

数组深克隆