JS 递归 拷贝

最新推荐文章于 2023-12-19 19:23:16 发布
最新推荐文章于 2023-12-19 19:23:16 发布
阅读量593 收藏 2
点赞数 2
分类专栏： # JavaScript 文章标签： 递归法 js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ulrica_Amaris/article/details/108551118
版权

递归

什么是递归

递归：如果一个函数在内部可以调用其本身，那么这个函数就是递归函数。简单理解:函数内部自己调用自己, 这个函数就是递归函数

注意：递归函数的作用和循环效果一样，由于递归很容易发生“栈溢出”错误（stack overflow），所以必须要加退出条件return。

<script>
        var num = 1;
        function fn() {
            console.log('6');

            if(num == 6) {
                return; //必须加return
            }

            num++;
            fn();
        }
        fn();
    </script>

递归例子

1.阶乘

<script>
        //利用递归函数求1~n的阶乘
        function fn(n) {
            if(n == 1) {
                return 1;
            }
            return n * fn(n-1);
        }
        console.log(fn(4));

        //详细思路

        //假如用户输入3，
        //return 3 * fn(3-1)

        //fn(2) = 2 * fn(2-1);

        //return 3 * (2*fn(1))

        //fn(1)  满足n == 1  return 1;

        //return 3 * (2 * 1) = 6
    </script>

2.递归求和

//递归实现n个数字的和
function getSum(x){
    if(x==1){
       return 1;
    }
    return x+getSum(x-1);
}
console.log(getSum(5));

常规求5个数的和

//求5个数字的和
var sum=0
for(var i=0;i<6;i++){
    sum=sum+i;
}
console.log(sum);

求斐波那契数列：1，1，2，3，5，8…

function Fib(x) {
      if(x == 1 || x == 2){
        return 1
      }
      return Fib(x-1) + Fib(x-2);
    }
    console.log(Fib(12));

利用递归遍历数组

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        var data = [{
            id: 1,
            name: '家电',
            goods: [{
                id: 11,
                gname: '冰箱',
                goods: [{
                    id: 111,
                    gname: '海尔'
                }, {
                    id: 112,
                    gname: '美的'
                },]
            }, {
                id: 12,
                gname: '洗衣机'
            }]
        }, {
            id: 2,
            name: '服饰'
        }];
        //1.利用forEach遍历每一个对象
        function getID(json, id) {
            var o = {}
            json.forEach(function (item) {
                if (item.id == id) {
                    o = item;
                    return item;
                    //2.想要得到里层11 12 可以利用递归
                    //里面应该有goods这个数组 应且长度不为0
                } else if (item.goods && item.goods.length > 0) {
                    o = getID(item.goods, id) //拿到 return item 的值 并赋值给o
                }

            });
            return o;
        }
        console.log(getID(data, 1));
        console.log(getID(data, 2));
        console.log(getID(data, 11));
        console.log(getID(data, 12));
        
    </script>
</body>

</html>

结果：
在这里插入图片描述

拷贝

两种数据类型

1.基本数据类型和引用数据类型

2.基本数据类型指的是，保存在栈中的简单数据类型

3.引用数据类型则是保存在堆内存中的对象，也就是说变量中保存的是指向该对象的指针

4.基本数据类型包括：
number
string
boolean
undefined
null

5.引用数据类型：
array
object
function

浅拷贝

1.深浅拷贝的问题根源是js中不同的数据类型在内存中的存储方式不一样。

基本数据类型是以名值得形式存储在栈内存中的。

let a = 1;

Name	Value
a		1

进行赋值操作时会新开辟一片栈内存存储新的名值。

let a = 1;
let b = a;

Name	Value
a		1
b		1

2.引用数据类型：数组、对象、函数等
以上的类型会在栈内存和堆内存中分别开辟一片空间进行存储。

let a = [1,3,5,7];

在这里插入图片描述

当直接赋值时其实是将a的堆地址赋值给了b，两者最终指向了同一个堆内存

let a = [1,3,5,7];
let b = a;
在这里插入图片描述
这就是浅拷贝，带来的后果就是对b的元素进行操作时，同时改变了a对应的值。

 <script>
        // 浅拷贝只是拷贝一层, 更深层次对象级别的只拷贝引用(地址).
        // 深拷贝拷贝多层, 每一级别的数据都会拷贝.
        var obj = {
            id: 1,
            name: 'andy',
            msg: {
                age: 18
            }
        };
        var o = {};
        // for (var k in obj) {
        //     // k 是属性名   obj[k] 属性值
        //     o[k] = obj[k];
        // }
        // console.log(o);
        // o.msg.age = 20;
        // console.log(obj);

        console.log('--------------');


        Object.assign(o, obj);   //浅拷贝建议用法  ES6中新增方法
        console.log(o);
        o.msg.age = 20;
        console.log(obj);

        //修改 o的msg值  obj的msg也会修改  因为浅拷贝 拷贝的是同一个地址  
    </script>

