1、sort

const insertSort = (arr:any, start =0, end:number) => {

    end = end === arr.length ? end : arr.length;

    for (let i = start;i < end;i++) {

        const e:any = arr[i];

        let j;

        for (j =i;j > start && arr[j -1] >e;j--)

                arr[j] = arr[j -1];

                arr[j] =e;

    }

    return arr;

}

2、promise

const PENDING ="pending"

const RESOLVE ="resolve"

const REJECT ="reject"

function MyPromise(fn) {

    const that =this

    that.status =PENDING // MyPromise 内部状态

    that.value =null // 传入 resolve 和 reject 的值

      that.resolveCallbacks = []// 保存 then 中resolve的回调函数

      that.rejectCallbacks = []// 保存 then 中reject的回调函数

// resolve 函数 Promise内部调用 resolve 函数例:new MyPromise((resolve,reject)=>{resolve(1)})

      function resolve(val) {

            if (that.status ===PENDING) {

                that.status =RESOLVE

that.value = val

                that.resolveCallbacks.forEach(cb => cb(that.value))

            }

        }

// reject 函数 Promise内部调用的 reject 函数例:new MyPromise((resolve,reject)=>{reject(1)})

          function reject(val) {

                if (that.status ===PENDING) {

                    that.status =REJECT

that.value = val

                        that.rejectCallbacks.forEach(cb => cb(that.value))

                }

            }

// 调用传入 MyPromise 内的方法例:new MyPromise((resolve,reject)=>{}) fn=(resolve,reject)=>{}

        try {

                fn(resolve,reject)

            }catch (error) {

                reject(error)

}

        }

// 在原型上添加then方法

            MyPromise.prototype.then =function (onFulfilled, onRejected) {

                const that =this

// 判断传入的是否为函数

            onFulfilled =typeof onFulfilled ==='function' ? onFulfilled : v => v

onRejected =typeof onRejected ==='function' ? onRejected : r => {

                    throw r

                }

//如果 Promise 内部存在异步代码，调用then方法时，此时 promise 内部还是 PENDING 状态，

将 then里面的函数添加进回调数组，当异步处理完成后调用 MyPromise 内部的 resolve或者

reject函数

          if (that.status ===PENDING) {

                that.resolveCallbacks.push(onFulfilled)

that.rejectCallbacks.push(onRejected)

                }

// 当 Promise 内部的状态已经为 resolve,则调用 then 里面的函数并传递值

                  if (that.status ===RESOLVE) {

                        onFulfilled(that.value)

                    }

// 当 Promise 内部状态为 reject,则调用then里的回调函数并传递值

                  if (that.status ===REJECT) {

                            onRejected(that.value)

                    }

            }

3、实现一个new方法

new原理那部分，链接到原型，obj = Object.create(Con.prototype)，这种方式会比较好

function _new(fn,...arg){

let obj = {}

let con = [].slice.call(arguments)

obj.__proto__ =con.prototype //链接原型

const ret = fn.call(obj, ...arg);//改变this的指向

return ret instanceof Object ?ret :obj;

}

4、用一个函数可实现add(1)(3)、add(1)(3)(5)，不限制个数

function add (a) {

function sum(b) { // 使用闭包

a = a + b; // 累加

return sum;

}

sum.toString = function() { // 重写toSting() 方法

return a;

}

return sum; // 返回一个函数

}

console.log(add(1)(3))

console.log(add(1)(3)(5))

5、实现一个深拷贝

function isObject(obj) {

return Object.prototype.toString.call(obj) === '[object Object]'

}

function deepCopy(source,hash= new WeakMap()){

// 判断如果参数不是一个对象，返回改参数

if(!isObject(source)) return source;

if(hash.has(source)) return hash.get(source); // 如何拷贝过该对象，则直接返回该对象

// 判断参数是对象还是数组来初始化返回值

let res = Array.isArray(source)?[]:{};

hash.set(source,res); // 哈希表添加新对象

// 循环参数对象的key

for(let key in source){

// 如果该key属于参数对象本身

if(Object.prototype.hasOwnProperty.call(source,key)){

// 如果该key的value值是对象，递归调用深拷贝方法进行拷贝

    if(isObject(source[key])){

        res[key] = deepCopy(source[key],hash);

    }else{

// 如果该key的value值不是对象，则把参数对象key的value值赋给返回值的key

        res[key] =source[key];

}

}

}

// 返回返回值

return res;

};

6、简单的深拷贝

var deepCopy = function(obj){

if (typeof obj !== 'object') return;

var newObj = obj instanceof Array ? [] : {};

for (var key in obj) {

if (obj.hasOwnProperty(key)) {

newObj[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key];

}

}

return newObj;

}

7、找出字符串中重复次数最多的字符

let str = 'dasdjkasljfkalfhjkaljdkslajdkslaadjskadjksaldjksal';

str = [...str];

let list = str.reduce((pre,cur) =>{

cur in pre?pre[cur] += 1:pre[cur] = 1

return pre

},{})

let king = Object.keys(list).reduce((pre,cur) =>{

return list[cur] > list[pre]? cur:pre;

})

console.log(king)

8、找出字符串中第2多的字符，第6改一下就行

let str = 'dasjjkasljfkalfhjkaljdkslajdkslaadjskadjksaldjksal';

str = [...str];

let flag = false;

let list = str.reduce((pre,cur) =>{

cur in pre?pre[cur] += 1:pre[cur] = 1

return pre

},{})

function b(){

let king = Object.keys(list).reduce((pre,cur) =>{

return list[cur] > list[pre]? cur:pre;

})

if(flag){

return king

}

else{

flag = true;

list[king] = 0;

return b()

}

}

console.log(list,b())

9、实现一个节流函数

防抖是延迟执行，而节流是间隔执行，函数节流即每隔一段时间就执行一次

functionthrottle(func, wait){

let timeout = null;

    return function(){

let context = this;

      let args = arguments;

if (!timeout) {

timeout = setTimeout(() => {

timeout = null;

                    func.apply(context, args)

}, wait)

}

}

}

10、实现一个防抖函数

防抖，即短时间内大量触发同一事件，只会执行一次函数

function debounce(func, wait){

let timeout = null;

return function(){

let context = this;

let args = arguments

    if (timeout) clearTimeout(timeout);

    timeout = setTimeout(() => {

    func.apply(context, args)

    }, wait)

}

}

11、实现一个二分查找

let arr = [1, 3, 5, 7, 9, 10, 13]; //数据必须是排序的，没有排序的自己排序

function search(arr, target) {

let left = 0;

let right = arr.length - 1;

while(left <= right) {

let mid = parseInt(right + left) / 2;

if (arr[mid] == target) {

return mid;

} else if (arr[mid] < target) {

left = mid + 1;

} else {

right = mid -1;

}

}

return -1;

}

console.log(search(arr, 9));