贴一点最近写的代码

(function() {

//节流函数 在特定时间内只会被出发一次
function throttle(fn, timer) {
    var flag = false;
    return function() {
        if (!flag) {
            flag = true;
            setTimeout(function() {
                fn.apply(this, arguments);
                flag = false;
            }, timer);
        }
    };
}
function scrollEvent() {
    console.log("scroll");
}
window.addEventListener("scroll", throttle(scrollEvent, 300));

//防抖函数 在指定时间内不再被调用，则执行,只执行最后一个
function debounce(fn, timer) {
    var timeout = null;
    return function() {
        clearTimeout(timeout);
        timeout = window.setTimeout(function() {
            fn.apply(this, arguments);
        }, timer);
    };
}
window.addEventListener("scroll", debounce(scrollEvent, 300));

// call  接受柯里化参数，改变this指向，返回函数执行结果
var obj = {
    a : 'cvb',
    b : 22
};
var a = "bnm", b = 23;
function test1() {
    console.log("a", this.a);
    console.log("b", this.b);
}
test1();

Function.prototype.myCall = function(context, ...argus) {
    context = context || window;
    let fn = Symbol(context);
    context[fn] = this;
    let result = context[fn](...argus);
    delete context[fn];
    return result;
};

// bind 返回改变this指向的函数，接受柯里化传参，如 myBind(obj)(1,2,3)
Function.prototype.myBind = function(context) {
    context = context || window;
    let argus = [...arguments].slice(1);
    let self = this;
    return function() {
        let arg = [...arguments];
        return self.apply(context, argus.concat(arg));
    };

};

test1.myCall(obj);

/**
 * 常见排序算法
 */
let arr = [5,7,3,2,4,6,79,23,4,6,67]
/**
 * 冒泡排序
 * 比较相邻的两个数，是否按正确顺序排列，循环至无可交换数据。
 */
function sort1(arr){
    var flag = false;
    while(!flag){
        flag= true;
        for(var i=0;i<arr.length;i++){
            if(arr[i]>arr[i+1]){
                flag = false;
                var tmp = arr[i+1];
                arr[i+1] = arr[i];
                arr[i] = tmp;
            }
        }
    }
}
/**
 * 选择排序
 * 每次查找最小的数一次插入排序后数组
 * 时间复杂度o(n^2)
 */
function sort2(arr){
    for(var i=0;i<arr.length;i++){
        let minIndex = i;
        for(var j=i+1;j<arr.length;j++){
            if(arr[j]<arr[minIndex]) minIndex = j;
        }
        let tmp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = tmp;
    }
}
/**
 * 插入排序
 * 从未排序序列中依次选择元素，将其插入已排序数组的合适位置（插入时按照从后向前查找，便于将元素进行移动）
 */
function sort3(arr){
    let newArr = [arr[0]];
    for(var i=1;i<arr.length;i++){
        let item = arr[i];
        for(var j=newArr.length-1;j>=0;j--){
            if(newArr[j]<=item){
                newArr[j+1] = item;
                break;
            } else {
                newArr[j+1] = newArr[j];
                if(j==0){
                    newArr[0] = item;
                }
            }
        }
    }
    return newArr;
}
/**
 * 快速排序
 * 选取一个数作为基准将数据分为两部分，一部分小于基准数，一部分大于基准数，再用递归对每一部分进行同样操作
 */
let arr3 = [4,7,2,3,56,45,75,22,67]
function quickSort(arr){
    // todo
}
function swap(arr,i1,i2){
    let tmp = arr[i1];
    arr[i1]=arr[i2];
    arr[i2]=tmp;
}
quickSort(arr3);

// 正则表达式
str.test(/^1(\d){10}/)

// promise async/await generator
var fn = new Promise(function(resolve,reject){
    setTimeout(function(){
        console.log("doe timeout");
        resolve(200);
    },200);
})
fn.then(function(data){
    console.log("data: "+data);
})

/**
 * async是promise的语法糖，使用async修饰时，会自动将函数包装为一个promise对象
 */
// 使用async/await 重写
fetch('coffee.jpg')
    .then(response => response.blob())
    .then(myBlob => {
        let objectURL = URL.createObjectURL(myBlob);
        let image = document.createElement('img');
        image.src = objectURL;
        document.body.appendChild(image);
    }).catch(e => {
        console.log('There has been a problem with your fetch operation: ' + e.message);
    });

//等价为
async function myFetch(){
   let response =  await fetch('coffee.jpg');
   let myBlob = await  response.blob();
   let objectURL = URL.createObjectURL(myBlob);
   let image = document.createElement('img');
   image.src = objectURL;
   document.body.appendChild(image);
} 



/**
 * 记一次羞辱式面试（bytedance）
 * 题目不难，还是怪自己平时代码撸的少，come on!!!
 */

// 1、手动实现flat
// 初版
Array.prototype.myFlat = function(target){
    let arr = this;
    arr.forEach(itm => {
        if(Array.isArray(itm)){
            itm.myFlat(target);
        } else {
            target.push(itm);
        }
    })
}
// 改造：如何不传参实现返回合并后数组
Array.prototype.myFlat = function(){
    var itm = JSON.parse(JSON.stringify(this));
    var target = [];
    function mapArr(itm){
        itm.forEach(_i => {
            if(Array.isArray(_i)){
                mapArr(_i);
            } else {
                target.push(_i);
            }
        });
    }
    mapArr(itm);
    return target;
}

// 2、实现一个定时器 
// 实在不知道她想让我做些啥 ^&%*&^$(#~#$#@%$#%(^*))

// 3、将数组转化为链表
function arr2list(arr){
    
    //结点构造函数
    function Node(value,next){
        this.value = value;
        this.next = next;
    }
    // 初始化当前节点
    let cNode = null;
    for (var i = arr.length-1; i >= 0; i--){
        let nextNode = i==arr.length-1 ? null : cNode;
        cNode = new Node(arr[i],nextNode);
    }
    // 返回链表首结点
    return cNode;
}

let arr = [5,6,7,2,4,1];

//打印转化后的链表数据
function printList(node) {
    if(node.value){
        alert(node.value);
    }
    if(node.next){
        printList(node.next);
    }
}
printList(arr2list(arr));

})();