深拷贝

1.简单粗暴，使用JSON.stringify和JSON.parse进行两次转。

let a = [1,3,5,7];
  let b = JSON.parse(JSON.stringify(a));

  b[0] = 99;
  console.log("a", a); // [1,3,5,7]
  console.log("b", b); // [99,3,5,7]

缺点：转换时会自动忽略undefined，Symbol、function

2.用递归的方法去遍历复制所有的层级

 function deepClone(obj){
    // 判断数据形式
    let clone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj === "object"){
      for(key in obj){
        if(obj.hasOwnProperty(key)){
          // 属性是对象则进行递归
          if(obj[key] && typeof obj[key] === "object"){
            clone[key] = deepClone(obj[key]);
          }else{
            clone[key] = obj[key];
          }
        }
      }
    }
    return clone;
  }
  
  let a = [1,3,5,7],
  b = deepClone(a);
  a[0] = 999;
  console.log(a); // [1,3,5,7]
  console.log(b); // [999,3,5,7]

3.for 循环：

 <script>
        // 深拷贝拷贝多层, 每一级别的数据都会拷贝.
        var obj = {
            id: 1,
            name: 'andy',
            msg: {
                age: 18
            },
            color: ['pink', 'red']
        };
        var o = {};
        // 封装函数 
        function deepCopy(newobj, oldobj) {
            for (var k in oldobj) {
                // 判断我们的属性值属于那种数据类型
                // 1. 获取属性值  oldobj[k]
                var item = oldobj[k];
                // 2. 判断这个值是否是数组  先判断数组 在判断对象，因为数组也是对象
                if (item instanceof Array) {
                    newobj[k] = [];
                    deepCopy(newobj[k], item)
                } else if (item instanceof Object) {
                    // 3. 判断这个值是否是对象
                    newobj[k] = {};
                    deepCopy(newobj[k], item)
                } else {
                    // 4. 属于简单数据类型
                    newobj[k] = item;
                }

            }
        }
        deepCopy(o, obj);
        console.log(o);

        var arr = [];
        console.log(arr instanceof Object);
        o.msg.age = 20;
        console.log(obj); //此时不会改变
    </script>

总结

1.在对象中赋值运算符 = 实现的是浅拷贝，只拷贝对象的引用值。

2.递归是做复杂深拷贝比较合理的方法。

3.JSON深拷贝只能是对象中没有function时可以使用。

4.数组的深拷贝方法较多，但是大多是只能进行第一层的深拷贝。

