手写题

数组去重

冒泡排序

详情
// 将数组中的数从小到大排列
var arr = [1, 4, 6, 7, 9, 3, 5, 8]
// var numi = 0
// var numj = 0
for (var j = 0; j < arr.length - 1; j++) {
// numj += 1
var flag = true
for (var i = 0; i < arr.length - 1 - j; i++) {
// document.write('(' + arr[i] + ',' + arr[i + 1] + ')')
// numi += 1
// 两两比较,如果前面的大于后面的,交换位置
if (arr[i] > arr[i + 1]) {
flag = false
var temp
temp = arr[i]
arr[i] = arr[i + 1]
arr[i + 1] = temp
// document.write('交换了')
}
}
// document.write(',arr=(' + arr + ')')
// document.write('<br>')
// 如果一趟下来,一次交换都没有做,说明就已经排好序,就不需要继续比
if (flag) {
break
}
}

实现 call apply bind 方法

详情

call 和 apply 区别

call:

Function.prototype.myCall = function(context) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
context = context || window
var args = Array.prototype.slice.apply(arguments, [1]) // 获取额外参数
// var args = [...arguments].slice(1)
context.fn = this
var res = context.fn(...args)
delete context.fn
return res
}

context 为要绑定的 this,不传默认为 window
给 context 创建一个 fn 属性,并将值设置为需要调用的函数
调用 context.fn,并将额外参数 args 传递进去
删除 context 上的 fn 函数

apply:

Function.prototype.myApply = function(context) {
if (typeof this !== 'function') {
throw new TypeError('Error')
}
context = context || window
context.fn = this
let res
if (!arguments[1]) {
res = context.fn()
} else if (arguments[1].constructor.name === 'Array') {
res = context.fn(...arguments[1])
} else {
return console.error('Uncaught TypeError: CreateListFromArrayLike called on non-object')
// throw 'Uncaught TypeError: CreateListFromArrayLike called on non-object'
}
delete context.fn
return res
}

bind:

Function.prototype.myBind = function() {
var self = this // 保存原函数
var args = Array.prototype.slice.call(arguments) // 参数转为数组
// var args = [...arguments].slice(1) // 参数转为数组
var context = args.shift() // 保存需要绑定的this上下文
return function() {
// 返回一个新函数
self.apply(context, args.concat([].slice.call(arguments)))
}
}
function aaa(val, val1) {
console.log(val)
console.log(val1)
console.log(this.name)
}
aaa()
aaa.myCall({ name: '123' }, '121', 122)
aaa.myApply({ name: '123' }, ['121', 122])
aaa.myBind({ name: '123' })('111', '222')

防抖和节流

深浅拷贝

手写 Promise

手写 Promise.all

手写 Promise.race

异步调度

实现继承的方式

参考:https://www.cnblogs.com/humin/p/4556820.html

原型链继承,将父类的实例作为子类的原型,无法实现多继承

function Cat(){
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

构造继承,使用父类的构造函数来增强子类实例,等于是复制父类的实例属性给子类(没用到原型)

function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}

组合继承,通过调用父类构造,继承父类的属性并保留传参的优点,然后通过将父类实例作为子类原型,实现函数复用

function Cat(name){
Animal.call(this);
this.name = name || 'Tom';
}
Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

调用了两次父类构造函数,生成了两份实例

寄生组合继承
通过寄生方式,砍掉父类的实例属性,这样,在调用两次父类的构造的时候,就不会初始化两次实例方法/属性,避免的组合继承的缺点

es6 中的继承

class Super {}
class Sub extends Super {}

const sub = new Sub()

Sub.__proto__ === Super

子类可以直接通过 __proto__ 寻址到父类

function Super() {}
function Sub() {}

Sub.prototype = new Super()
Sub.prototype.constructor = Sub

var sub = new Sub()

Sub.__proto__ === Function.prototype

而通过 ES5 的方式,Sub.__proto__ === Function.prototype

es5继承 与 es6 继承的区别参考 https://github.com/Advanced-Frontend/Daily-Interview-Question/issues/20

发布订阅

扁平数据转tree

实现 instanceof

// a instanceof b  b.prototype 是否在 a 的原型链中
function myInstanceof(a, b) {
if (typeof a === 'object' || a === null) return false

// getProtypeOf是Object对象自带的一个方法,能够拿到参数的原型对象
let proto = Object.getPrototypeOf(a)
while (true) {
// 查找到尽头,还没找到
if (proto == null) return false
// 找到相同的原型对象
if (proto == b.prototype) return true
proto = Object.getPrototypeof(proto)
}
}

实现一个 new 操作符

实现 JSON.stringify

手机号 3-4-4 分割
千分位格式化数字