其它

几个简单的前端算法

因为是个野生前端，很多科班的东西都没有系统的学习。曾经，因为不会二分法查找被鄙视了，后来发现有个大神也因为不会二叉树挂了，是不是觉得我们很像，233…

说算法感觉跟高深，其实一些简单的算法还是挺值得我们去学习的，下面我就列出几个简单的算法吧。

二分法查找

在哪里跌倒就在哪里站起来，先说说二分法吧。简单点说就是把一组数据按大小排序后分成两组，取中间值。如果比中间值大，就把后面的组分成两组，直到找到这个元素。

用递归实现：

function binarySearch(data, dest, start, end){
    var end = end || data.length - 1,
        start = start || 0,
        m = Math.floor((start + end) / 2);
    if(data[m] == dest){
        return m;
    }
    if(dest < data[m]){
        return binarySearch(data, dest, 0, m-1);
    }else{
        return binarySearch(data, dest, m+1, end);
    }
   
    return false;
}
var arr = [-34, 1, 3, 4, 5, 8, 34, 45, 65, 87];
binarySearch(arr,4);//3

非递归实现：

function binarySearch(data, dest){
    var h = data.length - 1,
        l = 0;
    while(l <= h){
        var m = Math.floor((h + l) / 2);
        if(data[m] == dest){
            return m;
        }
        if(dest > data[m]){
            l = m + 1;
        }else{
            h = m - 1;
        }
    }
   
    return false;
}
var arr = [-34, 1, 3, 4, 5, 8, 34, 45, 65, 87];
binarySearch(arr,4);//3

快速排序

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr; //如果数组只有一个数，就直接返回；
    }
    var num = Math.floor(arr.length / 2); //找到中间数的索引值，如果是浮点数，则向下取整
    var numValue = arr.splice(num, 1); //找到中间数的值
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] < numValue) {
            left.push(arr[i]); //基准点的左边的数传到左边数组
        } else {
            right.push(arr[i]); //基准点的右边的数传到右边数组
        }
    }
    return quickSort(left).concat(numValue, quickSort(right)); //递归不断重复比较
}

翻转字符串

function reverse(str){
    return str.split("").reverse().join("")
}

数组去重

ES6

const arr = [1, 1, 2, 3, 4, 4, 5, 5];
[...new Set(arr)]; //[1,2,3,4,5]
//或者
Array.from(new Set(arr))

老方法：

// 通过空数组
function unique(array){ 
    var n = [];
    for(var i = 0; i < array.length; i++){
        if (n.indexOf(array[i]) == -1){
            n.push(array[i]); 
        }
    } 
    return n; 
}
// 排序法
function unique(array){ 
    array.sort(); 
    var re=[array[0]]; 
    for(var i = 1; i < array.length; i++){ 
        if( array[i] !== re[re.length-1]){ 
            re.push(array[i]); 
        } 
    } 
    return re; 
}

阶乘

function factorial(num) {
    if(num <= 1) {
        return 1;
    } else {
        return num * factorial(num - 1); 
    }
}

斐波那契数列

function fib(n){
    if(n==1||n==2){
        return 1;
    }
    return fib(n-1)+fib(n-2);
}

千分位

正则：

//不包括小数
function thousands(num){
    var re=/(?=(?!(\b))(\d{3})+$)/g;
    return num.replace(re,",");
}
//包括小数怎么办？先从小数点分开，处理之后合并

非正则：

//补足3位再分割
function thousands(num){
    var num = (num || 0).toString(), temp = num.length % 3;
        switch (temp) {
        case 1:
            num = '00' + num;
            break;
        case 2:
            num = '0' + num;
            break;
    }
    return num.match(/\d{3}/g).join(',').replace(/^0+/, '');
}
//直接操作
function thousands(num) {
    var num = (num || 0).toString(), result = '';
    while (num.length > 3) {
        result = ',' + num.slice(-3) + result;
        num = num.slice(0, num.length - 3);
    }
    if (num) {
        result = num + result;
    }
    return result;
}

总结

就这几个，背下来吧。