2022.6.10. 防抖 节流 深拷贝(递归 $extend) 数组去重 冒泡 扁平化 序列化转对象 随机数不重复

防抖

btn1.onclick = deBounce();//防反跳
			function deBounce(){
				var timer = null;//借助闭包
				return function(){
					if(timer){
					//进入说明正在一个分支语句,触发相同事件,要取消计时,重新当前计时
						clearTimeout(timer);
					                  timer = setTimeout(function(){
						console.log("两秒后我输出了");
					},2000)}

					}else{
					timer = setTimeout(function(){
						console.log("两秒后我输出了");
					},2000)}
				}
			}

2节流

btn2.onclick = throttle();//节气门
			function throttle(){
				var flag = true;
				return function(){
					if(!flag)return;
					flag = false;
					setTimeout(function(){
						console.log("两秒后我输出了");
						flag = true;
					},2000)
				}
			}

3.递归深拷贝

function deepClone(obj){
			var o = Array.isArray(obj) ?  [] : {};
			for(var k in obj){
				o[k] = typeof obj[k] === "object" ? arguments.callee(obj[k]) : obj[k]
				}
				return o;
			}
			 原生js深度克隆步骤
			 步骤1.因为深度克隆只针对对象,也就是数组或对象吧,判断是数组还是对象
			 步骤2:遍历数据中的值,判断是否是对象,若是对象,则再调用深度克隆这个函数本身,若不是,则直接赋值
			 步骤3:返回新的数据

 $extend  深拷贝   b  深拷贝到a  并返回 a

var c = $.extend( "true",a,b);
b.name = 'cccc';

JSON 深拷贝

JSON.parse(JSON.stringify(obj))

$extend 浅拷贝  b  浅拷贝到a  并返回 a

var c = $.extend(a,b);
b.name = 'cccc';

4.数组去重

1  [...new Set(arr)]

 	2. 数组去重
                 	;(function(){
     		var arr = [12,52,52,62,12,85,12,81,12,15];
     		//这是创建有内容数组
     		var arr1 = [];
     		//创建空数组
     		for(var i=0;i<arr.length;i++){
     			//列举数组中每一个元素
     			if(arr1.indexOf(arr[i]) == -1){
     				//利用indexOf(数组下标法) 判断arr1数组里面是否存在arr[i]元素 
     				arr1.push(arr[i]);
     					//在arr1中利用push(末尾添加数组元素) 来加入arr[i]元素
     			}
     		}
     		console.log("arr1",arr1);
     		//打印arr1
     	}())

	3. // 对象 ： key 唯一
	    // 数组去重复
	    /*
	        let arr=[3,4,5,2,4,5]; // [3,4,5,2]
	            
	        let obj={3:3,4:4,5:5,2:2,4:4,5:5}
	                 // {3:3,4:4,5:5,2:2}
	                 // 提取 对象的值
	                         1、循环 对象 push
	                         2、Object.values(obj)  [3,4,5,2]
	    */

`	3---1
		 let arr=[3,4,5,2,4,5]; 
        let obj={};
        for(let i =0;i<arr.length;i++){
            obj[ arr[i] ] =arr[i]
        }

------------------------------------------

​            console.log(obj)
​	  let arr2= Object.values(obj)
​            console.log(arr2);

--------------------------------------

let arr2=[];
            for(let key in obj){
                arr2.push( obj[key] )
            }
            console.log(arr2)

4.数组冒泡

for(var i=0;i<arr.length;i++){
				//这是提取数组每一个元素
				for(var j=i+1;j<arr.length;j++){
					//这是提取上一个数组后面的元素
					if(arr[i]>arr[j]){
						//这是判断语句     //以 i=25  j= 1 
						var c = arr[j];
						   // C = [J] (C = 1  J = 未定)
						arr[j] = arr[i];  
						//[J]  =  [i] (因为J未定 被I 赋值  所以  J = 25 ) (I未定)
						arr[i] = c;		
						//[I] = [C] ( 因为I 未定  被C 赋值  所以  I = 1 ) (C未定)
						//(此时  I = 1  J = 25  C= 未定 )
						//这是上述俩个数组的替换
					}
				}
			}
			console.log("arr:",arr);
		}())

5.数组扁平化

let a=[];
function f(arr){
    for(let v of arr){
        if(Array.isArray(v)){
            f(v);
        }else{
            a.push(v);
        }
    }

}
f( arr )

6.序列化转对象

 window.onhashchange = function () {
            console.log("location.hash", location.hash);
            var str = location.hash.slice(3)
            console.log("str", str);  //a=1&b=2&c=3&d=4&e=5&f=6
            var arr = str.split("&");
            console.log("arr", arr); //['a=1', 'b=2', 'c=3', 'd=4', 'e=5', 'f=6']
            let obj = {};
            for (var i = 0; i < arr.length; i++) {
                var arr1 = arr[i].split("=");
                console.log("arr1", arr1);
                obj[arr1[0]] = arr1[1]
            }
            console.log("obj", obj);
        }

7.不重复的随机数

 function fn(min, max) {
            var arr = [];
            for (var i = 0; i < Math.abs(max - min) + 1; i++) {
                var num = randomFn(min, max);
                if (!arr.includes(num)) {
                    arr.push(num);
                } else {
                    i--;
                }
            }
            return arr;
        }

        function randomFn(min, max) {
            return
            Math.floor(Math.random() * (Math.abs(max - min) + 1) + (max > min ? min : max));
        }
    
        // 改动参数
        var arr = fn(800, 700);
        console.log("不重复数组:", arr);