2022 个前端面试笔试问题及答案

重绘：当节点需要更改外观而不会影响布局。
回流：DOM结构的修改引发DOM几何尺寸变化的时候，发生回流。
常见的几何属性有width、height、padding、margin、left、top、border 或者是DOM节点发生增减移动。
减少重绘和回流的办法。
使用css3新增属性：translate替代top等方向值。
避免频繁使用style，而是采用class。

普通函数this：
this总是代表它的直接调用者。
在默认情况下，没找到直接调用者，this指的是window。
在严格模式下，没有直接调用者的函数中的this是undefined。
使用call,apply,bind绑定，this指的是绑定的对象。
箭头函数this：
在使用=>定义函数的时候，this的指向是 定义时所在的对象，而不是使用时所在的对象；
不能够用作构造函数，这就是说，不能够使用new命令，否则就会抛出一个错误；
不能够使用 arguments 对象；
不能使用 yield 命令；

var 没有块级作用域，支持变量提升。
let 有块级作用域，不支持变量提升。不允许重复声明，暂存性死区。不能通过window.变量名进行访问.
const 有块级作用域，不支持变量提升，不允许重复声明，暂存性死区。声明一个变量一旦声明就不能改变，改变报错。

创建一个对象
连接原型
绑定this
返回该对象
function _new(){
  let obj = new Object();
  let Con = [].shift.call(arguments);
  obj.__proto__ = Con.prototype;
  let result = Con.apply(obj,arguments);
  return typeof result === 'object' ? result : obj
}

原型链：每个被实例对象都有__proto__对象，它指向了构造该对象的构造函数的prototype属性。同时该对象可以通过__proto__对象来寻找不属于自身的属性，
原型：就是实现继承过程中产生的一个概念。

原理是：复制父类的属性和方法来重写子类的原型对象
原型继承
构造函数继承
组合继承
寄生继承
寄生组合继承
class
等等
// 寄生组合继承方法
function Father(...arr) {
    this.some = '父类属性';
    this.params = arr;
}
Father.prototype.someFn = function() {
    console.log(1);
}
Father.prototype.someValue = '2';
function Son() {
    Father.call(this, 'xxxx');
    this.text = '2222';
}
Son.protptype = Object.create(Father.prototype);
Son.prototype.constructor = Son;

Object._create = function(obj){
  function F(){}; // 创建了一个新的构造函数F
  F.prototype = obj; // 然后将构造函数F的原型指向了参数对象obj
  return new F(); // 返回构造函数F的实例对象，从而实现了该实例继承obj的属性。
}

闭包就是有权访问一个函数内部变量的函数，也就是常说的函数内部嵌套函数，内部函数访问外部函数变量，从而导致垃圾回收机制没有将当前变量回收掉。这样的操作，有可能会带来内存泄漏。好处就是可以设计私有的方法和变量。

js拥有特殊的垃圾回收机制，当一个变量在内存中失去引用，js会通过特殊的算法将其回收，并释放内存。
分为以下两个阶段：
标记阶段：垃圾回收器，从根对象开始遍历，访问到的每一个对象都会被标示为可到达对象。
清除阶段：垃圾回收器在对内存当中进行线性遍历，如果发现该对象没有被标记为可到达对象，那么就会被垃圾回收机制回收。
这里面牵扯到了引用计数法，每次引用都被会‘➕1’ 如果标记清零，那么就会被回收掉。

浅拷贝
  通常需要拷贝的对象内部只有一层的这种对象。
  常用的方法
  Object.assign方法来实现
  扩展运算符 ...obj
深拷贝
  通常是嵌套二层或以上的复杂对象
  常用方法
  JSON.parse(JSON.stringfy(object)); 该方法忽略掉undefined、忽略Symbol、忽略function。只适合简单深拷贝
  手写递归方法去实现。
  通过第三方库提供的深拷贝实现。

