说一说正向代理和反向代理
正向代理
我们常说的代理也就是指正向代理,正向代理的过程,它隐藏了真实的请求客户端,服务端不知道真实的客户端是谁,客户端请求的服务都被代理服务器代替来请求。
反向代理
这种代理模式下,它隐藏了真实的服务端,当我们向一个网站发起请求的时候,背后可能有成千上万台服务器为我们服务,具体是哪一台,我们不清楚,我们只需要知道反向代理服务器是谁就行,而且反向代理服务器会帮我们把请求转发到真实的服务器那里去,一般而言反向代理服务器一般用来实现负载平衡。
负载平衡的两种实现方式?
- 一种是使用反向代理的方式,用户的请求都发送到反向代理服务上,然后由反向代理服务器来转发请求到真实的服务器上,以此来实现集群的负载平衡。
- 另一种是 DNS 的方式,DNS 可以用于在冗余的服务器上实现负载平衡。因为现在一般的大型网站使用多台服务器提供服务,因此一个域名可能会对应多个服务器地址。当用户向网站域名请求的时候,DNS 服务器返回这个域名所对应的服务器 IP 地址的集合,但在每个回答中,会循环这些 IP 地址的顺序,用户一般会选择排在前面的地址发送请求。以此将用户的请求均衡的分配到各个不同的服务器上,这样来实现负载均衡。这种方式有一个缺点就是,由于 DNS 服务器中存在缓存,所以有可能一个服务器出现故障后,域名解析仍然返回的是那个 IP 地址,就会造成访问的问题。
如何优化动画?
对于如何优化动画,我们知道,一般情况下,动画需要频繁的操作DOM,就就会导致页面的性能问题,我们可以将动画的position
属性设置为absolute
或者fixed
,将动画脱离文档流,这样他的回流就不会影响到页面了。
函数柯里化
柯里化(currying) 指的是将一个多参数的函数拆分成一系列函数,每个拆分后的函数都只接受一个参数。
对于已经柯里化后的函数来说,当接收的参数数量与原函数的形参数量相同时,执行原函数; 当接收的参数数量小于原函数的形参数量时,返回一个函数用于接收剩余的参数,直至接收的参数数量与形参数量一致,执行原函数。
数组能够调用的函数有那些?
- push
- pop
- splice
- slice
- shift
- unshift
- sort
- find
- findIndex
- map/filter/reduce 等函数式编程方法
- 还有一些原型链上的方法:toString/valudOf
行内元素有哪些?块级元素有哪些? 空(void)元素有那些?
- 行内元素有:
a b span img input select strong
; - 块级元素有:
div ul ol li dl dt dd h1 h2 h3 h4 h5 h6 p
;
空元素,即没有内容的HTML元素。空元素是在开始标签中关闭的,也就是空元素没有闭合标签:
- 常见的有:
<br>
、<hr>
、<img>
、<input>
、<link>
、<meta>
; - 鲜见的有:
<area>
、<base>
、<col>
、<colgroup>
、<command>
、<embed>
、<keygen>
、<param>
、<source>
、<track>
、<wbr>
。
用过 TypeScript 吗?它的作用是什么?
为 JS 添加类型支持,以及提供最新版的 ES 语法的支持,是的利于团队协作和排错,开发大型项目
介绍下 promise 的特性、优缺点,内部是如何实现的,动手实现 Promise
1)Promise基本特性
- 1、Promise有三种状态:pending(进行中)、fulfilled(已成功)、rejected(已失败)
- 2、Promise对象接受一个回调函数作为参数, 该回调函数接受两个参数,分别是成功时的回调resolve和失败时的回调reject;另外resolve的参数除了正常值以外, 还可能是一个Promise对象的实例;reject的参数通常是一个Error对象的实例。
- 3、then方法返回一个新的Promise实例,并接收两个参数onResolved(fulfilled状态的回调);onRejected(rejected状态的回调,该参数可选)
- 4、catch方法返回一个新的Promise实例
- 5、finally方法不管Promise状态如何都会执行,该方法的回调函数不接受任何参数
- 6、Promise.all()方法将多个多个Promise实例,包装成一个新的Promise实例,该方法接受一个由Promise对象组成的数组作为参数(Promise.all()方法的参数可以不是数组,但必须具有Iterator接口,且返回的每个成员都是Promise实例),注意参数中只要有一个实例触发catch方法,都会触发Promise.all()方法返回的新的实例的catch方法,如果参数中的某个实例本身调用了catch方法,将不会触发Promise.all()方法返回的新实例的catch方法
- 7、Promise.race()方法的参数与Promise.all方法一样,参数中的实例只要有一个率先改变状态就会将该实例的状态传给Promise.race()方法,并将返回值作为Promise.race()方法产生的Promise实例的返回值
- 8、Promise.resolve()将现有对象转为Promise对象,如果该方法的参数为一个Promise对象,Promise.resolve()将不做任何处理;如果参数thenable对象(即具有then方法),Promise.resolve()将该对象转为Promise对象并立即执行then方法;如果参数是一个原始值,或者是一个不具有then方法的对象,则Promise.resolve方法返回一个新的Promise对象,状态为fulfilled,其参数将会作为then方法中onResolved回调函数的参数,如果Promise.resolve方法不带参数,会直接返回一个fulfilled状态的 Promise 对象。需要注意的是,立即resolve()的 Promise 对象,是在本轮“事件循环”(event loop)的结束时执行,而不是在下一轮“事件循环”的开始时。
- 9、Promise.reject()同样返回一个新的Promise对象,状态为rejected,无论传入任何参数都将作为reject()的参数
2)Promise优点
- ①统一异步 API
- Promise 的一个重要优点是它将逐渐被用作浏览器的异步 API ,统一现在各种各样的 API ,以及不兼容的模式和手法。
- ②Promise 与事件对比
- 和事件相比较, Promise 更适合处理一次性的结果。在结果计算出来之前或之后注册回调函数都是可以的,都可以拿到正确的值。 Promise 的这个优点很自然。但是,不能使用 Promise 处理多次触发的事件。链式处理是 Promise 的又一优点,但是事件却不能这样链式处理。
- ③Promise 与回调对比
- 解决了回调地狱的问题,将异步操作以同步操作的流程表达出来。
- ④Promise 带来的额外好处是包含了更好的错误处理方式(包含了异常处理),并且写起来很轻松(因为可以重用一些同步的工具,比如 Array.prototype.map() )。
3)Promise缺点
- 1、无法取消Promise,一旦新建它就会立即执行,无法中途取消。
- 2、如果不设置回调函数,Promise内部抛出的错误,不会反应到外部。
- 3、当处于Pending状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。
- 4、Promise 真正执行回调的时候,定义 Promise 那部分实际上已经走完了,所以 Promise 的报错堆栈上下文不太友好。
4)简单代码实现
最简单的Promise实现有7个主要属性, state(状态), value(成功返回值), reason(错误信息), resolve方法, reject方法, then方法
class Promise{ | |
constructor(executor) { | |
this.state = 'pending'; | |
this.value = undefined; | |
this.reason = undefined; | |
let resolve = value => { | |
if (this.state === 'pending') { | |
this.state = 'fulfilled'; | |
this.value = value; | |
} | |
}; | |
let reject = reason => { | |
if (this.state === 'pending') { | |
this.state = 'rejected'; | |
this.reason = reason; | |
} | |
}; | |
try { | |
// 立即执行函数 | |
executor(resolve, reject); | |
} catch (err) { | |
reject(err); | |
} | |
} | |
then(onFulfilled, onRejected) { | |
if (this.state === 'fulfilled') { | |
let x = onFulfilled(this.value); | |
}; | |
if (this.state === 'rejected') { | |
let x = onRejected(this.reason); | |
}; | |
} | |
} |
5)面试够用版
function myPromise(constructor){ let self=this; | |
self.status="pending" //定义状态改变前的初始状态 | |
self.value=undefined;//定义状态为resolved的时候的状态 | |
self.reason=undefined;//定义状态为rejected的时候的状态 | |
function resolve(value){ | |
//两个==="pending",保证了了状态的改变是不不可逆的 | |
if(self.status==="pending"){ | |
self.value=value; | |
self.status="resolved"; | |
} | |
} | |
function reject(reason){ | |
//两个==="pending",保证了了状态的改变是不不可逆的 | |
if(self.status==="pending"){ | |
self.reason=reason; | |
self.status="rejected"; | |
} | |
} | |
//捕获构造异常 | |
try{ | |
constructor(resolve,reject); | |
}catch(e){ | |
reject(e); | |
} | |
} | |
myPromise.prototype.then=function(onFullfilled,onRejected){ | |
let self=this; | |
switch(self.status){ | |
case "resolved": onFullfilled(self.value); break; | |
case "rejected": onRejected(self.reason); break; | |
default: | |
} | |
} | |
// 测试 | |
var p=new myPromise(function(resolve,reject){resolve(1)}); | |
p.then(function(x){console.log(x)}) | |
//输出1 |
6)大厂专供版
const PENDING = "pending"; | |
const FULFILLED = "fulfilled"; | |
const REJECTED = "rejected"; | |
const resolvePromise = (promise, x, resolve, reject) => { | |
if (x === promise) { | |
// If promise and x refer to the same object, reject promise with a TypeError as the reason. | |
reject(new TypeError('循环引用')) | |
} | |
// if x is an object or function, | |
if (x !== null && typeof x === 'object' || typeof x === 'function') { | |
// If both resolvePromise and rejectPromise are called, or multiple calls to the same argument are made, the first call takes precedence, and any further calls are ignored. | |
let called | |
try { // If retrieving the property x.then results in a thrown exception e, reject promise with e as the reason. | |
let then = x.then // Let then be x.then | |
// If then is a function, call it with x as this | |
if (typeof then === 'function') { | |
// If/when resolvePromise is called with a value y, run [[Resolve]](promise, y) | |
// If/when rejectPromise is called with a reason r, reject promise with r. | |
then.call(x, y => { | |
if (called) return | |
called = true | |
resolvePromise(promise, y, resolve, reject) | |
}, r => { | |
if (called) return | |
called = true | |
reject(r) | |
}) | |
} else { | |
// If then is not a function, fulfill promise with x. | |
resolve(x) | |
} | |
} catch (e) { | |
if (called) return | |
called = true | |
reject(e) | |
} | |
} else { | |
// If x is not an object or function, fulfill promise with x | |
resolve(x) | |
} | |
} | |
function Promise(excutor) { | |
let that = this; // 缓存当前promise实例例对象 | |
that.status = PENDING; // 初始状态 | |
that.value = undefined; // fulfilled状态时 返回的信息 | |
that.reason = undefined; // rejected状态时 拒绝的原因 | |
that.onFulfilledCallbacks = []; // 存储fulfilled状态对应的onFulfilled函数 | |
that.onRejectedCallbacks = []; // 存储rejected状态对应的onRejected函数 | |
function resolve(value) { // value成功态时接收的终值 | |
if(value instanceof Promise) { | |
return value.then(resolve, reject); | |
} | |
// 实践中要确保 onFulfilled 和 onRejected ⽅方法异步执⾏行行,且应该在 then ⽅方法被调⽤用的那⼀一轮事件循环之后的新执⾏行行栈中执⾏行行。 | |
setTimeout(() => { | |
// 调⽤用resolve 回调对应onFulfilled函数 | |
if (that.status === PENDING) { | |
// 只能由pending状态 => fulfilled状态 (避免调⽤用多次resolve reject) | |
that.status = FULFILLED; | |
that.value = value; | |
that.onFulfilledCallbacks.forEach(cb => cb(that.value)); | |
} | |
}); | |
} | |
function reject(reason) { // reason失败态时接收的拒因 | |
setTimeout(() => { | |
// 调⽤用reject 回调对应onRejected函数 | |
if (that.status === PENDING) { | |
// 只能由pending状态 => rejected状态 (避免调⽤用多次resolve reject) | |
that.status = REJECTED; | |
that.reason = reason; | |
that.onRejectedCallbacks.forEach(cb => cb(that.reason)); | |
} | |
}); | |
} | |
// 捕获在excutor执⾏行行器器中抛出的异常 | |
// new Promise((resolve, reject) => { | |
// throw new Error('error in excutor') | |
// }) | |
try { | |
excutor(resolve, reject); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
Promise.prototype.then = function(onFulfilled, onRejected) { | |
const that = this; | |
let newPromise; | |
// 处理理参数默认值 保证参数后续能够继续执⾏行行 | |
onFulfilled = typeof onFulfilled === "function" ? onFulfilled : value => value; | |
onRejected = typeof onRejected === "function" ? onRejected : reason => { | |
throw reason; | |
}; | |
if (that.status === FULFILLED) { // 成功态 | |
return newPromise = new Promise((resolve, reject) => { | |
setTimeout(() => { | |
try{ | |
let x = onFulfilled(that.value); | |
resolvePromise(newPromise, x, resolve, reject); //新的promise resolve 上⼀一个onFulfilled的返回值 | |
} catch(e) { | |
reject(e); // 捕获前⾯面onFulfilled中抛出的异常then(onFulfilled, onRejected); | |
} | |
}); | |
}) | |
} | |
if (that.status === REJECTED) { // 失败态 | |
return newPromise = new Promise((resolve, reject) => { | |
setTimeout(() => { | |
try { | |
let x = onRejected(that.reason); | |
resolvePromise(newPromise, x, resolve, reject); | |
} catch(e) { | |
reject(e); | |
} | |
}); | |
}); | |
} | |
if (that.status === PENDING) { // 等待态 | |
// 当异步调⽤用resolve/rejected时 将onFulfilled/onRejected收集暂存到集合中 | |
return newPromise = new Promise((resolve, reject) => { | |
that.onFulfilledCallbacks.push((value) => { | |
try { | |
let x = onFulfilled(value); | |
resolvePromise(newPromise, x, resolve, reject); | |
} catch(e) { | |
reject(e); | |
} | |
}); | |
that.onRejectedCallbacks.push((reason) => { | |
try { | |
let x = onRejected(reason); | |
resolvePromise(newPromise, x, resolve, reject); | |
} catch(e) { | |
reject(e); | |
} | |
}); | |
}); | |
} | |
}; |
什么是原型什么是原型链?
<html lang="en"> | |
<head> | |
<meta charset="UTF-8"> | |
<meta http-equiv="X-UA-Compatible" content="IE=edge"> | |
<meta name="viewport" content="width=device-width, initial-scale=1.0"> | |
<title>Document</title> | |
</head> | |
<body> | |
</body> | |
<script> | |
function Person () { } var person = new Person(); person.name = 'Kevin'; console.log(person.name) // Kevin | |
// prototype | |
function Person () { } Person.prototype.name = 'Kevin'; var person1 = new Person(); var person2 = new Person(); console.log(person1.name)// Kevin | |
console.log(person2.name)// Kevin | |
// __proto__ | |
function Person () { } var person = new Person(); console.log(person.__proto__ === Person.prototype) // true | |
//constructor | |
function Person() { } console.log(Person === Person.prototype.constructor) // true | |
//综上所述 | |
function Person () { } var person = new Person() console.log(person.__proto__ == Person.prototype) // true | |
console.log(Person.prototype.constructor == Person) // true | |
//顺便学习一下ES5得方法,可以获得对象得原型 | |
console.log(Object.getPrototypeOf(person) === Person.prototype) // true | |
//实例与原型 | |
function Person () { } Person.prototype.name = 'Kevin'; var person = new Person(); person.name = 'Daisy'; console.log(person.name) // Daisy | |
delete person.name; console.log(person.name) // Kevin | |
//原型得原型 | |
var obj = new Object(); obj.name = 'Kevin', console.log(obj.name) //Kevin | |
//原型链 | |
console.log(Object.prototype.__proto__ === null) //true | |
// null 表示"没用对象" 即该处不应该有值 | |
// 补充 | |
function Person() { } var person = new Person() console.log(person.constructor === Person) // true | |
//当获取person.constructor时,其实person中并没有constructor属性,当不能读取到constructor属性时,会从person的原型 | |
//也就是Person.prototype中读取时,正好原型中有该属性,所以 | |
person.constructor === Person.prototype.constructor | |
//__proto__ | |
//其次是__proto__,绝大部分浏览器都支持这个非标准的方法访问原型,然而它并不存在于Person.prototype中,实际上,它 | |
// 是来自与Object.prototype,与其说是一个属性,不如说是一个getter/setter,当使用obj.__proto__时,可以理解成返回了 | |
// Object.getPrototypeOf(obj) | |
</script> | |
</html> |
总结:
1、当一个对象查找属性和方法时会从自身查找,如果查找不到则会通过__proto__指向被实例化的构造函数的prototype
2、隐式原型也是一个对象,是指向我们构造函数的原型
3、除了最顶层的Object对象没有__proto_,其他所有的对象都有__proto__,这是隐式原型
4、隐式原型__proto__的作用是让对象通过它来一直往上查找属性或方法,直到找到最顶层的Object的__proto__属性,它的值是null,这个查找的过程就是原型链
Vue的父子组件生命周期钩子函数执行顺序?
<!-- 加载渲染过程 --> | |
<!-- 父beforeCreate -> 父created -> 父beforeMount -> 子beforeCreate -> 子created -> | |
子beforeMount -> 子mounted -> 父mounted --> | |
<!-- 子组件更新过程 --> | |
<!-- 父beforeUpdate -> 子beforeUpdate -> 子updaed -> 父updated --> | |
<!-- 父组件跟新过程 --> | |
<!-- 父beforeUpdate -> 父updated --> | |
<!-- 销毁过程 --> | |
<!-- 父beforeDestroy -> 子beforeDestroy -> 子destroyed ->父destroyed --> |
懒加载的特点
- 减少无用资源的加载:使用懒加载明显减少了服务器的压力和流量,同时也减小了浏览器的负担。
- 提升用户体验: 如果同时加载较多图片,可能需要等待的时间较长,这样影响了用户体验,而使用懒加载就能大大的提高用户体验。
- 防止加载过多图片而影响其他资源文件的加载 :会影响网站应用的正常使用。
数组去重
实现代码如下:
function uniqueArr(arr) { | |
return [...new Set(arr)]; | |
} |
事件循环机制 (Event Loop)
事件循环机制从整体上告诉了我们 JavaScript 代码的执行顺序 Event Loop
即事件循环,是指浏览器或Node
的一种解决javaScript
单线程运行时不会阻塞的一种机制,也就是我们经常使用异步的原理。
先执行 Script 脚本,然后清空微任务队列,然后开始下一轮事件循环,继续先执行宏任务,再清空微任务队列,如此往复。
- 宏任务:Script/setTimeout/setInterval/setImmediate/ I/O / UI Rendering
- 微任务:process.nextTick()/Promise
上诉的 setTimeout 和 setInterval 等都是任务源,真正进入任务队列的是他们分发的任务。
优先级
- setTimeout = setInterval 一个队列
- setTimeout > setImmediate
- process.nextTick > Promise
for (const macroTask of macroTaskQueue) { | |
handleMacroTask(); | |
for (const microTask of microTaskQueue) { | |
handleMicroTask(microTask); | |
} | |
} |
代码输出结果
// a | |
function Foo () { | |
getName = function () { | |
console.log(1); | |
} | |
return this; | |
} | |
// b | |
Foo.getName = function () { | |
console.log(2); | |
} | |
// c | |
Foo.prototype.getName = function () { | |
console.log(3); | |
} | |
// d | |
var getName = function () { | |
console.log(4); | |
} | |
// e | |
function getName () { | |
console.log(5); | |
} | |
Foo.getName(); // 2 | |
getName(); // 4 | |
Foo().getName(); // 1 | |
getName(); // 1 | |
new Foo.getName(); // 2 | |
new Foo().getName(); // 3 | |
new new Foo().getName(); // 3 |
输出结果:2 4 1 1 2 3 3
解析:
- Foo.getName(), Foo为一个函数对象,对象都可以有属性,b 处定义Foo的getName属性为函数,输出2;
- getName(), 这里看d、e处,d为函数表达式,e为函数声明,两者区别在于变量提升,函数声明的 5 会被后边函数表达式的 4 覆盖;
- Foo().getName(), 这里要看a处,在Foo内部将全局的getName重新赋值为 console.log(1) 的函数,执行Foo()返回 this,这个this指向window,Foo().getName() 即为window.getName(),输出 1;
- getName(), 上面3中,全局的getName已经被重新赋值,所以这里依然输出 1;
- new Foo.getName(), 这里等价于 new (Foo.getName()),先执行 Foo.getName(),输出 2,然后new一个实例;
- new Foo().getName(), 这 里等价于 (new Foo()).getName(), 先new一个Foo的实例,再执行这个实例的getName方法,但是这个实例本身没有这个方法,所以去原型链protot上边找,实例.protot === Foo.prototype,所以输出 3;
- new new Foo().getName(), 这里等价于new (new Foo().getName()),如上述6,先输出 3,然后new 一个 new Foo().getName() 的实例。
什么是闭包,闭包的作用是什么
当一个内部函数被调用,就会形成闭包,闭包就是能够读取其他函数内部变量的函数。 | |
闭包作用: | |
局部变量无法共享和长久的保存,而全局变量可能造成变量污染,所以我们希望有一种机制既可以长久的保存变量又不会造成全局污染。 |
寄生组合继承
题目描述:实现一个你认为不错的 js 继承方式
实现代码如下:
function Parent(name) { | |
this.name = name; | |
this.say = () => { | |
console.log(111); | |
}; | |
} | |
Parent.prototype.play = () => { | |
console.log(222); | |
}; | |
function Children(name) { | |
Parent.call(this); | |
this.name = name; | |
} | |
Children.prototype = Object.create(Parent.prototype); | |
Children.prototype.constructor = Children; | |
// let child = new Children("111"); | |
// // console.log(child.name); | |
// // child.say(); | |
// // child.play(); |
实现函数原型方法
call
使用一个指定的 this 值和一个或多个参数来调用一个函数。
实现要点:
- this 可能传入 null;
- 传入不固定个数的参数;
- 函数可能有返回值;
Function.prototype.call2 = function (context) { | |
var context = context || window; | |
context.fn = this; | |
var args = []; | |
for(var i = 1, len = arguments.length; i < len; i++) { | |
args.push('arguments[' + i + ']'); | |
} | |
var result = eval('context.fn(' + args +')'); | |
delete context.fn | |
return result; | |
} |
apply
apply 和 call 一样,唯一的区别就是 call 是传入不固定个数的参数,而 apply 是传入一个数组。
实现要点:
- this 可能传入 null;
- 传入一个数组;
- 函数可能有返回值;
Function.prototype.apply2 = function (context, arr) { | |
var context = context || window; | |
context.fn = this; | |
var result; | |
if (!arr) { | |
result = context.fn(); | |
} else { | |
var args = []; | |
for (var i = 0, len = arr.length; i < len; i++) { | |
args.push('arr[' + i + ']'); | |
} | |
result = eval('context.fn(' + args + ')') | |
} | |
delete context.fn | |
return result; | |
} |
bind
bind 方法会创建一个新的函数,在 bind() 被调用时,这个新函数的 this 被指定为 bind() 的第一个参数,而其余参数将作为新函数的参数,供调用时使用。
实现要点:
- bind() 除了 this 外,还可传入多个参数;
- bing 创建的新函数可能传入多个参数;
- 新函数可能被当做构造函数调用;
- 函数可能有返回值;
Function.prototype.bind2 = function (context) { | |
var self = this; | |
var args = Array.prototype.slice.call(arguments, 1); | |
var fNOP = function () {}; | |
var fBound = function () { | |
var bindArgs = Array.prototype.slice.call(arguments); | |
return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs)); | |
} | |
fNOP.prototype = this.prototype; | |
fBound.prototype = new fNOP(); | |
return fBound; | |
} |
实现 new 关键字
new 运算符用来创建用户自定义的对象类型的实例或者具有构造函数的内置对象的实例。
实现要点:
- new 会产生一个新对象;
- 新对象需要能够访问到构造函数的属性,所以需要重新指定它的原型;
- 构造函数可能会显示返回;
function objectFactory() { | |
var obj = new Object() | |
Constructor = [].shift.call(arguments); | |
obj.__proto__ = Constructor.prototype; | |
var ret = Constructor.apply(obj, arguments); | |
// ret || obj 这里这么写考虑了构造函数显示返回 null 的情况 | |
return typeof ret === 'object' ? ret || obj : obj; | |
}; |
使用:
function person(name, age) { | |
this.name = name | |
this.age = age | |
} | |
let p = objectFactory(person, '布兰', 12) | |
console.log(p) // { name: '布兰', age: 12 } |
实现 instanceof 关键字
instanceof 就是判断构造函数的 prototype 属性是否出现在实例的原型链上。
function instanceOf(left, right) { | |
let proto = left.__proto__ | |
while (true) { | |
if (proto === null) return false | |
if (proto === right.prototype) { | |
return true | |
} | |
proto = proto.__proto__ | |
} | |
} |
上面的 left.proto 这种写法可以换成 Object.getPrototypeOf(left)。
实现 Object.create
Object.create()方法创建一个新对象,使用现有的对象来提供新创建的对象的proto。
Object.create2 = function(proto, propertyObject = undefined) { | |
if (typeof proto !== 'object' && typeof proto !== 'function') { | |
throw new TypeError('Object prototype may only be an Object or null.') | |
if (propertyObject == null) { | |
new TypeError('Cannot convert undefined or null to object') | |
} | |
function F() {} | |
F.prototype = proto | |
const obj = new F() | |
if (propertyObject != undefined) { | |
Object.defineProperties(obj, propertyObject) | |
} | |
if (proto === null) { | |
// 创建一个没有原型对象的对象,Object.create(null) | |
obj.__proto__ = null | |
} | |
return obj | |
} |
实现 Object.assign
Object.assign2 = function(target, ...source) { | |
if (target == null) { | |
throw new TypeError('Cannot convert undefined or null to object') | |
} | |
let ret = Object(target) | |
source.forEach(function(obj) { | |
if (obj != null) { | |
for (let key in obj) { | |
if (obj.hasOwnProperty(key)) { | |
ret[key] = obj[key] | |
} | |
} | |
} | |
}) | |
return ret | |
} |
实现 JSON.stringify
JSON.stringify([, replacer , space) 方法是将一个 JavaScript 值(对象或者数组)转换为一个 JSON 字符串。此处模拟实现,不考虑可选的第二个参数 replacer 和第三个参数 space
- 基本数据类型:
- undefined 转换之后仍是 undefined(类型也是 undefined)
- boolean 值转换之后是字符串 "false"/"true"
- number 类型(除了 NaN 和 Infinity)转换之后是字符串类型的数值
- symbol 转换之后是 undefined
- null 转换之后是字符串 "null"
- string 转换之后仍是string
- NaN 和 Infinity 转换之后是字符串 "null"
- 函数类型:转换之后是 undefined
- 如果是对象类型(非函数)
- 如果是一个数组:如果属性值中出现了 undefined、任意的函数以及 symbol,转换成字符串 "null" ;
- 如果是 RegExp 对象:返回 {} (类型是 string);
- 如果是 Date 对象,返回 Date 的 toJSON 字符串值;
- 如果是普通对象;
- 如果有 toJSON() 方法,那么序列化 toJSON() 的返回值。
- 如果属性值中出现了 undefined、任意的函数以及 symbol 值,忽略。
- 所有以 symbol 为属性键的属性都会被完全忽略掉。
- 对包含循环引用的对象(对象之间相互引用,形成无限循环)执行此方法,会抛出错误。
function jsonStringify(data) { | |
let dataType = typeof data; | |
if (dataType !== 'object') { | |
let result = data; | |
//data 可能是 string/number/null/undefined/boolean | |
if (Number.isNaN(data) || data === Infinity) { | |
//NaN 和 Infinity 序列化返回 "null" | |
result = "null"; | |
} else if (dataType === 'function' || dataType === 'undefined' || dataType === 'symbol') { | |
//function 、undefined 、symbol 序列化返回 undefined | |
return undefined; | |
} else if (dataType === 'string') { | |
result = '"' + data + '"'; | |
} | |
//boolean 返回 String() | |
return String(result); | |
} else if (dataType === 'object') { | |
if (data === null) { | |
return "null" | |
} else if (data.toJSON && typeof data.toJSON === 'function') { | |
return jsonStringify(data.toJSON()); | |
} else if (data instanceof Array) { | |
let result = []; | |
//如果是数组 | |
//toJSON 方法可以存在于原型链中 | |
data.forEach((item, index) => { | |
if (typeof item === 'undefined' || typeof item === 'function' || typeof item === 'symbol') { | |
result[index] = "null"; | |
} else { | |
result[index] = jsonStringify(item); | |
} | |
}); | |
result = "[" + result + "]"; | |
return result.replace(/'/g, '"'); | |
} else { | |
//普通对象 | |
/** * 循环引用抛错(暂未检测,循环引用时,堆栈溢出) * symbol key 忽略 * undefined、函数、symbol 为属性值,被忽略 */ | |
let result = []; | |
Object.keys(data).forEach((item, index) => { | |
if (typeof item !== 'symbol') { | |
//key 如果是symbol对象,忽略 | |
if (data[item] !== undefined && typeof data[item] !== 'function' | |
&& typeof data[item] !== 'symbol') { | |
//键值如果是 undefined、函数、symbol 为属性值,忽略 | |
result.push('"' + item + '"' + ":" + jsonStringify(data[item])); | |
} | |
} | |
}); | |
return ("{" + result + "}").replace(/'/g, '"'); | |
} | |
} | |
} |
实现 JSON.parse
介绍 2 种方法实现:
- eval 实现;
- new Function 实现;
eval 实现
第一种方式最简单,也最直观,就是直接调用 eval,代码如下:
var json = '{"a":"1", "b":2}'; | |
var obj = eval("(" + json + ")"); // obj 就是 json 反序列化之后得到的对象 |
但是直接调用 eval 会存在安全问题,如果数据中可能不是 json 数据,而是可执行的 JavaScript 代码,那很可能会造成 XSS 攻击。因此,在调用 eval 之前,需要对数据进行校验。
var rx_one = /^[\],:{}\s]*$/; | |
var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g; | |
var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; | |
var rx_four = /(?:^|:|,)(?:\s*\[)+/g; | |
if ( | |
rx_one.test( | |
json.replace(rx_two, "@") | |
.replace(rx_three, "]") | |
.replace(rx_four, "") | |
) | |
) { | |
var obj = eval("(" +json + ")"); | |
} |
new Function 实现
Function 与 eval 有相同的字符串参数特性。
var json = '{"name":"小姐姐", "age":20}'; | |
var obj = (new Function('return ' + json))(); |
实现 Promise
实现 Promise 需要完全读懂 Promise A+ 规范,不过从总体的实现上看,有如下几个点需要考虑到:
- then 需要支持链式调用,所以得返回一个新的 Promise;
- 处理异步问题,所以得先用 onResolvedCallbacks 和 onRejectedCallbacks 分别把成功和失败的回调存起来;
- 为了让链式调用正常进行下去,需要判断 onFulfilled 和 onRejected 的类型;
- onFulfilled 和 onRejected 需要被异步调用,这里用 setTimeout 模拟异步;
- 处理 Promise 的 resolve;
const PENDING = 'pending'; | |
const FULFILLED = 'fulfilled'; | |
const REJECTED = 'rejected'; | |
class Promise { | |
constructor(executor) { | |
this.status = PENDING; | |
this.value = undefined; | |
this.reason = undefined; | |
this.onResolvedCallbacks = []; | |
this.onRejectedCallbacks = []; | |
let resolve = (value) = > { | |
if (this.status === PENDING) { | |
this.status = FULFILLED; | |
this.value = value; | |
this.onResolvedCallbacks.forEach((fn) = > fn()); | |
} | |
}; | |
let reject = (reason) = > { | |
if (this.status === PENDING) { | |
this.status = REJECTED; | |
this.reason = reason; | |
this.onRejectedCallbacks.forEach((fn) = > fn()); | |
} | |
}; | |
try { | |
executor(resolve, reject); | |
} catch (error) { | |
reject(error); | |
} | |
} | |
then(onFulfilled, onRejected) { | |
// 解决 onFufilled,onRejected 没有传值的问题 | |
onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (v) = > v; | |
// 因为错误的值要让后面访问到,所以这里也要抛出错误,不然会在之后 then 的 resolve 中捕获 | |
onRejected = typeof onRejected === "function" ? onRejected : (err) = > { | |
throw err; | |
}; | |
// 每次调用 then 都返回一个新的 promise | |
let promise2 = new Promise((resolve, reject) = > { | |
if (this.status === FULFILLED) { | |
//Promise/A+ 2.2.4 --- setTimeout | |
setTimeout(() = > { | |
try { | |
let x = onFulfilled(this.value); | |
// x可能是一个proimise | |
resolvePromise(promise2, x, resolve, reject); | |
} catch (e) { | |
reject(e); | |
} | |
}, 0); | |
} | |
if (this.status === REJECTED) { | |
//Promise/A+ 2.2.3 | |
setTimeout(() = > { | |
try { | |
let x = onRejected(this.reason); | |
resolvePromise(promise2, x, resolve, reject); | |
} catch (e) { | |
reject(e); | |
} | |
}, 0); | |
} | |
if (this.status === PENDING) { | |
this.onResolvedCallbacks.push(() = > { | |
setTimeout(() = > { | |
try { | |
let x = onFulfilled(this.value); | |
resolvePromise(promise2, x, resolve, reject); | |
} catch (e) { | |
reject(e); | |
} | |
}, 0); | |
}); | |
this.onRejectedCallbacks.push(() = > { | |
setTimeout(() = > { | |
try { | |
let x = onRejected(this.reason); | |
resolvePromise(promise2, x, resolve, reject); | |
} catch (e) { | |
reject(e); | |
} | |
}, 0); | |
}); | |
} | |
}); | |
return promise2; | |
} | |
} | |
const resolvePromise = (promise2, x, resolve, reject) = > { | |
// 自己等待自己完成是错误的实现,用一个类型错误,结束掉 promise Promise/A+ 2.3.1 | |
if (promise2 === x) { | |
return reject( | |
new TypeError("Chaining cycle detected for promise #<Promise>")); | |
} | |
// Promise/A+ 2.3.3.3.3 只能调用一次 | |
let called; | |
// 后续的条件要严格判断 保证代码能和别的库一起使用 | |
if ((typeof x === "object" && x != null) || typeof x === "function") { | |
try { | |
// 为了判断 resolve 过的就不用再 reject 了(比如 reject 和 resolve 同时调用的时候) Promise/A+ 2.3.3.1 | |
let then = x.then; | |
if (typeof then === "function") { | |
// 不要写成 x.then,直接 then.call 就可以了 因为 x.then 会再次取值,Object.defineProperty Promise/A+ 2.3.3.3 | |
then.call( | |
x, (y) = > { | |
// 根据 promise 的状态决定是成功还是失败 | |
if (called) return; | |
called = true; | |
// 递归解析的过程(因为可能 promise 中还有 promise) Promise/A+ 2.3.3.3.1 | |
resolvePromise(promise2, y, resolve, reject); | |
}, (r) = > { | |
// 只要失败就失败 Promise/A+ 2.3.3.3.2 | |
if (called) return; | |
called = true; | |
reject(r); | |
}); | |
} else { | |
// 如果 x.then 是个普通值就直接返回 resolve 作为结果 Promise/A+ 2.3.3.4 | |
resolve(x); | |
} | |
} catch (e) { | |
// Promise/A+ 2.3.3.2 | |
if (called) return; | |
called = true; | |
reject(e); | |
} | |
} else { | |
// 如果 x 是个普通值就直接返回 resolve 作为结果 Promise/A+ 2.3.4 | |
resolve(x); | |
} | |
}; |
Promise 写完之后可以通过 promises-aplus-tests 这个包对我们写的代码进行测试,看是否符合 A+ 规范。不过测试前还得加一段代码:
// promise.js | |
// 这里是上面写的 Promise 全部代码 | |
Promise.defer = Promise.deferred = function () { | |
let dfd = {} | |
dfd.promise = new Promise((resolve,reject)=>{ | |
dfd.resolve = resolve; | |
dfd.reject = reject; | |
}); | |
return dfd; | |
} | |
module.exports = Promise; |
全局安装:
npm i promises-aplus-tests -g
终端下执行验证命令:
promises-aplus-tests promise.js
上面写的代码可以顺利通过全部 872 个测试用例。
Promise.resolve
Promsie.resolve(value) 可以将任何值转成值为 value 状态是 fulfilled 的 Promise,但如果传入的值本身是 Promise 则会原样返回它。
Promise.resolve = function(value) { | |
// 如果是 Promsie,则直接输出它 | |
if(value instanceof Promise){ | |
return value | |
} | |
return new Promise(resolve => resolve(value)) | |
} |
Promise.reject
和 Promise.resolve() 类似,Promise.reject() 会实例化一个 rejected 状态的 Promise。但与 Promise.resolve() 不同的是,如果给 Promise.reject() 传递一个 Promise 对象,则这个对象会成为新 Promise 的值。
Promise.reject = function(reason) { | |
return new Promise((resolve, reject) => reject(reason)) | |
} |
Promise.all
Promise.all 的规则是这样的:
- 传入的所有 Promsie 都是 fulfilled,则返回由他们的值组成的,状态为 fulfilled 的新 Promise;
- 只要有一个 Promise 是 rejected,则返回 rejected 状态的新 Promsie,且它的值是第一个 rejected 的 Promise 的值;
- 只要有一个 Promise 是 pending,则返回一个 pending 状态的新 Promise;
Promise.all = function(promiseArr) { | |
let index = 0, result = [] | |
return new Promise((resolve, reject) => { | |
promiseArr.forEach((p, i) => { | |
Promise.resolve(p).then(val => { | |
index++ | |
result[i] = val | |
if (index === promiseArr.length) { | |
resolve(result) | |
} | |
}, err => { | |
reject(err) | |
}) | |
}) | |
}) | |
} |
Promise.race
Promise.race 会返回一个由所有可迭代实例中第一个 fulfilled 或 rejected 的实例包装后的新实例。
Promise.race = function(promiseArr) { | |
return new Promise((resolve, reject) => { | |
promiseArr.forEach(p => { | |
Promise.resolve(p).then(val => { | |
resolve(val) | |
}, err => { | |
rejecte(err) | |
}) | |
}) | |
}) | |
} |
Promise.allSettled
Promise.allSettled 的规则是这样:
- 所有 Promise 的状态都变化了,那么新返回一个状态是 fulfilled 的 Promise,且它的值是一个数组,数组的每项由所有 Promise 的值和状态组成的对象;
- 如果有一个是 pending 的 Promise,则返回一个状态是 pending 的新实例;
Promise.allSettled = function(promiseArr) { | |
let result = [] | |
return new Promise((resolve, reject) => { | |
promiseArr.forEach((p, i) => { | |
Promise.resolve(p).then(val => { | |
result.push({ | |
status: 'fulfilled', | |
value: val | |
}) | |
if (result.length === promiseArr.length) { | |
resolve(result) | |
} | |
}, err => { | |
result.push({ | |
status: 'rejected', | |
reason: err | |
}) | |
if (result.length === promiseArr.length) { | |
resolve(result) | |
} | |
}) | |
}) | |
}) | |
} |
Promise.any
Promise.any 的规则是这样:
- 空数组或者所有 Promise 都是 rejected,则返回状态是 rejected 的新 Promsie,且值为 AggregateError 的错误;
- 只要有一个是 fulfilled 状态的,则返回第一个是 fulfilled 的新实例;
- 其他情况都会返回一个 pending 的新实例;
Promise.any = function(promiseArr) { | |
let index = 0 | |
return new Promise((resolve, reject) => { | |
if (promiseArr.length === 0) return | |
promiseArr.forEach((p, i) => { | |
Promise.resolve(p).then(val => { | |
resolve(val) | |
}, err => { | |
index++ | |
if (index === promiseArr.length) { | |
reject(new AggregateError('All promises were rejected')) | |
} | |
}) | |
}) | |
}) | |
} |
localStorage sessionStorage cookies 有什么区别?
localStorage:以键值对的方式存储 储存时间没有限制 永久生效 除非自己删除记录 | |
sessionStorage:当页面关闭后被清理与其他相比不能同源窗口共享 是会话级别的存储方式 | |
cookies 数据不能超过4k 同时因为每次http请求都会携带cookie 所有cookie只适合保存很小的数据 如会话标识 |
回流与重绘的概念及触发条件
(1)回流
当渲染树中部分或者全部元素的尺寸、结构或者属性发生变化时,浏览器会重新渲染部分或者全部文档的过程就称为回流。
下面这些操作会导致回流:
- 页面的首次渲染
- 浏览器的窗口大小发生变化
- 元素的内容发生变化
- 元素的尺寸或者位置发生变化
- 元素的字体大小发生变化
- 激活CSS伪类
- 查询某些属性或者调用某些方法
- 添加或者删除可见的DOM元素
在触发回流(重排)的时候,由于浏览器渲染页面是基于流式布局的,所以当触发回流时,会导致周围的DOM元素重新排列,它的影响范围有两种:
- 全局范围:从根节点开始,对整个渲染树进行重新布局
- 局部范围:对渲染树的某部分或者一个渲染对象进行重新布局
(2)重绘
当页面中某些元素的样式发生变化,但是不会影响其在文档流中的位置时,浏览器就会对元素进行重新绘制,这个过程就是重绘。
下面这些操作会导致回流:
- color、background 相关属性:background-color、background-image 等
- outline 相关属性:outline-color、outline-width 、text-decoration
- border-radius、visibility、box-shadow
注意: 当触发回流时,一定会触发重绘,但是重绘不一定会引发回流。
Number() 的存储空间是多大?如果后台发送了一个超过最大自己的数字怎么办
Math.pow(2, 53) ,53 为有效数字,会发生截断,等于 JS 能支持的最大数字。
说一下你对盒模型的理解?
CSS3中的盒模型有以下两种:标准盒模型、IE盒模型
盒模型都是由四个部分组成的,分别是margin、border、padding和content
标准盒模型和IE盒模型的区别在于设置width和height时, 所对应的范围不同
1、标准盒模型的width和height属性的范围只包含了content
2、IE盒模型的width和height属性的范围包含了border、padding和content
可以通过修改元素的box-sizing属性来改变元素的盒模型;
1、box-sizing:content-box表示标准盒模型(默认值)
2、box-sizing:border-box表示IE盒模型(怪异盒模型)