记一次小米前端面试题

这两天参加了一次小米的面试，面试方式比较随意，直接用微信聊的。感觉面试题有些意思，所以想记下来，也使我学到了不少东西。

Q:

定义这样一个函数

function doRepeat(func, times, wait) {

}

参数分别是需要 repeat的函数， repeat的次数，每次repeat的间隔

使用方式如下：

调用这个函数能返回一个新函数，比如传入的是alert，这个函数的调用就是
var repeatedFun = doRepeat(alert, 10, 5000);

调用返回的这个新函数，如: repeatFun("hellworld");

会依次alert十次 helloworld，每次间隔5秒

这个题目很简单，单从要求来看考验的是闭包函数，所以我们只需要使用延时函数再return一个函数就能达到要求，答案网上也能查到。我使用setInterval函数实现的，这里只给出部分关键性代码。

function doRepeat(func, times, wait) {
    // 检查参数是否存在
    if (!func || !times || !wait) {
        return function () { };
    }
    // 检查参数类型
    if (!checkType(func, ['function']) && !checkType(times, ['Number', 'String']) && !checkType(wait, ['Number', 'String'])) {
        return function () { };
    }
    // 进行不规则类型的类型转换
    times = exchange(times, 'Number');
    wait = exchange(wait, 'Number');
    let i = 0;
    return function repeat() {
        const _args = arguments;

        const handler = setInterval(function () {
            if (i == times) {
                clearInterval(handler);
                return;
            }
            func(_args[0]);
            i++;
        }, wait)
    }
}

这个函数非常简单，请在十分钟内完成就好。但是这里想说一下几个要点：

• 一个是程序的可用性：即程序是否可以正常运行，这个是最基本的条件，如果不能达到请自觉面壁30秒。

• 另外一个是程序的健壮性：是否检查传参的完整性？是否检查参数类型？我想强调这一点，因为javascript是自动类型的语言，在运行过程中进行类型的检测是十分重要的问题。

• 另外一个是程序的可读性：这个也是最基本的问题之一，代码风格良好的程序应该可读性强，并且仅添加必要的注释。

• 程序的和谐性：即在程序出错的情况下是否依然可以返回标准的数据格式？可以看到我在检查参数出错以后返回

return function() {}

这么做可以避免因为此函数出错而影响其他的功能性函数。

• 程序的包容性：可以看到我在函数中进行了类型转换。这也是我在工作中遇到的问题，当我们参与工作的协作之时，我们往往需要调用同事或者其他人的函数，而javascript的自动类型也可能导致传过来的参数类型并不标准，如果我们能在代码中给予这些“小问题”适当的支持，那么我们的函数将会友好很多。这里我将并不标准的字符串类型转换为了Number类型。

这些特点实际上是我在某篇文章上面看到的，但是实际应用以后发现受益良多，我会在找到这篇文章以后把链接发上来。我坚信良好的代码风格可以帮助我们避免很多坑，并且严格遵守这一点。

但是实际上我写的这个函数并不完善，这一点也将在后面的面试题中考到。

Q:
请再用setTimeout实现一下

果然考到了这一点，setTimeout在实际运用的过程中会有很多的坑，最明显的问题就是异步问题，这也是我一开始使用setInterval来实现的原因。下面给出代码：

function doRepeat(func, times, wait) {
    // 检查参数是否存在
    if (!func || !times || !wait) {
        return function () { };
    }
    // 检查参数类型
    if (!checkType(func, ['function']) && !checkType(times, ['Number', 'String']) && !checkType(wait, ['Number', 'String'])) {
        return function () { };
    }
    // 进行不规则类型的类型转换
    times = exchange(times, 'Number');
    wait = exchange(wait, 'Number');

    return function repeat() {
        const _args = arguments;
        // 如果次数大于0先执行一遍，避免setTimeout延迟问题
        if (times > 0) {
            func(_args[0]);
        }
        for (let i = 1; i < times; i++) {
            (window.setTimeout)(func(_args[0]), wait);
        }
    }

}

这是我一开始写的代码，但是实际上这段代码是错误的。我在setTimeout一行中使用了立即执行函数，但是立即执行函数并不会阻塞函数的运行，所以这段代码还是会在N秒过后一下子把所有的函数全部执行一遍。

请注意，这里又一个小坑，使用setTimeout是延迟执行函数，如果直接使用第一次传入的函数不会立即执行，所以需要先做一次判断。

Q:
能不能不要一下子就设定好所有的setTimeout
在完成一个setTimeout后再去递归一下

这次考的是递归，没有什么难度。

function doRepeat(func, times, wait) {
    // 检查参数是否存在
    if (!func || !times || !wait) {
        return function () { };
    }
    // 检查参数类型
    if (!checkType(func, ['function']) && !checkType(times, ['Number', 'String']) && !checkType(wait, ['Number', 'String'])) {
        return function () { };
    }
    // 进行不规则类型的类型转换
    times = exchange(times, 'Number');
    wait = exchange(wait, 'Number');
    let i = 0;

    // 返回函数主体
    function repeat() {
        // 如果次数达到则退出
        if (times === i) {
            return;
        }
        const _args = arguments;
        
        func(_args[0]);
        i++;

        // 尾递归
        return setTimeout(repeat.bind(this, _args[0]), wait);
    }

    return repeat;
}

写到这里，突然觉得这个函数其实还是不够健壮。我们来分析一下参数，func参数，默认是一个函数。times参数，默认是一个非负数。wait也默认是一个非负数。

如果传入的参数times是一个负数，那么这个函数将会陷入死循环。这里做检测是否存在过度优化的问题？我还是抱有疑虑。

Q: 这里如果有多个参数怎么办？比如传入的函数叫console.log,可以接受多个参数
A:方法比较多，比如可以规定传参的格式，用数组将参数包裹起来，或者使用arguments
Q: show me the code

这里实际上有个坑，就是IE9的setTimeout只能传入两个参数（IE的梗已经被玩烂了）,这里可以使用bind函数来解决这个问题。

function doRepeat(func, times, wait) {
    // 检查参数是否存在
    if (!func || !times || !wait) {
        return function () { };
    }
    // 检查参数类型
    if (!checkType(func, ['function']) && !checkType(times, ['Number', 'String']) && !checkType(wait, ['Number', 'String'])) {
        return function () { };
    }
    // 进行不规则类型的类型转换
    times = exchange(times, 'Number');
    wait = exchange(wait, 'Number');
    let i = 0;

    // 返回函数主体
    function repeat() {
        // 如果次数达到则退出
        if (times === i) {
            return;
        }
        const _args = [].slice.call(arguments);

        // 如果次数大于0并且是第一次执行则先执行一遍，避免setTimeout延迟问题
        func(..._args)
        // 尾递归
        return setTimeout(repeat.bind(this, _args), wait);
    }

    return repeat;
}

这里同样解释一下这行代码的作用

const _args = [].slice.call(arguments);

可以看到我在下面的代码中使用了展开运算符...，但是展开运算符的使用需要迭代器。arguments不是数组，所以没有迭代器。

考虑以下代码：

(function(){
  console.log([] instanceof Array);
})() // true

(function(){
  console.log(arguments instanceof Array);
})() // false

这些大概就是全部的面试过程，不过最后俺没去成小米，因为时间实在是不合适……

最后想给自己挖个坑，也出个升级版的问题

Q: 请将这道题用setTimeout配合Generator函数实现一遍

这几天考试，等考完试我再来填……