前端面试总结（一年主vue）

先说不足之处，框架原理理解不够，蜻蜓点水一般，跨域几种方式的优缺点也没说出来，对于组件库的概念理解不深刻

Vue了解下webpack，根据生产、开发环境配置参数了解下

https://blog.csdn.net/lian772882/article/details/81364644

前端面试

https://github.com/gujianxiang95/Web/tree/master/14-%E5%89%8D%E7%AB%AF%E9%9D%A2%E8%AF%95

 

Es6清除promise\class\async await 和数组方法

数组方法总结

https://segmentfault.com/a/1190000008147878

 

 

sass（scss）10大常用重要特性

https://www.cnblogs.com/wangyanhua95/p/8565284.html  

用reduce实现call\apply\bind

Function.prototype.mycall = function (ctx,args){
    ctx.fn = this; // 仅能将被期望修改this指向的函数   传递为期望环境的某个方法
    // 此时的ctxfn的this被重定向为 期望绑定环境ctx的this,运用的虽然是被调用函数的方法，this确指向ctx
    res = ctx.fn(...args); 
    return res
}

 

 

 

用reduce实现map/filter

Array.prototype._map = function(callback){

    if(typeof callback !== 'function'){

        console.log('callback is not function ')

        return

    }

    return this.reduce((total,item,index,arr)=>{

        total.push(callback(item,index,arr))

        return total

    },[])

}

Array.prototype._filter = function(callback){

    if(typeof callback !== 'function'){

        console.log('callback is not function ')

        return

    }

    return this.reduce((total,item,index,arr)=>{

        if(callback(item,index,arr)){

        total.push(arr[index])

    }

    return total

    },[])

}

Array.prototype.getMax = function(){

    return this.reduce((pre,item,index,arr)=>{

        return Math.max(pre,item)

    })

}

//去重

Array.prototype.removal = function(){

    return this.reduce((total,item,index,arr)=>{

        !total.includes(item) && total.push(item)

        return total

    },[])

}

//数组扁平化

function _flat(arr){

    return arr.reduce((total,item,index,arr)=>{

        return Array.isArray(item)?total.concat(_flat(item)):total.concat(item)
    
    },[])

}

 

稳定性：排序后2个相等键值的顺序和排序之前它们的顺序相同

 

//冒泡 n2依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。

function bubble(arr){

    for(let i = 0;i<arr.length;i++){

        for(let j = 0 ;j<arr.length-i;j++){

            if(arr[j]>arr[j+1]){

                [arr[j],arr[j+1]] = [arr[j+1],arr[j]];

            }

        }

    }

    return arr

}

 

选择排序（Selection Sort）

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。

function choice(arr){
    for(let i = 0;i<arr.length;i++){

        let item = i

        for(let j = i ;j<arr.length-1;j++){

            if(arr[item]>arr[j+1]){

                item = j+1

            }
        }

        [arr[item],arr[i] ] = [arr[i],arr[item] ];

    }

    return arr

}

插入排序（Insertion Sort）

如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序

function insert(arr){

    for(let i = 1;i<arr.length;i++){

        let item = arr[i]

        for(var j=i;j>0&&item<arr[j -1];j--){

            arr[j] = arr[j-1]

        }

        arr[j] = item

    }

    return arr

}

 

希尔排序

 

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

//希尔排序

function shell(arr){

    let len = arr.length,

    gap = 1,temp

    for(gap;gap>0;gap=Math.floor(gap/3)){

        for(let i = gap;i<len;i++){

            temp = arr[i]

            for(j = i-gap;j>=0&&temp<arr[j];j-=gap){

                arr[j+gap] = arr[j]

            }

            arr[j+gap] = temp

        }

    }

    return arr

}

 

归并排序

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

//归并排序

function mergeSort(arr){

    let len = arr.length

    if (len <= 1) {

        return arr;

    }

    let middle = len/2

    let left = arr.slice(0,middle)

    let right = arr.slice(middle,len)

    return merge(mergeSort(left),mergeSort(right))

}

function merge(left,right){

    let arr = []

    while(left.length&&right.length){

        if(left[0]<right[0]){

            arr.push(left.shift())

        }else{

            arr.push(right.shift())

        }

    }

    while(left.length){

        arr.push(left.shift())

    }

    while(right.length){

        arr.push(right.shift())

    }
    
    return arr

}

 

 

快速排序（Quick Sort）

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 

function quick(arr){

    let len = arr.length

    if(len<2){

        return arr

    }

    let povitIndex = len/2

    let povit = arr.splice(povitIndex,1)[0]

    let left=[],right=[]
    
    for(let i = 0;i< arr.length;i++){

        if(arr[i]<=povit){

            left.push(arr[i])

        }else{

            right.push(arr[i])

        }

    }

    return quick(left).concat([povit],quick(right))

}