MichstaBe-IMUT
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
nodejs 递归拷贝、读取目录下所有文件和目录
01-20
本篇文章将详细介绍如何使用Node.js进行递归拷贝和读取目录下的所有文件和目录。 首先，我们来看递归拷贝目录的实现。在提供的代码中，定义了一个名为`copy`的函数，它接受两个参数，分别是源目录(`src`)和目标目录...
deep-copy-ts:typescriptjavascript的递归深拷贝、克隆和浅拷贝函数
06-27
总结一下，"deep-copy-ts"是一个专门针对typescript和javascript的深拷贝工具，它实现了递归深拷贝和浅拷贝功能，适用于处理复杂的对象和数组结构，同时兼容两种语言。通过使用这个库，开发者可以更轻松地管理对象的...
Go自动内存管理和优化（五）—— Go垃圾回收机制
qq_54353206的博客
02-06 708
这节课学习了自动内存管理的背景和意义，了解GO内存管理相关概念和评价方法。从垃圾回收追踪深入浅出讲解了Go垃圾回收的经典算法：复制算法，标记清除算法，标记清除压缩算法。说到了三类算法的优缺点，再到Go本身是如何合理使用三种GC算法的结合来大大降低GC的资源消耗。
深入理解GO语言垃圾回收全流程
myIddddd的博客
05-07 641
GO语言引入辅助标记，辅助清扫，系统驻留内存存储，混合写屏障等策略保证能快速执行垃圾回收而且不影响用户协程，默认下，内存达到上一次GC标记内存的2倍后触发回收。并发阶段目标是消耗25%的CPU后台标记协程，清扫阶段，GO语言采用懒清扫策略。并留1%CPU执行系统驻留内存清除。
Golang 垃圾回收内存精通
最新发布
csjds的专栏
12-19 920
在 Go 编程语言（Golang）的背景下，这是一种由 Google 开发的开源语言，垃圾回收在维护内存效率和程序稳定性方面起着关键作用。
GO进阶(5) 垃圾回收机制
黄规速博客:学如逆水行舟，不进则退
03-05 1689
当程序的内存占用达到一定阈值时，整个应用程序就会全部暂停，垃圾收集器会扫描已经分配的所有对象并回收不再使用的内存空间，当这个过程结束后，用户程序才可以继续执行，Go 语言在早期也使用这种策略实现垃圾收集，但是今天的实现已经复杂了很多。在应用程序中会使用到两种内存，分别为堆(Heap)和栈(Stack) , GC负责回收堆内存，而不负责回收栈中的内存:栈是线程的专用内存，专门为了函数执行而准备的，存储着函数中的局部变量以及调用栈，函数执行完后，编译器可以将栈上分配的内存可以直接释放，不需要通过GC来回收。
请解释一下Go语言中的垃圾回收（garbage collection）是如何工作的？
学亮编程手记
06-10 472
野指针（Dangling Pointer）是指指向已释放或无效的内存空间的指针。当程序中的指针引用了被释放的内存或者指向了无效的内存位置时，就会产生野指针。野指针的出现可能导致程序运行时的各种问题，包括崩溃、数据损坏或未定义的行为。这是因为野指针指向的内存空间可能已经被其他数据覆盖或重新分配给其他对象，所以对其进行操作会产生不可预测的结果。内存释放后未置空指针：在释放内存后，没有将指针设置为nil或NULL，导致指针仍然指向已释放的内存空间。
JavaScript 深拷贝 递归 手写
01-08
今天的学习笔记写在了自己的网页笔记本上，没有记录到博客，但是学到一个有关深拷贝的实现方法，为加深印象，这里给大家分享一下： 深拷贝：就是拷贝到最底层的属性。 function deepCopy(object){ //这里传入一个...
js 深拷贝函数
10-30
// 如果属性名不是要排除的preventName，则进行递归拷贝 if (i !== preventName) { res[i] = objectClone(obj[i], preventName); } } // 如果原对象是函数，这里创建一个新的函数实例并返回其构造函数 // ...
图解Go的垃圾回收机制
weixin_51991615的博客
04-16 5502
一、内存垃圾的是怎样产生的？ 程序在内存上被分为堆区、栈区、全局数据区、代码段、数据区五个部分。 对于某些早期的编程语言栈上的内存由编译器管理回收，堆上的内存空间需要程序员负责申请与释放。 Go中的栈上内存仍由编译器负责管理回收，而堆上的内存由编译器和垃圾收集器负责管理回收。 垃圾是指程序向堆栈申请的内存空间，随着程序的运行已经不再使用这些内存空间，这时如果不释放他们就会造成垃圾也就是内存泄漏。 下面我们举一个栗子，程序是怎样产生垃圾的 package main // 假设每个人都有自己的手机 ty
关于golang在4.4.94内核上 gc机制os内存回收不回来的问题
2301_77709688的博客
06-08 219
原本想在 kernel/mm/madvise.c加点打印看看流程的，但是发现并没有打印，最后发现最新内核并没有编译该文件，于是看了下 kernel/mm/Makefile 需要支持CONFIG_MMU（默认打开）和 CONFIG_ADVISE_SYSCALLS（默认关闭）,原来被编译裁剪了。golang gc机制回收内存最终会调用sysUnused函数，sysUnused调用的系统调用是madvise函数。背景： 在3.10内核上可以回收 4.4.94内核上不可以回收。
javascript中怎样用递归函数实现深拷贝
m0_50665842的博客
11-22 1645
【代码】javascript中怎样用递归函数实现深拷贝。
二. go 内存管理之 垃圾收集
qq_29799655的博客
04-26 318
了解垃圾收集前,先了解一下STW垃圾收集器在回收垃圾时,必须在一个能保障一致性的快照中进行的,如果不满足,分析垃圾的结果的准确性就无法保证,所以通过挂起所有用户线程来保证,这个挂起是JVM在后台自动发起的,也就是我们说的Stop the World进而引出什么时候挂起用户线程: 是在一个特定的位置挂起用户线程,这个特定的位置被称为安全点SefePoint,
golang-内存管理-GC回收
weixin_42128977的博客
08-22 1345
go 1.5 采用三色标记法，插入写屏障机制（只在堆内存中生效），最后仍需对栈内存进行STW；go 1.8 采用混合写屏障机制，屏障限制只在堆内存中生效。避免了最后节点对栈进行STW的问题，提升了GC效率；插入写屏障没有完全保证完整的强三色不变式(栈对象的影响)，所以赋值器是灰色赋值器，最后必须 STW 重新扫描栈；混合写屏障消除了所有的 STW，实现的是黑色赋值器，不用 STW 扫描栈；混合写屏障的精度和删除写屏障的一致，比以前插入写屏障要低；
js递归方式实现深拷贝
JiaPeng366的博客
06-06 2250
上篇文章提到了对象的浅拷贝和深拷贝，当时深拷贝使用的是最简单的方法，如下 JSON.parse(JSON.stringify(obj)) 这个方法能实现简单数据的深拷贝，但是对于复杂对象还是有局限性的，比如说会把时间对象转化成字符串，会丢失函数等等。 今天亲自封装一个方法，来实现深拷贝。原理就是先判断各个字段类型，然后用递归解决嵌套数据。 // 获取数据类型， js获取数据类型也有很多方法，我用了比较严谨的方法。 const getObjType = obj => { var toString =
Linux服务器查看内存使用情况
爱琴孩的博客
09-28 1116
前言 在日常开发或者生产环境，我们经常需要查看linux服务的内存使用情况，所以能熟练敲出命令能便于我们快速定位问题，这里来和大家一起学习linux的常用查看内存命令。 free命令 free命令显示系统使用和空闲的内存情况，包括物理内存、交互区内存(swap)和内核缓冲区内存。 很清晰明白的显示出了总内存多少，已使用多少，还剩下多少。这里可以看到Swap的used已使用了811Mb，服务器上跑了一个下载音频的进程，物理内存已经不够用了，所以从磁盘中虚拟出一部分的内存。当然我们可以使用free.
golang 内存管理 + 垃圾回收
wwhhff11
05-11 5746
tmcalloc 参考链接 分配内存策略：全局缓存堆 + 进程私有缓存 对于小容量的内存申请，优先尝试进程私有缓存，若私有缓存不足，则向全局缓存申请。 对于大容量的内存申请，直接向全局缓存申请。 进程私有缓存：单链表数组，默认分配86个大小不同的块，每个块上的数组使用才初始化。 全局缓存堆：单链表数组，一共会分配256个不同大小的块，1 page = 4k，链表对应数组每个元素page递增...
golang的垃圾回收（GC）机制
热门推荐
两只羊的博客
09-26 1万+
请先阅读 golang的goroutine调度机制 然后再到这里   golang的垃圾回收采用的是 标记-清理（Mark-and-Sweep） 算法 就是先标记出需要回收的内存对象快，然后在清理掉； 在这里不介绍标记和清理的具体策略，只介绍 GC过程是怎么调度的以及stw相关 这个算法，会导致 stw (stop the world) 的问题，中断用户逻辑 触发GC机制 1.
Go语言内存回收机制GC
bingshiwuyu的专栏
07-16 2129
前言 文章有点长，如果是刚接触GC建议耐心看完 所谓内存回收，便是指当前内存使用完毕，释放当前存储器，以供后续继续使用，如果没有进行及时的释放，则会造成内存泄漏 常见的GC方式有如下三种 引用计数：对每一个对象维护一个引用计数，当引用该对象的对象被销毁的时候，引用计数减1，当引用计数为0的时候，怎回收该对象，比如c++的shared_ptr 优点 ：对象可以很快的被回收，不会出现内存耗尽或达到某个阀值时才回收。 缺点：不能很好的处理循环引用，而且实时维护引用计数，有也一定的代价。 代表语言：Pytho
js深拷贝的递归方法
09-20
深拷贝是指将一个对象完全复制一份，包括其所有属性和子对象。在JavaScript中，可以使用递归方法实现深拷贝。递归方法的原理是遍历对象或数组，直到遍历到基本数据类型为止，然后再进行复制。以下是一个示例代码： ``` function deepCopy(obj) { let newObj = {}; if (typeof obj === 'object') { for (let key in obj) { newObj[key] = deepCopy(obj[key]); } } else { newObj = obj; } return newObj; } ``` 这个方法首先创建一个空对象newObj，然后判断传入的参数obj是否为复杂数据类型。如果是，就遍历obj的每一个属性，并将其递归地复制到newObj中。如果不是复杂数据类型，直接将obj赋值给newObj。最后，返回newObj作为深拷贝的结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值