快手基础研发平台前端四面面经- 校招VIP

文章申明：转载来源：https://www.nowcoder.com/discuss/771166

一面

个人介绍，项目经历

计算机网络

TCP/UDP区别

HTTP 1.1/HTTP 2/HTTPS区别

数据结构

有向图的遍历方法

DFS、BFS效率高低：最好情况DFS高，一般BFS高，时间复杂度没说出来

手撕代码

二叉树层次遍历

// let obj = {
//  left:{},
//  right:{},
//  val:12
// }
//  0
// 1  2
//3 4 5 6
function travel(root){
    const res = [];
    if (!root)return res;
    const queue = [root];
    while (queue.length) {
        const len = queue.length;
        res.push(queue[0].val);
        for (let i = 0; i < len; i++) {
            let node = queue.shift();
            if (node.left) queue.push(node.left);
            if (node.right) queue.push(node.right);
        }
    }
    return res;
}
 
let obj = {
  left:{
      left: {
          left:null,
          right:null,
          val: 3
      },
      right: {
          left:null,
          right:null,
          val: 4
      },
      val: 1
  },
  right:{
      left: {
          left:null,
          right:null,
          val: 5
      },
      right: {
          left:null,
          right:null,
          val: 6
      },
      val: 2
  },
  val: 0
};
console.log(travel(obj));

反问

二面

JS基础

输入输出

// 本段代码在全局作用域执行
 
var name ="outer";
 
function K() {
    let name ="k";
    let innerObj = {
        print:function() {
            console.log(name);
            console.log(this.name);
        }
    }
 
    return innerObj;
}
 
let o = K();
o.print();// 输出是什么？
// k
// undefined
 
let p = o.print;
p();// 输出是什么？
// k
// outer

this指向

项目相关：CDN

压缩方式

手撕代码

帕多瓦数列

（1）使用递归方法，定义函数 F(n)；函数只有一个参数 n，n 的值为0或正整数；函数返回值是帕多瓦数列 n 位置处的数字。

（2）使用非递归方法，定义函数F(n)。

//line=readline()
//print(line)
// 递归
// function F(n) {
//     if (n <= 2) return 1;
//     return F(n - 2) + F(n - 3);
// }
function F(n) {
    let dp0 = 1, dp1 = 1, dp2 = 1;
    if (n <= 2)return 1;
    for (let i = 3; i <= n; i++) {
        let cur = dp0 + dp1;
        dp0 = dp1;
        dp1 = dp2;
        dp2 = cur;
    }
    return dp2;
}
console.log(F(1))
console.log(F(2))
console.log(F(3))
console.log(F(4))
console.log(F(5))
console.log(F(6))
console.log(F(7))

讲了特征方程的思路

队列

// 使用 JavaScript 中的数组实现一个队列结构
 
function Queue() {
    this.queue = [];
}
 
Queue.prototype = {
    add:function(e) {
        /**
         * 在队列尾部插入一个元素
         */
        this.queue.push(e);
    },
    remove:function() {
        /**
         * 在队列头部移出一个元素，返回该元素值
         */
        return this.queue &&this.queue.length ?this.queue.shift() : undefined;
    },
    size:function() {
        /**
         * 返回队列元素个数
         */
        return this.queue &&this.queue.length ?this.queue.length : 0;
    },
    clear:function() {
        /**
         * 清空队列中的元素
         */
        this.queue = [];
    }
}
 
// Queue 使用样例
let q =new Queue();
q.add('1');
q.add('2');
q.add('3');
q.add('4');
q.add('5');
q.add('6');
while (q.size()) {
    console.log(q.remove());hx
}
console.log(q.size());// 输出 0

三面

项目相关

Vue和React区别

Vue、React哪个下限高，哪个上限高

小程序和H5原生程序区别和意义

有没有看过源码

手撕代码

将字符串转化为整数

限定语言：Kotlin、Typescript、Python、C++、Groovy、Rust、Java、Go、Scala、Javascript、Ruby、Swift、Php、Python 3

实现函数 atoi 。函数的功能为将字符串转化为整数

提示：仔细思考所有可能的输入情况。这个问题没有给出输入的限制，你需要自己考虑所有可能的情况。

示例1

输入

"123"

输出

现场写的不是很好，可以看看

/**
  *
  * @param str string字符串
  * @return int整型
  */
