web前端面试题总结

• 判断是否为字符串

function isString (val) {
    return Object.prototype.toString.call(val) === "[object String]"
}

• 将函数柯里化

function currying(func) {
    var len = func.length;
    var getCurry = function(params) {
        return function() {
            var next = params.concat(Array.prototype.slice.call(arguments));
            if (len - next.length <= 0) {
                return func.apply(this, next);
            }
            return getCurry(next);
        };
    };
    return getCurry([]);
}

• 重复数组中元素

function duplicate(arr) {
    return arr.concat(arr);
}

• 实现一个继承 (继承的实现几种方式，原型链继承、类式继承实现方法) 组合继承：

function Parent (name) {
    this.name = name;
}

Parent.prototype.getName = function() {
    return this.name;
};

function Son (parentName, name) {
    this.childName = name;
    Parent.call(this, parentName);
}

Son.prototype = new Parent();//or Son.prototype = Object.create(Parent);

Son.prototype.constructor = Son;

Son.prototype.getChildName = function(){
    return this.childName;
};

• 数组各种方法简记

    concat() 连接两个或更多的数组，并返回结果。
    join()  把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
    pop()   删除并返回数组的最后一个元素
    push()  向数组的末尾添加一个或更多元素，并返回新的长度。
    reverse()   颠倒数组中元素的顺序。
    shift() 删除并返回数组的第一个元素
    slice() 从某个已有的数组返回选定的元素
    sort()  对数组的元素进行排序
    splice()    删除元素，并向数组添加新元素。
    toSource()  返回该对象的源代码。
    toString()  把数组转换为字符串，并返回结果。
    toLocaleString()    把数组转换为本地数组，并返回结果。
    unshift()   向数组的开头添加一个或更多元素，并返回新的长度。
    valueOf()   返回数组对象的原始值
 * es5新增方法array
    forEach (js v1.6) 循环遍历数组
    map (js v1.6) 返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组
    filter (js v1.6) 返回一个由原数组中的每个元素调用一个指定方法后的返回值为真的元素组成的新数组
    some (js v1.6)返回数组中是否有某个元素满足指定方法返回值为真元素，有则返回true，否则false
    every (js v1.6) 数组每个方法测试数组中的所有元素是否经过所提供的函数来实现测试
    indexOf (js v1.6) 返回数组中第一某个元素的首次出现的索引值，不存在则返回-1 
    lastIndexOf (js v1.6)返回数组中第一某个元素的最后一次出现的索引值，不存在则返回-1 
    reduce (js v1.8) 对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果，并且此返回值在下一次调用该回调函数时作为参数提供
    reduceRight (js v1.8)按降序顺序对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果，并且此返回值在下一次调用该回调函数时作为参数提供。

• 类似_.map实现

function map (array, cb, ctx) {
    var arr = [];
    /*array.forEach(function(i ,index){
        arr.push(cb.call(ctx, i, index, arr));
    });*/
    for (var i = 0; i< array.length; i++) {
        arr.push(cb.call(ctx, array[i], i, arr));
    }
    return arr;
}
var test = [{name : 'nan', age: 25}, {name : 'bei', age : 33}];
var map2 = map (test, function(i){
    return i.age * this;
},5);

• _.reduce实现

function reduce (array, cb, init) {
    /*var base = typeof init === 'undefined' ? arr[0] : init;
    var stepForward = typeof init === 'undefined' ? 1: 0;
    var startPoint = stepForward;
    array.slice(startPoint)
         .forEach(function(val, index){
            base = cb(base, val, index + stepForward, arr);
         });
    return base;*/
    var base = init ? init : '';
    for (var i = 0; i< array.length; i++) {
        base = cb(base, array[i], i, base);
    }
    return base;
}
var test = [{name : 'nan', age: 25}, {name : 'bei', age : 33}];
var reduce1 = reduce(test, function(previous, i) {
    return previous + i.name + ' ';
}, 'hello ');
console.log(reduce1);

• 获取原始数据值

function releasedValue(anything) {
    if (Object.prototype.toString.call(anything) !== '[object Function]') {
        return anything;
    }
    return releasedValue(anything());
}

//_.find
function find(array, cb) {
    var arr = [];
    for (var i = 0; i< array.length; i++) {
        if (cb(array[i], i)) {
            arr.push(array[i]);
        }
    }
    return arr;
}

var arr = [{name:'上海', size : 6300}, {name : '北京', size : 16520}];
var found = find(arr, function(i){
    return i.name === '上海';
});

• _.findlast array.lastIndexOf

function findlast(array, cb) {
    for (var i = array.length - 1; i >= 0; i--) {
        if (cb(array[i], i)) {
            return array[i];
        }
    }
    return -1;
}

• findmost

var findmost = function(array, identity) {
    var occurrence = {};
    var most;
    for (var i = 0; i < array.length; i++) {
        var item = array[i];
        var id = identity ? identity(item) : item;
        if (!occurrence[id]) {
            occurrence[id] = {count: 1, raw: item};
        } else {
            occurrence[id].count++;
        }
        if (!most || (most !== id && occurrence[id].count > occurrence[most].count)) {
            most = id;
        }
    }
    return occurrence[most].raw;
};

• 冒泡排序

function maopao(arr) {
    var i,j,temp;
    for (i = 0; i < arr.length; i++) {
        for (j = 0; j < arr.length; j ++) {
            if (arr[i] < arr[j]){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

• 1 9 20 3 5 10 to 1 20 3 10 5 9

function sortarr(arr) {
    var _arr = [];
    arr.sort(function(a, b){
        return a - b;
    });
    function get_arr (arr1) {
        if (arr1.length > 2) {
            _arr.push(arr.shift());
            _arr.push(arr.pop());
            return get_arr(arr1);
        }
        if (arr1.length === 2){
            _arr.push(arr.shift());
            _arr.push(arr.pop()); 
        }
        if (arr1.length === 1) {
            _arr.push(arr.shift());
        }
        return _arr;
    }
    return get_arr(arr);  
}