2024前端面试之JavaScript手写题（一），当面试遇到回答不出的问题的时候,该如何巧妙地回答

本文链接：https://blog.csdn.net/HUAXIAL/article/details/137728229

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

function myNew(ctor,…args){

if(typeof ctor !== ‘function’){

throw ‘myNew function the first param must be a function’;

}

var newObj = Object.create(ctor.prototype); //创建一个继承自ctor.prototype的新对象

var ctorReturnResult = ctor.apply(newObj, args); //将构造函数ctor的this绑定到newObj中

var isObject = typeof ctorReturnResult === ‘object’ && ctorReturnResult !== null;

var isFunction = typeof ctorReturnResult === ‘function’;

if(isObject || isFunction){

return ctorReturnResult;

}

return newObj;

}

let c = myNew(Ctor);

7.instanceof的实现

instanceof 是用来判断A是否为B的实例，表达式为：A instanceof B，如果A是B的实例，则返回true,否则返回false。
instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性。
不能检测基本数据类型，在原型链上的结果未必准确，不能检测null,undefined
实现：遍历左边变量的原型链，直到找到右边变量的 prototype，如果没有找到，返回 false

function myInstanceOf(a,b){

let left = a.proto;

let right = b.prototype;

while(true){

if(left == null){

return false

}

if(left == right){

return true

}

left = left.proto

}

//instanceof 运算符用于判断构造函数的 prototype 属性是否出现在对象的原型链中的任何位置。

function myInstanceof(left, right) {

let proto = Object.getPrototypeOf(left), // 获取对象的原型

prototype = right.prototype; // 获取构造函数的 prototype 对象

// 判断构造函数的 prototype 对象是否在对象的原型链上

while (true) {

if (!proto) return false;

if (proto === prototype) return true;

proto = Object.getPrototypeOf(proto);

}

8.Object.create()的实现

MDN文档
Object.create()会将参数对象作为一个新创建的空对象的原型, 并返回这个空对象

//简略版

function myCreate(obj){

// 新声明一个函数

function C(){};

// 将函数的原型指向obj

C.prototype = obj;

// 返回这个函数的实力化对象

return new C()

}

//官方版Polyfill

if (typeof Object.create !== “function”) {

Object.create = function (proto, propertiesObject) {

if (typeof proto !== ‘object’ && typeof proto !== ‘function’) {

throw new TypeError('Object prototype may only be an Object: ’ + proto);

} else if (proto === null) {

throw new Error(“This browser’s implementation of Object.create is a shim and doesn’t support ‘null’ as the first argument.”);

}

if (typeof propertiesObject !== ‘undefined’) throw new Error(“This browser’s implementation of Object.create is a shim and doesn’t support a second argument.”);

function F() {}

F.prototype = proto;

return new F();

};

}

9.实现 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

}

10.Promise的实现

实现 Promise 需要完全读懂 Promise A+ 规范，不过从总体的实现上看，有如下几个点需要考虑到：

Promise本质是一个状态机，且状态只能为以下三种：Pending（等待态）、Fulfilled（执行态）、Rejected（拒绝态），状态的变更是单向的，只能从Pending -> Fulfilled 或 Pending -> Rejected，状态变更不可逆
then 需要支持链式调用

class Promise {

callbacks = [];

state = ‘pending’;//增加状态

value = null;//保存结果

constructor(fn) {

fn(this._resolve.bind(this), this._reject.bind(this));

}

then(onFulfilled, onRejected) {

return new Promise((resolve, reject) => {

this._handle({

onFulfilled: onFulfilled || null,

onRejected: onRejected || null,

resolve: resolve,

reject: reject

});

}

_handle(callback) {

if (this.state === ‘pending’) {

this.callbacks.push(callback);

return;

}

let cb = this.state === ‘fulfilled’ ? callback.onFulfilled : callback.onRejected;

if (!cb) {//如果then中没有传递任何东西

cb = this.state === ‘fulfilled’ ? callback.resolve : callback.reject;

cb(this.value);

return;

}

let ret = cb(this.value);

cb = this.state === ‘fulfilled’ ? callback.resolve : callback.reject;

cb(ret);

}

_resolve(value) {

if (value && (typeof value === ‘object’ || typeof value === ‘function’)) {

var then = value.then;

if (typeof then === ‘function’) {

then.call(value, this._resolve.bind(this), this._reject.bind(this));

return;

}

this.state = ‘fulfilled’;//改变状态

this.value = value;//保存结果

this.callbacks.forEach(callback => this._handle(callback));

}

_reject(error) {

this.state = ‘rejected’;

this.value = error;

this.callbacks.forEach(callback => this._handle(callback));

}

Promise.resolve

Promsie.resolve(value) 可以将任何值转成值为 value 状态是 fulfilled 的 Promise，但如果传入的值本身是 Promise 则会原样返回它。

Promise.resolve(value) {

if (value && value instanceof Promise) {

return value;

} else if (value && typeof value === ‘object’ && typeof value.then === ‘function’) {

let then = value.then;

return new Promise(resolve => {

then(resolve);

});

} else if (value) {

return new Promise(resolve => resolve(value));

} else {

return new Promise(resolve => resolve());

}

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

传入的所有 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§.then(val => {

index++

result[i] = val

if (index === promiseArr.length) {

resolve(result)

}

}, err => {

reject(err)