/*判断是否是数字*/
/* function isNumber(char) {
    if (!char || char.length !== 1) return false;
    if (/^[0-9]$/.test(char)) return true;
    return false;
}*/
function atoi( str ) {
    // write code here
    str = str.trim().split('.')[0];
    // 判断是否为NaN
    // if (str.length === 0 || str[0] !== '-' || str[0] !== '+' || !isNumber(str[0])) return NaN;
    if (Number.isNaN(str))return NaN;
       // 判定正负数数
    let signal = 1;
    if (str[0] ==='+') {
        str = str.slice(1);
    }else if (str[0] ==='-') {
        signal = -1;
        str = str.slice(1);
    }
    // 基数
    let baseNum = 0;
    let i = 0;
    // 是否用了科学表达式
    let isSci =false;
    let sciNum = 0;
    for (; i < str.length; i++) {
        if (/\d/.test(str[i])) {
            baseNum = baseNum * 10 + (str[i] - 0);
        }else if ((str[i] ==='e' || str[i] ==='E') && isSci ===false) {
            isSci =true;
            sciNum = atoi(str.slice(i + 1));
        }else {
            break;
        }
    }
    if (!isSci) {
        return signal * baseNum;
    }else if (!Number.isNaN(sciNum)) {
        return signal * (Math.floor(baseNum * Math.pow(10, sciNum)));
    }else {
        return NaN;
    }
}
module.exports = {
    atoi : atoi
};

其实这个完整版需要状态机严格写，上面临场写的太随性了

function atoi( str ) {
    //封装自动机类
    class Automation{
        constructor(){
            //执行阶段，默认处于开始执行阶段
            this.state ='start';
            //正负符号，默认是正数
            this.sign = 1;
            //数值，默认是0
            this.answer = 0;
            /* 关键点：
            执行阶段和执行阶段德对应表
            含义如下
            [执行阶段，[空格，正负，数值，其他]] */
            this.map =new Map([
                ['start', ['start','signed','in_number','end']],
                ['signed', ['end','end','in_number','end']],
                ['in_number', ['end','end','in_number','end']],
                ['end', ['end','end','end','end']]
            ])
        }
 
        // 获取状态的索引
        getIndex(char) {
            if (char ===' ') {
                // 空格判断
                return 0;
            }else if (char ==='-' || char ==='+') {
                // 正负判断
                return 1;
            }else if (typeof Number(char) ==='number' && !isNaN(char)) {
                // 数值判断
                return 2;
            }else {
                // 其他情况
                return 3;
            }
        }
 
        /* 关键点：
        字符转换执行函数 */
        get(char) {
            /* 易错点：
            每次传入字符时，都要变更自动机的执行阶段 */
            this.state =this.map.get(this.state)[this.getIndex(char)];
 
            if(this.state ==='in_number') {
                /* 小技巧：
                在JS中，对字符串类型进行减法操作，可以将得到一个数值型（Number）的值
 
                易错点：
                本处需要利用括号来提高四则运算的优先级  */
                this.answer =this.answer * 10 + (char - 0);
 
                /* 易错点：
                在进行负数比较时，需要将INT_MIN变为正数 */
                this.answer =this.sign === 1 ? Math.min(this.answer, Math.pow(2, 31) - 1) : Math.min(this.answer, -Math.pow(-2, 31));
            }else if (this.state ==='signed') {
                /* 优化点：
                对于一个整数来说，非正即负，
                所以正负号的判断，只需要一次。
                故，可以降低其判断的优先级 */
                this.sign = char ==='+' ? 1 : -1;
            }
        }
    }
 
    // 生成自动机实例
    let automation =new Automation();
 
    // 遍历每个字符
    for(let char of str) {
        // 依次进行转换
        automation.get(char);
    }
 
    // 返回值，整数 = 正负 * 数值
    return automation.sign * automation.answer;
};

四面

个人介绍，项目经历，实验室经历

手撕代码

最长无重复子串

滑动窗口双指针

//line=readline()
//print(line)
// console.log('Hello World!');
function findLongestOnce(str) {
    let left = 0, right = 0;
    let maxLen = 0;
    let leftIndex = 0;
    let set =new Set();
    const len = str.length;
    while (right < len) {
        while (!set.has(str[right]) && right < len) {
            set.add(str[right]);
            right++;
        }
        if (right - left > maxLen) {
            maxLen = right - left;
            leftIndex = left;
        }
        if (right === len)break;
        while (set.has(str[right])) {
            set.delete(str[left]);
            left++;
        }
    }
    return str.slice(leftIndex, leftIndex + maxLen);
}
 
console.log(findLongestOnce('abcda'));