防抖函数：将多次触发变成最后一次触发；
function debounce(fn,wait){
  let timer = null;
  return function (){
    let arg = arguments;
    if(timer){
      clearTimeout(timer);
      timer = null;
    }
    timer = setTimeout(()=>{
       fn.apply(this,arg)
    },wait)
  }
}
function clg(){
  console.log('clg')
}
window.addEventListener('resize',debounce(clg,1000))

function throttle(fn,time){
  let lastTime = null;
  return function(){
    let nowTime = Date.now();
    if(nowTime - lastTime > time || !lastTime){
      fn();
      last = nowTime
    }
  }
}
function sayHi(){
  console.log('hi')
}
setInterval(throttle(sayHi,1000),500)

相同点：都是重定向this指针的方法。
不同点：call和apply的第二个参数不相同，call是若干个参数的列表。apply是一个数组
手写一个call方法
// 在这之前需要重新认识一下call方法的执行操作
let mock = { value : 1 };
function mockNum(){
 console.log('value',this.value)
}
mockNum.call(mock) // 改变了函数中this的指向，当前this指向了mock对象
转换一下实现方法就是
let mock = {
  value:1;
  mockNum:function(){
     console.log('value',this.value)
  }
}
mock.mockNum();
所以经过上面这个操作的演化而来的结果就是如下步骤：
1. 将函数设为一个对象的属性
2. 并将这个函数的属性调用
3. 删除该函数
Function.prototype.Mycall = function(context){
  let obj = context || window;
  obj.fn = this; //   这一步可以看做是this其实就指的当前函数。
  let args = [...arguments].slice(1); // 返回删除第一个元素的数组；
  let result = obj.fn(...args); // 调用函数
  delete obj.fn;
  return result;
}
// 操作一下
let mock = { value : 1 };
function mockNum(){
  console.log('value',this.value);
}
mockNum.Mycall(mock) // value 1

Function.prototype.Myapply = function (context){
    let obj = context || window;
    obj.fn = this;
    let result = arguments[1] ? obj.fn(arguments[1]) : obj.fn([]);
    delete obj.fn;
    return result;
}
let mock3 = {
  arr: [1, 2, 3, 4, 5],
};
function arrx2(arr) {
  return this.arr.concat(arr).map((x) => x * 2);
}
console.log("arrx2", arrx2.myApply(mock3));

bind方法是直接返回一个新的函数，需要手动去调用才能执行。
创建一个新函数，当这个新函数被调用时，bind()方法的第一个参数将作为运行他的this，之后的一系列参数将会在传递的实参传入作为他的参数；
特点：1. 返回一个函数。 2. 可以传入参数；
手写一个bind方法
例如：
let foo = { value : 1 };
function bar() {
  console.log('bindFoo',this.value);
  // return this.value // 考虑到函数可能有返回值
}
let bindFoo = bar.bind(foo);
bindFoo() // 1  // 如果有返回值的情况下 bindFoo() === 1;
Function.prototype.Mybind = function(obj){
  if(typeof this !== 'function') throw new Error('not a function');
  let self = this;
  let args = [...arguments].clice(1);
  return function F(){

																				

						

							上一篇：							
								前端工程师笔试试题 - js篇							
						
						

							下一篇：							
								前端开发 JavaScript 笔试试题 前端开发笔试试题及答案							
						
					
															

						

							推荐阅读						
						

														

								
									

										收藏夹！6 个常见的 hadoop 面试问题及答案解析									
								
							
														

								
									

										2020 年更新：100 个前端面试问题及答案（上）									
								
							
														

								
									

										[吐槽】2023 个 Java 基础高频面试问题及答案（收藏）									
								
							
														

								
									

										前端 vue 面试问题及答案									
								
							
														

								
									

										13 个前端 vue 面试问题分享（附答案解析）									
								
							
														

								
									

										[面试问题] 2022 个前端面试问题									
								
							
														

								
									

										2022 前端面试高频问题汇总（附答案）									
								
							
														

								
									

										2022 个前端面试笔试问题及答案									
								
							
														

								
									

										全新2022整理的软件测试面试热门问题及答案集锦									
								
							
														

								
									

										搞定前端面试必备的八个问题（附答案及详解）