深拷贝与浅拷贝js,方法

在使用JavaScript对数组进行操作的时候,我们经常需要将数组进行备份,事实证明如果只是简单的将它赋予其他变量,那么我们只要更改其中的任何一个,然后其他的也会跟着改变,这就导致了问题的发生。

参考Object.assign():https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

<!DOCTYPE html>
<html>
<head>
    <title>测试深拷贝,浅拷贝方法及现象</title>
</head>
<body>
    <script type="text/javascript">
        //Object.assign()方法是浅拷贝

        var myobject={
            a:"a",
            b:"b",
            c:"c",
        }
        var newobject=Object.assign({},myobject);
        newobject.a=222;
        document.writeln("原始:"+JSON.stringify(myobject));
        document.writeln("现在:"+JSON.stringify(newobject));

                function test() {
          ‘use strict‘;

          let obj1 = { a: 0 , b: { c: 0}};
          let obj2 = Object.assign({}, obj1);
          console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}

          obj1.a = 1;
          console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
          console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}}

          obj2.a = 2;
          console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}}
          console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 0}}

          obj2.b.c = 3;
          console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}}
          console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}}

          // Deep Clone
          //利用json方法是深复制,但要JSON安全
          obj1 = { a: 0 , b: { c: 0}};
          let obj3 = JSON.parse(JSON.stringify(obj1));
          obj1.a = 4;
          obj1.b.c = 4;
          console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}
        }

        test();
    </script>

<!--     <script type="text/javascript">
        //这是浅拷贝,该变拷贝的对象会改变原始对象的值
        var arr = ["One","Two","Three"];

        var arrto = arr;
        arrto[1] = "test";
        document.writeln("数组的原始值:" + arr + "<br />");//Export:数组的原始值:One,test,Three
        document.writeln("数组的新值:" + arrto + "<br />");//Export:数组的新值:One,test,Three

    </script>
 -->

<!--      <script type="text/javascript">
    //这是深拷贝,该变现有对象不会改变原始对象的值

    var arr = ["One","Two","Three"];

    var arrtoo = arr.slice(0);
    arrtoo[1] = "set Map";
    document.writeln("数组的原始值:" + arr + "<br />");//Export:数组的原始值:One,Two,Three
    document.writeln("数组的新值:" + arrtoo + "<br />");//Export:数组的新值:One,set Map,Three
     </script> -->

<!--      <script type="text/javascript">
    //这是深拷贝
         var arr = ["One","Two","Three"];

        var arrtooo = arr.concat();
        arrtooo[1] = "set Map To";
        document.writeln("数组的原始值:" + arr + "<br />");//Export:数组的原始值:One,Two,Three
        document.writeln("数组的新值:" + arrtooo + "<br />");//Export:数组的新值:One,set Map To,Three
     </script> -->

<!--      <script type="text/javascript">
    //深拷贝,json方法是深拷贝
         var someobj={
             a:"a",
             b:"b",
             c:"c"
         }
         var newobject=JSON.parse(JSON.stringify(someobj));
         someobj.a="aaaa";
         document.writeln("原始:"+JSON.stringify(someobj)+"<br/>");
         document.writeln("现在:"+JSON.stringify(newobject)+"<br/>");
         //原始:{"a":"aaaa","b":"b","c":"c"}
        // 现在:{"a":"a","b":"b","c":"c"}
     </script> -->

 </body>
</html>

这里只是浅尝辄止,以后还会继续探究。

总结:浅拷贝Object.assign(),

      深拷贝用JSON.parse(JSON.stringify(someobj));

   但要保证someobj是json安全的,符合json规则。

原文地址:https://www.cnblogs.com/wulinzi/p/8283814.html

时间: 2024-10-11 02:54:07

深拷贝与浅拷贝js,方法的相关文章

js的命名空间 &amp;&amp; 单体模式 &amp;&amp; 变量深拷贝和浅拷贝 &amp;&amp; 页面弹窗设计

