「前端招聘」校招社招面试记录

社招

腾讯云（2021.01.29）

（1）一面 2 hours

1. 实现 promise.all 函数

static all(iterators) {
    return new Prussia((resolve, reject) => {
      let count = 0
      const values = []
      const list = [...iterators]

      if (!list.length) {
        resolve(values)
        return
      }

      for (const [index, iterator] of list.entries()) {
        Prussia.resolve(iterator).then(
          res => {
            count++
            values[index] = res
            if (count === list.length) {
              resolve(values)
            }
          },
          err => { reject(err) }
        )
      }
    })
  }

2. 找出字符串重复的字符

找出一个字符串出现连续重复的字符，例如：输入'aaasfjkjkbbbdjkjssjccc'，输出：['aaa', 'bbb', 'ss', 'ccc']

function getSameString(string){
    return string.match(/(.)\1+/g)
}

JavaScript 的正则表达式组成为：/正则表达式主体/修饰符(可选)

修饰符有：

修饰符	描述
i	执行对大小写不敏感的匹配
g	执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）
m	执行多行匹配

后向引用：用于重复搜索前面某个分组匹配的文本。例如，\1 代表分组 1 匹配的文本。本题中分组 1 为(.)。

3. 求可被整除的数字的个数

给出两个整数 m,n, 请算出 在[m, n] 区间内能被 整数k整除的数的个数，如[2,10]， k = 2, 返回 5, 即共有 2，4，6，8，10五个数字
1 自己的解法
思路：直接通过循环来找出个数

function countDivideNumber(m, n, k){
    let count = 0
    for(let i=m; i<n; i++){
        if(i % k === 0){
            count += 1
        }
    }
    return count
}

但是该算法的时间复杂度为O(n)，如果要求时间复杂度为O(1)呢？

2 优秀的解法
思路：通过算出[0, n]可以被 k 整除的个数，然后在计算出[0, m-1]的个数，相减就可以得到[m, n]可以被 k 整除的个数

function countDivideNumber(m, n, k){
    return Math.floor(n/k) - Math.floor((m-1)/k)
}

（2）二面 1 hour

概念：

1. 跨域的方式
2. 英语
3. DOM 添加自定义属性
4. 使用 JavaScript 操作 cookie
5. http缓冲，设置缓冲
6. http怎么抓包
7. 移动端怎么抓包
8. 1万次循环语句中报错怎么调试 bug
9. 双11页面优化加载方式
10. 虚拟列表
11. 接口返回时间长后端没办法优化了，怎么处理？
12. 表单关闭后再次加载历史记录
13. 代码规范命名
14. vue 和 react 的区别

算法：

1. 实现 ltrim 函数

function ltrim(string){
    return string.replace(/\s+$/g, "");
}

\s 表示匹配任意的空白符

2. 三个数之和

该题与 leetcode（15）三数之和 相似

优秀的解法：
思路：先对数组进行排序，然后通过双指针方法来寻找： 固定 3 个指针中最左（最小）数字的指针 k，双指针 i，j 分设在数组索引（k，len(nums）两端，通过双指针交替向中间移动，记录对于每个固定指针 k 的所有满足，nums[k] + nums[i] + nums[j] == 0的i，j组合。

var threeSum = function(nums) {
    let length = nums.length
    let res = []
    nums.sort((a, b) => a-b)
    for(let k=0; k<length-2; k++){
        if(k > 0 && nums[k-1] === nums[k]) continue
        let i = k + 1
        let j = length - 1
        while(i < j){
            let sum = nums[k] + nums[i] + nums[j]
            if(sum < 10){
                i += 1
                while(i < j && nums[i] === nums[i-1]) i += 1
            }else if(sum > 10){
                j -= 1
                while(i < j && nums[j] === nums[j+1]) j -= 1
            }else{
                res.push([nums[k], nums[i], nums[j]])
                i += 1
                j -= 1
                while(i < j && nums[i] === nums[i-1]) i += 1
                while(i < j && nums[j] === nums[j+1]) j -= 1
            }
        }
    }
    return res
};

蚂蚁金服（2021.03.02）

（1）跳台阶
（2）DFS 全排列
（3）并发下载图片

/**
 * 问题：任何时刻同时下载的链接数量不可以超过3个。
 * 请写一段代码实现这个需求，要求尽可能快速地将所有图片下载完成。
 */
var urls = [
  'https://www.kkkk1000.com/images/getImgData/getImgDatadata.jpg', 
  'https://www.kkkk1000.com/images/getImgData/gray.gif', 
  'https://www.kkkk1000.com/images/getImgData/Particle.gif',
  'https://www.kkkk1000.com/images/getImgData/arithmetic.png',
  'https://www.kkkk1000.com/images/getImgData/arithmetic2.gif',
  'https://www.kkkk1000.com/images/getImgData/getImgDataError.jpg',
  'https://www.kkkk1000.com/images/getImgData/arithmetic.gif',
  'https://www.kkkk1000.com/images/wxQrCode2.png'
];

function loadImg(url) {
  return new Promise((resolve, reject) => {
    const img = new Image()
    img.onload = function () {
      resolve();
    }
    img.onerror = reject
    img.src = url
  })
};

function limitLoad(urls, handler, limit) {
  
}

代码

function delay() {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('加载完成')
      resolve()
    }, Math.random() * 2000)
  })
};

function limitLoad(times, handler, limit) {
  const handles = Array(limit)
    .fill()
    .map((_, index) => handler().then(() => index))
  const remaining = times - limit
  let p = Promise.race(handles)
  let count = 0

  return new Promise((resolve) => {
    for (let i = 0; i < remaining; i++) {
      p = p.then(index => {
        handles[index] = handler().then(() => index)

     // 达到加载数量，在Promise.all(handles) 结束后触发resolve，全部加载完
        if (++count === remaining) {
          Promise.all(handles).then(resolve)
          return
        }

        return Promise.race(handles)
      })
    }
  })
}

limitLoad(10, delay, 3)
  .then(() => {
    console.log('全部加载完毕')
  })

bigo（）

（1）二叉搜索树的第k大元素，时间复杂度优化到O(n)以下。