2022前端面试遇到的手写题总结

实现千位分隔符

// 保留三位小数
parseToMoney(1234.56); // return '1,234.56'
parseToMoney(123456789); // return '123,456,789'
parseToMoney(1087654.321); // return '1,087,654.321'
function parseToMoney(num) {
 num = parseFloat(num.toFixed(3));
 let [integer, decimal] = String.prototype.split.call(num, '.');
 integer = integer.replace(/\d(?=(\d{3})+$)/g, '$&,');
 return integer + '.' + (decimal ? decimal : '');
}

正则表达式(运用了正则的前向声明和反前向声明):

function parseToMoney(str){
 // 仅仅对位置进行匹配
 let re = /(?=(?!\b)(\d{3})+$)/g; 
 return str.replace(re,','); 
}

将js对象转化为树形结构

// 转换前:
source = [{
 id: 1,
 pid: 0,
 name: 'body'
 }, {
 id: 2,
 pid: 1,
 name: 'title'
 }, {
 id: 3,
 pid: 2,
 name: 'div'
 }]
// 转换为: 
tree = [{
 id: 1,
 pid: 0,
 name: 'body',
 children: [{
 id: 2,
 pid: 1,
 name: 'title',
 children: [{
 id: 3,
 pid: 1,
 name: 'div'
 }]
 }
 }]

代码实现:

function jsonToTree(data) {
 // 初始化结果数组,并判断输入数据的格式
 let result = []
 if(!Array.isArray(data)) {
 return result
 }
 // 使用map,将当前对象的id与当前对象对应存储起来
 let map = {};
 data.forEach(item => {
 map[item.id] = item;
 });
 // 
 data.forEach(item => {
 let parent = map[item.pid];
 if(parent) {
 (parent.children || (parent.children = [])).push(item);
 } else {
 result.push(item);
 }
 });
 return result;
}

前端手写面试题详细解答

循环打印红黄绿

下面来看一道比较典型的问题,通过这个问题来对比几种异步编程方法:红灯 3s 亮一次,绿灯 1s 亮一次,黄灯 2s 亮一次;如何让三个灯不断交替重复亮灯?

三个亮灯函数:

function red() {
 console.log('red');
}
function green() {
 console.log('green');
}
function yellow() {
 console.log('yellow');
}

这道题复杂的地方在于需要“交替重复”亮灯,而不是“亮完一次”就结束了。

(1)用 callback 实现

const task = (timer, light, callback) => {
 setTimeout(() => {
 if (light === 'red') {
 red()
 }
 else if (light === 'green') {
 green()
 }
 else if (light === 'yellow') {
 yellow()
 }
 callback()
 }, timer)
}
task(3000, 'red', () => {
 task(2000, 'green', () => {
 task(1000, 'yellow', Function.prototype)
 })
})

这里存在一个 bug:代码只是完成了一次流程,执行后红黄绿灯分别只亮一次。该如何让它交替重复进行呢?

上面提到过递归,可以递归亮灯的一个周期:

const step = () => {
 task(3000, 'red', () => {
 task(2000, 'green', () => {
 task(1000, 'yellow', step)
 })
 })
}
step()

注意看黄灯亮的回调里又再次调用了 step 方法 以完成循环亮灯。

(2)用 promise 实现

const task = (timer, light) => 
 new Promise((resolve, reject) => {
 setTimeout(() => {
 if (light === 'red') {
 red()
 }
 else if (light === 'green') {
 green()
 }
 else if (light === 'yellow') {
 yellow()
 }
 resolve()
 }, timer)
 })
const step = () => {
 task(3000, 'red')
 .then(() => task(2000, 'green'))
 .then(() => task(2100, 'yellow'))
 .then(step)
}
step()

这里将回调移除,在一次亮灯结束后,resolve 当前 promise,并依然使用递归进行。

(3)用 async/await 实现

const taskRunner = async () => {
 await task(3000, 'red')
 await task(2000, 'green')
 await task(2100, 'yellow')
 taskRunner()
}
taskRunner()

实现一个call

call做了什么:

  • 将函数设为对象的属性
  • 执行&删除这个函数
  • 指定this到函数并传入给定参数执行函数
  • 如果不传入参数,默认指向为 window
// 模拟 call bar.mycall(null);
//实现一个call方法:
Function.prototype.myCall = function(context) {
 //此处没有考虑context非object情况
 context.fn = this;
 let args = [];
 for (let i = 1, len = arguments.length; i < len; i++) {
 args.push(arguments[i]);
 }
 context.fn(...args);
 let result = context.fn(...args);
 delete context.fn;
 return result;
};

手写类型判断函数

function getType(value) {
 // 判断数据是 null 的情况
 if (value === null) {
 return value + "";
 }
 // 判断数据是引用类型的情况
 if (typeof value === "object") {
 let valueClass = Object.prototype.toString.call(value),
 type = valueClass.split(" ")[1].split("");
 type.pop();
 return type.join("").toLowerCase();
 } else {
 // 判断数据是基本数据类型的情况和函数的情况
 return typeof value;
 }
}

实现JSON.parse

var json = '{"name":"cxk", "age":25}';
var obj = eval("(" + json + ")");

此方法属于黑魔法,极易容易被xss攻击,还有一种new Function大同小异。

判断对象是否存在循环引用

循环引用对象本来没有什么问题,但是序列化的时候就会发生问题,比如调用JSON.stringify()对该类对象进行序列化,就会报错: Converting circular structure to JSON.

下面方法可以用来判断一个对象中是否已存在循环引用:

const isCycleObject = (obj,parent) => {
 const parentArr = parent || [obj];
 for(let i in obj) {
 if(typeof obj[i] === 'object') {
 let flag = false;
 parentArr.forEach((pObj) => {
 if(pObj === obj[i]){
 flag = true;
 }
 })
 if(flag) return true;
 flag = isCycleObject(obj[i],[...parentArr,obj[i]]);
 if(flag) return true;
 }
 }
 return false;
}
const a = 1;
const b = {a};
const c = {b};
const o = {d:{a:3},c}
o.c.b.aa = a;
console.log(isCycleObject(o)

查找有序二维数组的目标值:

var findNumberIn2DArray = function(matrix, target) {
 if (matrix == null || matrix.length == 0) {
 return false;
 }
 let row = 0;
 let column = matrix[0].length - 1;
 while (row < matrix.length && column >= 0) {
 if (matrix[row][column] == target) {
 return true;
 } else if (matrix[row][column] > target) {
 column--;
 } else {
 row++;
 }
 }
 return false;
};

二维数组斜向打印:

function printMatrix(arr){
 let m = arr.length, n = arr[0].length
 let res = []
 // 左上角,从0 到 n - 1 列进行打印
 for (let k = 0; k < n; k++) {
 for (let i = 0, j = k; i < m && j >= 0; i++, j--) {
 res.push(arr[i][j]);
 }
 }
 // 右下角,从1 到 n - 1 行进行打印
 for (let k = 1; k < m; k++) {
 for (let i = k, j = n - 1; i < m && j >= 0; i++, j--) {
 res.push(arr[i][j]);
 }
 }
 return res
}

模板引擎实现

let template = '我是{{name}},年龄{{age}},性别{{sex}}';
let data = {
 name: '姓名',
 age: 18
}
render(template, data); // 我是姓名,年龄18,性别undefined
function render(template, data) {
 const reg = /\{\{(\w+)\}\}/; // 模板字符串正则
 if (reg.test(template)) { // 判断模板里是否有模板字符串
 const name = reg.exec(template)[1]; // 查找当前模板里第一个模板字符串的字段
 template = template.replace(reg, data[name]); // 将第一个模板字符串渲染
 return render(template, data); // 递归的渲染并返回渲染后的结构
 }
 return template; // 如果模板没有模板字符串直接返回
}

函数珂里化

指的是将一个接受多个参数的函数 变为 接受一个参数返回一个函数的固定形式,这样便于再次调用,例如f(1)(2)

经典面试题:实现add(1)(2)(3)(4)=10;add(1)(1,2,3)(2)=9;

function add() {
 const _args = [...arguments];
 function fn() {
 _args.push(...arguments);
 return fn;
 }
 fn.toString = function() {
 return _args.reduce((sum, cur) => sum + cur);
 }
 return fn;
}

实现深拷贝

  • 浅拷贝: 浅拷贝指的是将一个对象的属性值复制到另一个对象,如果有的属性的值为引用类型的话,那么会将这个引用的地址复制给对象,因此两个对象会有同一个引用类型的引用。浅拷贝可以使用 Object.assign 和展开运算符来实现。
  • 深拷贝: 深拷贝相对浅拷贝而言,如果遇到属性值为引用类型的时候,它新建一个引用类型并将对应的值复制给它,因此对象获得的一个新的引用类型而不是一个原有类型的引用。深拷贝对于一些对象可以使用 JSON 的两个函数来实现,但是由于 JSON 的对象格式比 js 的对象格式更加严格,所以如果属性值里边出现函数或者 Symbol 类型的值时,会转换失败

(1)JSON.stringify()

  • JSON.parse(JSON.stringify(obj))是目前比较常用的深拷贝方法之一,它的原理就是利用JSON.stringifyjs对象序列化(JSON字符串),再使用JSON.parse来反序列化(还原)js对象。
  • 这个方法可以简单粗暴的实现深拷贝,但是还存在问题,拷贝的对象中如果有函数,undefined,symbol,当使用过JSON.stringify()进行处理之后,都会消失。
let obj1 = { a: 0,
 b: {
 c: 0
 }
 };
let obj2 = JSON.parse(JSON.stringify(obj1));
obj1.a = 1;
obj1.b.c = 1;
console.log(obj1); // {a: 1, b: {c: 1}}
console.log(obj2); // {a: 0, b: {c: 0}}

(2)函数库lodash的_.cloneDeep方法

该函数库也有提供_.cloneDeep用来做 Deep Copy

var _ = require('lodash');
var obj1 = {
 a: 1,
 b: { f: { g: 1 } },
 c: [1, 2, 3]
};
var obj2 = _.cloneDeep(obj1);
console.log(obj1.b.f === obj2.b.f);// false

(3)手写实现深拷贝函数

// 深拷贝的实现
function deepCopy(object) {
 if (!object || typeof object !== "object") return;
 let newObject = Array.isArray(object) ? [] : {};
 for (let key in object) {
 if (object.hasOwnProperty(key)) {
 newObject[key] =
 typeof object[key] === "object" ? deepCopy(object[key]) : object[key];
 }
 }
 return newObject;
}

实现数组的flat方法

function _flat(arr, depth) {
 if(!Array.isArray(arr) || depth <= 0) {
 return arr;
 }
 return arr.reduce((prev, cur) => {
 if (Array.isArray(cur)) {
 return prev.concat(_flat(cur, depth - 1))
 } else {
 return prev.concat(cur);
 }
 }, []);
}

Object.assign

Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象(请注意这个操作是浅拷贝)

Object.defineProperty(Object, 'assign', {
 value: function(target, ...args) {
 if (target == null) {
 return new TypeError('Cannot convert undefined or null to object');
 }
 // 目标对象需要统一是引用数据类型,若不是会自动转换
 const to = Object(target);
 for (let i = 0; i < args.length; i++) {
 // 每一个源对象
 const nextSource = args[i];
 if (nextSource !== null) {
 // 使用for...in和hasOwnProperty双重判断,确保只拿到本身的属性、方法(不包含继承的)
 for (const nextKey in nextSource) {
 if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
 to[nextKey] = nextSource[nextKey];
 }
 }
 }
 }
 return to;
 },
 // 不可枚举
 enumerable: false,
 writable: true,
 configurable: true,
})

验证是否是邮箱

function isEmail(email) {
 var regx = /^([a-zA-Z0-9_\-])[email protected]([a-zA-Z0-9_\-])+(\.[a-zA-Z0-9_\-])+$/;
 return regx.test(email);
}

手写 new 操作符

在调用 new 的过程中会发生以上四件事情:

(1)首先创建了一个新的空对象

(2)设置原型,将对象的原型设置为函数的 prototype 对象。

(3)让函数的 this 指向这个对象,执行构造函数的代码(为这个新对象添加属性)

(4)判断函数的返回值类型,如果是值类型,返回创建的对象。如果是引用类型,就返回这个引用类型的对象。

function objectFactory() {
 let newObject = null;
 let constructor = Array.prototype.shift.call(arguments);
 let result = null;
 // 判断参数是否是一个函数
 if (typeof constructor !== "function") {
 console.error("type error");
 return;
 }
 // 新建一个空对象,对象的原型为构造函数的 prototype 对象
 newObject = Object.create(constructor.prototype);
 // 将 this 指向新建对象,并执行函数
 result = constructor.apply(newObject, arguments);
 // 判断返回对象
 let flag = result && (typeof result === "object" || typeof result === "function");
 // 判断返回结果
 return flag ? result : newObject;
}
// 使用方法
objectFactory(构造函数, 初始化参数);

实现AJAX请求

AJAX是 Asynchronous JavaScript and XML 的缩写,指的是通过 JavaScript 的 异步通信,从服务器获取 XML 文档从中提取数据,再更新当前网页的对应部分,而不用刷新整个网页。

创建AJAX请求的步骤:

  • 创建一个 XMLHttpRequest 对象。
  • 在这个对象上使用 open 方法创建一个 HTTP 请求,open 方法所需要的参数是请求的方法、请求的地址、是否异步和用户的认证信息。
  • 在发起请求前,可以为这个对象添加一些信息和监听函数。比如说可以通过 setRequestHeader 方法来为请求添加头信息。还可以为这个对象添加一个状态监听函数。一个 XMLHttpRequest 对象一共有 5 个状态,当它的状态变化时会触发onreadystatechange 事件,可以通过设置监听函数,来处理请求成功后的结果。当对象的 readyState 变为 4 的时候,代表服务器返回的数据接收完成,这个时候可以通过判断请求的状态,如果状态是 2xx 或者 304 的话则代表返回正常。这个时候就可以通过 response 中的数据来对页面进行更新了。
  • 当对象的属性和监听函数设置完成后,最后调用 sent 方法来向服务器发起请求,可以传入参数作为发送的数据体。
const SERVER_URL = "/server";
let xhr = new XMLHttpRequest();
// 创建 Http 请求
xhr.open("GET", SERVER_URL, true);
// 设置状态监听函数
xhr.onreadystatechange = function() {
 if (this.readyState !== 4) return;
 // 当请求成功时
 if (this.status === 200) {
 handle(this.response);
 } else {
 console.error(this.statusText);
 }
};
// 设置请求失败时的监听函数
xhr.onerror = function() {
 console.error(this.statusText);
};
// 设置请求头信息
xhr.responseType = "json";
xhr.setRequestHeader("Accept", "application/json");
// 发送 Http 请求
xhr.send(null);

使用Promise封装AJAX请求

// promise 封装实现:
function getJSON(url) {
 // 创建一个 promise 对象
 let promise = new Promise(function(resolve, reject) {
 let xhr = new XMLHttpRequest();
 // 新建一个 http 请求
 xhr.open("GET", url, true);
 // 设置状态的监听函数
 xhr.onreadystatechange = function() {
 if (this.readyState !== 4) return;
 // 当请求成功或失败时,改变 promise 的状态
 if (this.status === 200) {
 resolve(this.response);
 } else {
 reject(new Error(this.statusText));
 }
 };
 // 设置错误监听函数
 xhr.onerror = function() {
 reject(new Error(this.statusText));
 };
 // 设置响应的数据类型
 xhr.responseType = "json";
 // 设置请求头信息
 xhr.setRequestHeader("Accept", "application/json");
 // 发送 http 请求
 xhr.send(null);
 });
 return promise;
}

判断括号字符串是否有效(小米)

题目描述

给定一个只包括 '(',')','{','}','[',']' 的字符串 s ,判断字符串是否有效。
有效字符串需满足:
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
示例 1:
输入:s = "()"
输出:true
示例 2:
输入:s = "()[]{}"
输出:true
示例 3:
输入:s = "(]"
输出:false

答案

const isValid = function (s) {
 if (s.length % 2 === 1) {
 return false;
 }
 const regObj = {
 "{": "}",
 "(": ")",
 "[": "]",
 };
 let stack = [];
 for (let i = 0; i < s.length; i++) {
 if (s[i] === "{" || s[i] === "(" || s[i] === "[") {
 stack.push(s[i]);
 } else {
 const cur = stack.pop();
 if (s[i] !== regObj[cur]) {
 return false;
 }
 }
 }
 if (stack.length) {
 return false;
 }
 return true;
};

数组去重方法汇总

首先:我知道多少种去重方式

1. 双层 for 循环

function distinct(arr) {
 for (let i=0, len=arr.length; i<len; i++) {
 for (let j=i+1; j<len; j++) {
 if (arr[i] == arr[j]) {
 arr.splice(j, 1);
 // splice 会改变数组长度,所以要将数组长度 len 和下标 j 减一
 len--;
 j--;
 }
 }
 }
 return arr;
}
思想: 双重 for 循环是比较笨拙的方法,它实现的原理很简单:先定义一个包含原始数组第一个元素的数组,然后遍历原始数组,将原始数组中的每个元素与新数组中的每个元素进行比对,如果不重复则添加到新数组中,最后返回新数组;因为它的时间复杂度是O(n^2),如果数组长度很大,效率会很低

2. Array.filter() 加 indexOf/includes

function distinct(a, b) {
 let arr = a.concat(b);
 return arr.filter((item, index)=> {
 //return arr.indexOf(item) === index
 return arr.includes(item)
 })
}
思想: 利用indexOf检测元素在数组中第一次出现的位置是否和元素现在的位置相等,如果不等则说明该元素是重复元素

3. ES6 中的 Set 去重

function distinct(array) {
 return Array.from(new Set(array));
}
思想: ES6 提供了新的数据结构 Set,Set 结构的一个特性就是成员值都是唯一的,没有重复的值。

4. reduce 实现对象数组去重复

var resources = [
 { name: "张三", age: "18" },
 { name: "张三", age: "19" },
 { name: "张三", age: "20" },
 { name: "李四", age: "19" },
 { name: "王五", age: "20" },
 { name: "赵六", age: "21" }
]
var temp = {};
resources = resources.reduce((prev, curv) => {
 // 如果临时对象中有这个名字,什么都不做
 if (temp[curv.name]) {
 }else {
 // 如果临时对象没有就把这个名字加进去,同时把当前的这个对象加入到prev中
 temp[curv.name] = true;
 prev.push(curv);
 }
 return prev
}, []);
console.log("结果", resources);
这种方法是利用高阶函数 reduce 进行去重, 这里只需要注意initialValue得放一个空数组[],不然没法push

实现类数组转化为数组

类数组转换为数组的方法有这样几种:

  • 通过 call 调用数组的 slice 方法来实现转换
Array.prototype.slice.call(arrayLike);
  • 通过 call 调用数组的 splice 方法来实现转换
Array.prototype.splice.call(arrayLike, 0);
  • 通过 apply 调用数组的 concat 方法来实现转换
Array.prototype.concat.apply([], arrayLike);
  • 通过 Array.from 方法来实现转换
Array.from(arrayLike);

实现Vue reactive响应式

// Dep module
class Dep {
 static stack = []
 static target = null
 deps = null
 constructor() {
 this.deps = new Set()
 }
 depend() {
 if (Dep.target) {
 this.deps.add(Dep.target)
 }
 }
 notify() {
 this.deps.forEach(w => w.update())
 }
 static pushTarget(t) {
 if (this.target) {
 this.stack.push(this.target)
 }
 this.target = t
 }
 static popTarget() {
 this.target = this.stack.pop()
 }
}
// reactive
function reactive(o) {
 if (o && typeof o === 'object') {
 Object.keys(o).forEach(k => {
 defineReactive(o, k, o[k])
 })
 }
 return o
}
function defineReactive(obj, k, val) {
 let dep = new Dep()
 Object.defineProperty(obj, k, {
 get() {
 dep.depend()
 return val
 },
 set(newVal) {
 val = newVal
 dep.notify()
 }
 })
 if (val && typeof val === 'object') {
 reactive(val)
 }
}
// watcher
class Watcher {
 constructor(effect) {
 this.effect = effect
 this.update()
 }
 update() {
 Dep.pushTarget(this)
 this.value = this.effect()
 Dep.popTarget()
 return this.value
 }
}
// 测试代码
const data = reactive({
 msg: 'aaa'
})
new Watcher(() => {
 console.log('===> effect', data.msg);
})
setTimeout(() => {
 data.msg = 'hello'
}, 1000)
作者:hello_world_1024原文地址:https://segmentfault.com/a/1190000042532305

%s 个评论

要回复文章请先登录注册