说在前面:这是我近期开发或者看书遇到的一些点,觉得还是蛮重要的. 一.为你的 JavaScript 对象提供命名空间 <!DOCTYPE html> <html> <head> <title>为自己的js对象提供命名空间</title> </head> <body> <div>封装自己的数据和函数,防止和其他的库搞混了</div> <script> var jscbObject = {

【JS】深拷贝与浅拷贝的区别,实现深拷贝的几种方法

如何区分深拷贝与浅拷贝,简单点来说,就是假设B复制了A,当修改A时,看B是否会发生变化,如果B也跟着变了,说明这是浅拷贝,拿人手短,如果A没变,那就是深拷贝,自食其力. 此篇文章中也会简单阐述到栈堆,基本数据类型与引用数据类型,因为这些概念能更好的让你理解深拷贝与浅拷贝. 我们来举个浅拷贝例子: let a=[0,1,2,3,4], b=a; console.log(a===b); a[0]=1; console.log(a,b); 嗯?明明b复制了a,为啥修改数组a,数组b也跟着变了,这里我不

从JS的深拷贝与浅拷贝到jq的$.extend()方法

一.堆内存与栈内存 堆和栈都是内存中划分出来的用来存储的区域,栈为自动分配的内存空间,它由系统自动释放,堆为动态分配的内存,大小不定也不会自动释放. 二.js基本数据类型与引用类型的不同 基本数据类型(boolean,undefined,null,string,number) 1.基本数据类型存放在栈内存中 是存放在栈中的简单数据段,数据大小确定,内存空间大小可以分配,是直接按值存放的,所以可以直接访问. 2.基本数据类型值不可变 js中给基本类型赋值或操作基本类型数据时,并没有改变基本类型的原

JS中深拷贝与浅拷贝的区别,实现深拷贝的几种方法

JS中深拷贝与浅拷贝的区别,实现深拷贝的几种方法 如何区分深拷贝与浅拷贝,简单点来说,就是假设B复制了A,当修改A时,看B是否会发生变化,如果B也跟着变了,说明这是浅拷贝,拿人手短,如果B没变,那就是深拷贝,自食其力. 此篇文章中也会简单阐述到栈堆,基本数据类型与引用数据类型,因为这些概念能更好的让你理解深拷贝与浅拷贝. 我们来举个浅拷贝例子: let a=[0,1,2,3,4], b=a; console.log(a===b); a[0]=1; console.log(a,b); 嗯?明明b复

js 中引用类型 的深拷贝 和 浅拷贝的区别

一.曾经在读JQ源码的时候,对深拷贝算是有了一点的理解.我们在项目中是不是经常会遇到这样的问题呢? 后台返回一个数组对象(引用类型).次数在页面渲染中需要对部分数据进行处理 比如:银行卡62345092534 (这么长) 但在页面显示的时候, 只显示中国银行(3118)但是传给后台的时候.又要传623445242整个号码,我们也许会把var oldData = res.data; 但是我们发现两个数据都变了? 这是为什么呢? 其实就是一个深浅拷贝的问题. 二.浅拷贝 比如数组,对象,这样的引用类

JS 数据类型、赋值、深拷贝和浅拷贝

js 数据类型 六种 基本数据类型: Boolean. 布尔值,true 和 false. null. 一个表明 null 值的特殊关键字. JavaScript 是大小写敏感的,因此 null 与 Null.NULL或其他变量完全不同. undefined. 变量未定义时的属性. Number. 表示数字,例如: 42 或者 3.14159. String. 表示字符串,例如:"Howdy" Symbol ( 在 ECMAScript 6 中新添加的类型)..一种数据类型,它的实例是

在vue中子组件修改props引发的对js深拷贝和浅拷贝的思考

不管是react还是vue,父级组件与子组件的通信都是通过props来实现的,在vue中父组件的props遵循的是单向数据流,用官方的话说就是,父级的props的更新会向下流动到子组件中,反之则不行.也就是说,子组件不应该去修改props.但实际开发过程中,可能会有一些情况试图去修改props数据: 1.这个props只是传递一个初始值,子组件把它当做一个局部变量来使用,这种情况一般定义一个本地的data属性,将props的值赋值给它.如下: props: ['initialCounter'],

老生常谈之js深拷贝与浅拷贝

前言 经常会在一些网站或博客看到"深克隆","浅克隆"这两个名词,其实这个很好理解,今天我们就在这里分析一下js深拷贝和浅拷贝. 浅拷贝 我们先以一个例子来说明js浅拷贝: var n = {a: 1, b: 2} var m = n m.a = 12 console.log(n.a) // ? 上面显然 n.a 的值会变为 12,这就是js浅拷贝.浅拷贝只是拷贝的指向对象的指针,本质上还是指向同一个对象. 深拷贝 同样我们还是以一个例子来说明啥叫 js deep

深拷贝与浅拷贝的区别,实现深拷贝的几种方法

JS的基本数据类型 基本数据类型:String,Boolean,Number,Undefined,Null: 引用数据类型:Object(Array,Date,RegExp,Function): 浅拷贝 浅拷贝是会将对象的每个属性进行依次复制,但是当对象的属性值是引用类型时,实质复制的是其引用,当引用指向的值改变时也会跟着变化. Object.assign. 扩展运算符 ... . Array.prototype.slice(). Array.prototype.concat() 等 深拷贝 深