JS常见手写代码题（一）

1、call bind apply
call 、bind 、apply三个都是用来改变函数的this对象的指向，第一个参数都是this要指向的对象，也就是想指定的上下文。call和apply是立即调用函数，而bind是返回一个函数，需要调用的时候再执行。三者的实现如下：

//方法或函数.call(obj, [参数1，参数2，...])
Function.prototype.call = function(ctx){
    ctx = ctx || window
    ctx.fn = this
    let arg = [...arguments].slice(1) //arguments是个类数组，不是个数组，则需先转换成数组
    let res = ctx.fn(arg)
    delete ctx.fn
    return res
}

//方法或函数.apply(obj,  参数1，参数2，...)
Function.prototype.apply = function(ctx){
    ctx = ctx || window
    ctx.fn = this
    let arg = arguments[1]
    let res = ctx.fn(arg)
    delete ctx.fn
    return res
}

//方法或函数.bind(obj)
Function.prototype.bind = function(ctx){
    let fn = this
    return function(){
        fn.apply(ctx, arguments) //arguments是函数调用时所传参数
    }  
}

2、浅拷贝与深拷贝
浅拷贝只复制对象的第一层属性、深拷贝是对对象的属性进行递归复制。

//浅拷贝   （obj1为所要拷贝的对象）
//方式一：原始版本（obj1为所要拷贝的对象，obj2已经默认为一个对象）
function shallowCopy(obj1, obj2){
    for(let key in obj1){
        obj2[key] = obj1[key]
    }
}
//方式一：优化版本（obj为所要拷贝的对象）
function shallowClone(obj){
    if(typeof obj !== 'object' || obj == null){
        //obj是null，或者不是对象和数组，直接返回
        return obj
    }
    let result
    if(obj instanceof Array){
        result = []
    }else{
        result = {}
    }
    for(let key in obj){// for in 遍历对象可枚举属性，包括其原型的属性和方法， 
        if(obj.hasOwnProperty(key)){ //保证key不是原型的属性
            //递归调用
            result[key] = obj[key]
        }
    }
    //返回结果
    return result
}
//方式二
function shallowCopy(obj1, obj2){
    obj2 = Object.assign({}, obj1)
}

//深拷贝   （obj1为所要拷贝的对象）
//方式一：原始版本（obj1为所要拷贝的对象）   
function deepCopy(obj1, obj2){
    for(let key in obj1){// for in 遍历对象可枚举属性，包括其原型的属性和方法， 可用obj1.hasOwnPerporty(key)判断这个实例是否有这个属性
        let item = obj1[key] 
        if(item instanceof Array){ // 不能用typeof  item，因为不能区分对象和数组
            obj2[key] = []
            deepCopy(item, obj2[key])
        }else if(item instanceof Object){
            obj2[key] = {}
            deepCopy(item, obj2[key])
        }else{
            obj2[key] = item
        }
    }
}
//方式一：优化版本（obj为所要拷贝的对象，obj2已经默认为一个对象）
思路：1、判断是否是值类型还是引用类型。2、判断是数组还是对象。3、递归
function deepClone(obj){
    if(typeof obj !== 'object' || obj == null){
        //obj是null，或者不是对象和数组，直接返回
        return obj
    }
    let result
    if(obj instanceof Array){
        result = []
    }else{
        result = {}
    }
    for(let key in obj){// for in 遍历对象可枚举属性，包括其原型的属性和方法， 
        if(obj.hasOwnProperty(key)){ //保证key不是原型的属性
            //递归调用
            result[key] = deepClone(obj[key])
        }
    }
    //返回结果
    return result
}
缺陷：当遇到两个互相引用的对象，会出现死循环的情况。
//方式二  
function deepCopy(obj1, obj2){
    obj2 = JSON.parse(JSON.stringify(obj1))
}
缺陷：这种方法不能拷贝函数属性

3、字符串转驼峰，如：jin-bang转为jinBang

function change(str) {
    let arr = str.split('-')
    str = str.map((item, index) => {
        index === 0 ? item : item.charAt(0).toUpperCase() + item.substring(1)
    })
    return str.join('')
}

4、数组扁平化
方式一：ES6 新特性

let arr = [[1,2,2], [6,7,8, [11,12, [12,13,[14]]], 10]]
arr = arr.flat(infinity)

方式二：循环

let arr = [[1,2,2], [6,7,8, [11,12, [12,13,[14]]], 10]]
while(arr.map(item => Array.isArray(item))){//只要有一个元素是数组就对arr进行一次扁平化
    arr = [].concat(...arr) //不能[...arr] ，arr时刻在变化
}
//给Array添加原型方法
Array.prototype.flat = function(n = 1){
    let arr = this
    let res = 0
    while(arr.some(item => 
        Array.isArray(item)       
    )){
        arr = [].concat(...arr)
        res++
        if(res === n){
            return arr
        }
    }
}

方式三：递归

let arr = [[1,2,2], [6,7,8, [11,12, [12,13,[14]]], 10]]
function flatten(arr){
    let res = []
    arr.forEach(item => {
        if(Array.isArray(item)){//判断item是否为数组
            res = res.concat(flatten[item])
        }
        res.push(item)
    })
    return res
}

5、数组去重
方式一：ES6新特性

let arr = [1,1,2,3,2,1,2]
let set = new Set(arr)
arr = [...set]  //或者arr = Array.from(set)      Array.from() 将伪数组转换为数组

方式二：循环遍历的方式

function unique(arr){
    let res = []
    for(let i = 0; i < arr.length; i++){
        if(!res.includes(arr[i])){ // if判断语句中也可以是!res.indexOf(arr[i])
            res.push(arr[i])
        }
    }
    return res
}

方式三：hash表的方式

let arr = [1,1,2,3,2,1,2]
function unique(arr){
    let obj = {}
    arr.forEach((item) => {
        obj[item] = true
    })
    let keys = Object.keys(obj)
    keys = keys.map(item => parseInt(item))
    return keys
}
console.log(unique(arr))

方式四：

var arr = [1, 2, 3, 3, 4, 2]
var newArr = arr.reduce((pre, cur) => {
    if (!pre.includes(cur)) {
        return pre.concat(cur)
    } else {
        return pre
    }
}, [])
console.log(newArr)

6、实现检测数据类型中的instanceof，其原理是用原型链实现的，A(实例对象) instanceof B(构造函数)。

function instanceof(left, right){
    let proto = left._proto_
    let prototype = right.prototype
    while(true){
        if(proto === null) return false
        if(proto === prototype) return true
        proto = proto._proto_
    }
}