手写promise原理——高阶函数实现——函数柯里化原理——实现通用柯里化函数——函数订阅发布模式实现——手写观察者模式

最新推荐文章于 2022-12-08 12:02:12 发布
最新推荐文章于 2022-12-08 12:02:12 发布
阅读量671 收藏
点赞数
分类专栏： JavaScript 文章标签： javascript 前端 typescript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44984407/article/details/121754688
版权

1. 高阶函数

// 高阶函数： 如果一个函数的参数是一个函数（回调函数也是高阶函数的一种）
//  如果一个函数返回 一个函数 当前函数也是一个 高阶函数  

// 扩展当前业务代码 
function say(a,b){
	console.log("say",a,b);
}
// 给某个方法添加方法 在执行之前调用 
Function.prototype.before = function(callback){
	// let _this = this; // 让this 指向say  
	//return function(){
	//	callback();
		// 注意 this 
	//	this()  
	//}
	// 剩余运算符 ...args   ... 在函数参数里 把所有参数组成数组 在函数调用 表示展开 参数依次传入 
	return (...args)=>{
		// 箭头函数 没有this 和 arguments
		callback();
		this(...args); 
	}
}
let beforeSay = say.before(function(){
 	console.log('before.say');
});
// 之后调用 beforeSay
beforeSay("hello","word");

2. 函数柯里化

// 函数柯里化 函数反柯里化 

// 判断变量的类型 
// 常用的判断 类型的方法。 

 -  typeof  不能判断对象类型 （ 数组和 对象都是 Object ）;
 -  constructor 判断类型的构造  
 - instanceof  判断谁是谁 实例 （判断会存在不准确的情况） __proto__ ;
 - Object.prototype.toString.call() // 获取对象原型上的 toStiong 上的 this  是当前的对象 缺陷 不能判断谁是谁的实例	
 
 function istype(value,type){
	return Object.prototype.toString.call(value) === `[object ${type}]`;
};
// 方法的详细拆分 isType => isString isArray 
console.log(istype([],'Array'));
  // 柯里化
  function isType(type){
	return function(value){
		return Object.protottpe.toString.call(value) === `[Object ${type}]`
	}
}
let isString = isType('String'); // 创造固定类型函数
let isArray = isType('Array'); 
let Object = isType('Object');
console.log(isString('value'));
console.log([]);
// 实现通用函数柯里化 （通过一个通用的柯里化函数，实现函数的柯里化）
const currying = (fn,arr=[])=>{
	let len = fn.length; // 获取函数参数的个数
	return (...args)=>{
		let arg = arr.concat(args); // [...arr,...args]
		if(arg.length < len){
			return 	currying(fn,arg);
		}
		return fn(...arg);
	}
}
const add = (a,b,c,d,e)=>{
	return a + b + c + d + e;
}
let r = currying(add)(1)(2,3)(4,5);
isArray = curring(istype)('Array');
isString = curring(istype)('String');
console.log(isArray([]));
console.log(isString('hello'));

  1. 回调函数异步并发问题

// 多个异步请求 同时获取 最终结果
const after = (times, callback) => () => {
  if (--times === 0) {
    callback();
  }
};
const newFn = after(3, () => {
  console.log("ok");
});

  1. 发布订阅模

// on-emit 模式
 let man = {}
 let fs = require('fs'); // file system 
 let even = { // 发布和订阅没有明星的关系
	 arr:[],
	 on(fn){
		 this.arr.push(fn);
	 },
	 emit(){ 
		 this.arr.forEach(fn=>fn());
	 },
 };
 even.on(()=>{console.log("读取数据")})
 fs.readFile('./name.txt','utf8',(err,data)=>{
	 man.name = data;
	 // console.log(man,'1')
	even.emit();
 })
 fs.readFile('./age.txt','utf8',(err,data)=>{
 	 man.age = data;
	 // console.log(man,"3")
	 even.emit();
 })
 even.on(()=>{
	 if(Object.keys(man).length !==2)return
	 console.log("读取数据",man)
 })

  1. 观察者模式

// 观察者模式  观察者 和被观察者 观察者需要发到被观察者中 被观察者发生变化 需要告之被观察者

// 内部也是基于订阅发布者模式  收集观察者 状态变化 通知观察者 

  class Subject { // 被观察者 
		constructor(name) {
		    this.name = name;
			this.state = "面无表情";
			this.observers = [];
		}
		attach(o){
			this.observers.push(o);
		}
		SetState(newState){
			this.state = newState;
			this.observers.forEach(o=>o.update(this))
		}
	  
  }
  class Observer{
	  constructor(name) {
	      this.name = name;
		  
	  }
	  update(baby){
		  console.log(`这个${this.name}被通知了${baby.name}他${baby.state}`);
	  }
  }
  let baby = new Subject('张太阳');
  let parent = new Observer('爸爸');
  let mother = new Observer('妈妈');
  baby.attach(parent);
  baby.attach(mother);
  baby.SetState('饿哭了');

  1. 简单的promise

promise 的简单理解

//  promise 的概念 以及特点

// https://promisesaplus.com/   promisea+ 规范 
//  https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise

//  promise Es6 内部已经完全实现  ie 不支持promis , 需要 polyfill  es6-promise 

// promise	的产生原因 用于解决异步问题

//  1. 异步 请求的多并发问题 （希望同步最终结果） promise.all 
//  2. 异步请求问题（异步回调儿地狱-回调金字塔问题）上一个请求的输出是下一个请求的参数 Promise 的链式调用 可以解决这个问题
//  3. 缺陷 还是基于回调的 
	
// promise 有三个状态： 成功态(resolve) 失败态(reject) 等待态(pending) (不成功也不失败)
// promise 就是一个类 
// 用户自己决定失败的原因和成功的原因 成功和失败也是用户自己定义的 取决于用户调了那个方法 
// 1.promise 执行器是默认立即 执行
// 2.promise 的每个实例都有一个 then 的方法 一个参数是成功的回调 一个参数是失败的回调  
// 3.如果执行函数的时候发生了异常(执行了异常的逻辑) 也会执行失败
// 4.promise 一旦成功就不可能失败 一旦失败就不可能成功 
let promise = new Promise((resolve,reject)=>{
	
	// throw new Error("失败了"); 
	console.log(1)
	reject("没有发工资");
	resolve("今天墨鱼了");
	
})
console.log(2);
console.log(promise);


promise.then((resole)=>{
	//  这里走的是成功的回调函数
	
	console.log( "success",resole);
},(reject)=>{
	//  这里走的是失败的回调函数  
	console.log("err",reject);
})

实现一个简单的promise

// promise 有三个状态 pending(等待态)  resolve(成功态) reject(失败态)
let PENDING = "PENDING"; // 等待态
let RESOLVE = "RESOLVE"; // 成功态
let REJECT = "REJECT"; // 失败态
// promise 是个类  创建一个promise 类
class Promise{
	constructor(executor){
        this.status = PENDING;
        this.value = undefined; // 成功的原因
        this.reason = undefined; // 失败的原因
        let resolve = (value)=>{
            if(this.status === "PEDING"){
                this.value = value;
                this.status = RESOLVE;
            }

        } // 不属于实例上的 是单独每个人都有的
        let reject = (reason)=>{
            if(this.status === "PENDING"){
                this.reason = reason;
                this.status = REJECT;
            }

        }
        // promise 发生了错误的逻辑也会 执行 失败
        try{
            executor(resolve,reject); // 这个是执行器 默认立即执行
        }catch (e) {
            console.log(e)
            reject(e);
        }
    }
    then(onFulfiled,onRjected){
        if(this.status === RESOLVE){
            onFulfiled(this.value);
        }
        if(this.status === REJECT){
            onRjected(this.reason);
        }
    }
}

promise 的 then 方法 实现

// promise 有三个状态 pending(等待态)  resolve(成功态) reject(失败态)
let PENDING = "PENDING"; // 等待态
let RESOLVE = "RESOLVE"; // 成功态
let REJECT = "REJECT"; // 失败态
// promise 是个类  创建一个promise 类
class Promise{
	constructor(executor){
        this.status = PENDING;
        this.value = undefined; // 成功的原因
        this.reason = undefined; // 失败的原因
        this.onResolvedCallbacks = []; // 成功的回调函数 集合
        this.onRejectedCallbacks =[]; // 失败的回调函数 集合
        let resolve = (value)=>{
            if(this.status === "PEDING"){
                this.value = value;
                this.status = RESOLVE;
                console.log(this.onResolvedCallbacks)
                this.onResolvedCallbacks.forEach(fn=>fn());
            }

        } // 不属于实例上的 是单独每个人都有的
        let reject = (reason)=>{
            if(this.status === "PENDING"){
                this.reason = reason;
                this.status = REJECT;
                console.log(this.onRejectedCallbacks)
                this.onRejectedCallbacks.forEach(fn=>fn());
            }

        }
        // promise 发生了错误的逻辑也会 执行 失败
        try{
            executor(resolve,reject); // 这个是执行器 默认立即执行
        }catch (e) {
            console.log(e)
            reject(e);
        }
    }
    then(onFulfiled,onRejected){
        console.log(1,this.onResolvedCallbacks)
        console.log(1,this.onRejectedCallbacks)
        if(this.status === RESOLVE){
            onFulfiled(this.value);
        }
        if(this.status === REJECT){
            onRejected(this.reason);
        }
    if(this.status === PENDING){

        this.onResolvedCallbacks.push(()=>{
            onFulfiled(this.value);
        })
        this.onRejectedCallbacks.push(()=>{
            onRejected(this.reason);
        })
    }
    }
}
module.exports = Promise;

promise 的 then的用法解析

let fs = require("fs");
//  error first 错误第一  异步方法 无法通过 try catch 捕获异常
// fs.readFile("./name.text","utf8",(err,data)=>{
//     console.log(data);
//     if(err){}
//     fs.readFile(data,"utf8",(err,data)=>{
//         if(err){}
//         console.log(data);
//     })
// });
// 写法没有问题 但是错误处理麻烦
// promis 可以解决上面的问题
function read(fillname){
    return new Promise((resolve, reject)=>{
         fs.readFile(fillname,"utf8",(err,data)=>{
             if(err)return reject(err)
             resolve(data)
         })
    })
}
// 1.promise 的 成功或失败的回调的 返回值 可以传递到外层的 then
// 2. 如果返回值为普通值 可以当下一个回调 then 的参数 可能有 promise 的情况(采用 promis的状态 判断下一次的 成功或者失败) 还有 error的情况 出错就一点会走下一次的失败
// 3. 错误处理 如果 自己没有错误处理 他会向下查找
// 4. 每次执行完promise.then 方法后返回的都是一个 "promise" (promise 一旦成功或者失败就不能修改)
read("./name.txt").then((data)=>{
    console.log(data);
    return read(data);
},(err)=>{
    console.log(err);
    throw new Error("错误");
}).then((data)=>{
    console.log("______",data);
},(err)=>{
    console.log("____",err+"错误");
})
// 这样就是通过了 链式调用解决了回调 嵌套问题

普通值的处理

// promise 有三个状态 pending(等待态)  resolve(成功态) reject(失败态)
let PENDING = "PENDING"; // 等待态
let RESOLVE = "RESOLVE"; // 成功态
let REJECT = "REJECT"; // 失败态
// promise 是个类  创建一个promise 类
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.value = value;
                this.status = RESOLVE;
                console.log(this.onResolvedCallbacks)
                this.onResolvedCallbacks.forEach(fn => fn());
            }

        } // 不属于实例上的 是单独每个人都有的
        let reject = (reason) => {
            if (this.status === PENDING) {
                this.reason = reason;
                this.status = REJECT;
                console.log(this.onRejectedCallbacks)
                this.onRejectedCallbacks.forEach(fn => fn());
            }

        }
        // promise 发生了错误的逻辑也会 执行 失败
        try {
            executor(resolve, reject); // 这个是执行器 默认立即执行
        } catch (e) {
            console.log(e)
            reject(e);
        }
    }

    // 1.promise 的 成功或失败的回调的 返回值 可以传递到外层的 then
    // 2. 如果返回值为普通值 可以当下一个回调 then 的参数 可能有 promise 的情况(采用 promis的状态 判断下一次的 成功或者失败) 还有 error的情况 出错就一点会走下一次的失败
    // 3. 错误处理 如果 自己没有错误处理 他会向下查找
    // 4. 每次执行完promise.then 方法后返回的都是一个 "promise"(promise 一旦成功或者失败就不能修改)


    then(onFulfiled, onRejected) {
        // console.log(1, this.onResolvedCallbacks)
        // console.log(1, this.onRejectedCallbacks,this.status)

        let promise2 = new Promise((resolve,reject)=>{ // 为了实现链式调用
            if (this.status === RESOLVE) {

                let x =   onFulfiled(this.value);
                resolve(x);

            }
            if (this.status === REJECT) {
                onRejected(this.reason);
            }
            if (this.status === PENDING) {

                this.onResolvedCallbacks.push(() => {
                    onFulfiled(this.value);
                })
                this.onRejectedCallbacks.push(() => {
                    onRejected(this.reason);
                })
            }
        })
        return promise2
    }
}

module.exports = Promise;

promise2状态的处理

// promise 有三个状态 pending(等待态)  resolve(成功态) reject(失败态)
let PENDING = "PENDING"; // 等待态
let RESOLVE = "RESOLVE"; // 成功态
let REJECT = "REJECT"; // 失败态
let resolvePromise = (promise2,x,resolve,reject)=>{
    console.log(promise2,x,resolve,reject);
}
// promise 是个类  创建一个promise 类
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.value = value;
                this.status = RESOLVE;
                console.log(this.onResolvedCallbacks)
                this.onResolvedCallbacks.forEach(fn => fn());
            }

        } // 不属于实例上的 是单独每个人都有的
        let reject = (reason) => {
            if (this.status === PENDING) {
                this.reason = reason;
                this.status = REJECT;
                console.log(this.onRejectedCallbacks)
                this.onRejectedCallbacks.forEach(fn => fn());
            }

        }
        // promise 发生了错误的逻辑也会 执行 失败
        try {
            executor(resolve, reject); // 这个是执行器 默认立即执行
        } catch (e) {
            console.log(e)
            reject(e);
        }
    }

    // 1.promise 的 成功或失败的回调的 返回值 可以传递到外层的 then
    // 2. 如果返回值为普通值 可以当下一个回调 then 的参数 可能有 promise 的情况(采用 promis的状态 判断下一次的 成功或者失败) 还有 error的情况 出错就一点会走下一次的失败
    // 3. 错误处理 如果 自己没有错误处理 他会向下查找
    // 4. 每次执行完promise.then 方法后返回的都是一个 "promise"(promise 一旦成功或者失败就不能修改)


    then(onFulfiled, onRejected) {
        // console.log(1, this.onResolvedCallbacks)
        // console.log(1, this.onRejectedCallbacks,this.status)

        let promise2 = new Promise((resolve,reject)=>{ // 为了实现链式调用
            if (this.status === RESOLVE) {
                setTimeout(()=>{
                    try{
                        let x =   onFulfiled(this.value);
                        resolvePromise(promise2,x,resolve,reject);
                    }catch (e) {
                        reject(e);
                    }

                },0)


            }
            if (this.status === REJECT  ) {

                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 =  onFulfiled(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
    }
}

module.exports = Promise;

**完整的promise **

// promise 有三个状态 pending(等待态)  resolve(成功态) reject(失败态)
let PENDING = "PENDING"; // 等待态
let RESOLVE = "RESOLVE"; // 成功态
let REJECT = "REJECT"; // 失败态
// resolvePromise 所有的 promise 都要遵循 bluebired q es6-romise
let resolvePromise = (promise2,x,resolve,reject)=>{
    // console.log(promise2,x,resolve,reject);
    // 循环引用
    if(promise2 === x){
        throw reject(new TypeError("TypeError: Chaining cycle detected for promise #<Promise>"))
    }
    let called = false;
    if(typeof x === 'object' && x != null || typeof x === "function"){
    //     要继续判断 有可能是 promise
       
        try {
            let then = x.then
            if(typeof then === "function"){ // 只能认为是个 promise了
                // x.then
                then.call(x,y=>{ // 根据 promise 的成功就走成功，失败就走失败
                    if(called)return;
                    called = true;
                    resolvePromise(promise2,y,resolve,reject)
                    // resolve(y)
                },e=>{
                    if(called)return;
                    called = true;
                    reject(e)
                })
            }else {

                resolve(x)
            }
        }catch (e) {
            // 防止失败了 再次成功
            if(called)return;
            called = true;
            reject(e) // 异常抛出
        }
    }else {
        resolve(x);
    }

    // 后续判断必须为严格模式  保证代码能和别的库 一起使用
}
// promise 是个类  创建一个promise 类
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.value = value;
                this.status = RESOLVE;
                console.log(this.onResolvedCallbacks)
                this.onResolvedCallbacks.forEach(fn => fn());
            }

        } // 不属于实例上的 是单独每个人都有的
        let reject = (reason) => {
            if (this.status === PENDING) {
                this.reason = reason;
                this.status = REJECT;
                console.log(this.onRejectedCallbacks)
                this.onRejectedCallbacks.forEach(fn => fn());
            }

        }
        // promise 发生了错误的逻辑也会 执行 失败
        try {
            executor(resolve, reject); // 这个是执行器 默认立即执行
        } catch (e) {
            console.log(e)
            reject(e);
        }
    }

    // 1.promise 的 成功或失败的回调的 返回值 可以传递到外层的 then
    // 2. 如果返回值为普通值 可以当下一个回调 then 的参数 可能有 promise 的情况(采用 promis的状态 判断下一次的 成功或者失败) 还有 error的情况 出错就一点会走下一次的失败
    // 3. 错误处理 如果 自己没有错误处理 他会向下查找
    // 4. 每次执行完promise.then 方法后返回的都是一个 "promise"(promise 一旦成功或者失败就不能修改)


    then(onFulfiled, onRejected) {
        // console.log(1, this.onResolvedCallbacks)
        console.log(1, this.onRejectedCallbacks,this.status)
        onFulfiled = typeof onFulfiled === "function"? onFulfiled:v=>v;
        onRejected = typeof onRejected === "function"? onRejected:err=>{throw err};
        let promise2 = new Promise((resolve,reject)=>{ // 为了实现链式调用
            if (this.status === RESOLVE) {
                setTimeout(()=>{
                    try{
                        let x =   onFulfiled(this.value);
                        resolvePromise(promise2,x,resolve,reject);
                    }catch (e) {
                        reject(e);
                    }

                },0)


            }
            if (this.status === REJECT  ) {

                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 =  onFulfiled(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
    }
}

module.exports = Promise;
张续栋
关注
专栏目录
【JS基础整理—No.07】函数柯里化
Chailo的博客
11-22 1165
柯里化的官方解释：把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数。
美团前端二面必会手写面试题汇总
helloworld1024fd的博客
10-10 819
考点： 数组去重方法汇总 1. 双层 for 循环 2. Array.filter() 加 indexOf/includes 3. ES6 中的 Set 去重 4. reduce 实现对象数组去重复 实现观察者模式 观察者需要放到被观察者中，被观察者的状态变化需要通知观察者 我变化了 内部也是基于发布订阅模式，收集观察者，状态变化后要主动通知观察者 实现一个链表结构 链表结构看图理解next层级 参考前端手写面试题详细解答第一版 时间复杂度为 O(n^2) 第二版 标记法 / 自定义属性法 时间
手写实现柯里化函数
qq_41547037的博客
12-18 491
手写实现科里化函数 只传递给函数一部分参数来调用它，让它返回一个函数去处理剩余的参数 作用：在函数式编程中，我们其实往往希望一个函数处理的问题尽可能的单一，而不是将一大堆的处理过程交给一个函数来处理 另外一个使用柯里化的场景是可以帮助我们可以复用参数逻辑 function addHandle(x, y, z) { x = x + 2 y = y * 2 z = z * z return x + y + z } // 自动柯里化函数的实现 function dyCurrying(
实现一个 柯里化函数
weixin_45192421的博客
03-24 502
实现一个 柯里化函数 首先我们来了解一下 什么叫做 柯里化函数； 函数柯里化，就是可以将一个接受多个参数的函数分解成多个接收单个参数的函数的技术，直到接收的参数满足了原来所需的数量后，才执行原函数**** 好处 代码复用 可扩展 节省代码空间 下面我们来 定义一个 柯里化函数 function curry(fn, ...args) { const self = this; // 判断当前参数是否获取完 if (args.length < fn.length) { return func
all方法 手写promise_手写发布订阅模式（手写系列二）
weixin_39754411的博客
12-08 138
背景以下是手写系列内容预告，初步计划一周一个主题。手写Promise、Promise.all、Promise.race手写发布订阅模式手写简易Redux手写简易模块加载器手写简易模块打包器手写简易React手写简易React Hooks手写简易JQuery......(根据小伙伴的提议待定)手写观察者/发布订阅模式Subject是构造函数，new Subject() 创建一个主题对象，该对象内部维...
从面试题手写bind函数分析函数柯里化
qq_40718073的博客
04-06 904
手写一个bind函数是面试中一个常见的面试题，由于bind函数是es5之后才有的，有些低版本的游览器可能不支持，有时候在开发中常常需要手写封装一个bind()函数 那怎么实现bind()函数的封装呢？ 这里就不得不提函数柯里化，那什么是函数柯里化呢？请看百度百科的解释： 在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接...
实现一个简单的柯里化函数
THINK_OF_的博客
07-11 442
//基础函数 const sum = (a, b, c) => { return [a,b,c] } ES5写法 /* *cb为调用的函数，lens为最多接受的参数长度，array为初始的参数 */ const curry = (cb, lens, array) => { array = array || [] return function name...
前端常见手写面试题（持续更新中）
helloworld1024fd的博客
10-26 453
发布订阅者模式，一种对象间一对多的依赖关系，但一个对象的状态发生改变时，所依赖它的对象都将得到状态改变的通知。
前端--基础
qq_44377537的博客
07-05 384
原文链接：https://juejin.im/post/6844903830887366670 开篇 前端开发是一个非常特殊的行业，它的历史实际上不是很长，但是知识之繁杂，技术迭代速度之快是其他技术所不能比拟的。 winter 在他的《重学前端》课程中提到： 到现在为止，前端工程师已经成为研发体系中的重要岗位之一。可是，与此相对的是，我发现极少或者几乎没有大学的计算机专业愿意开设前端课程，更没有系统性的教学方案出现。大部分前端工程师的知识，其实都是来自于实践和工作中零散的学习。 这样是一个非常真实的现状，实
2022前端秋招面试题总结 阿里 腾讯 字节 百度 网易 京东 小红书 快手面试记录
最新发布
m0_46424423的博客
12-08 1650
等了百度三个月，终于发offer了，白菜价，92大佬们拒的薪资，我知足了。排序挂了狠多，快手，蚂蚁，… 很绝望我的新博客：https://jzq422bol5.feishu.cn/wiki/个人分享：https://jzq422bol5.feishu.cn/wiki/wikcnuSye5AxZ1IwRyRedlKxaAhGithub：https://github.com/Sunny-117自我介绍手写：实现n阶乘手写：相邻数组的最大哪个，不能排序手写：tree 可以看这里https://www.nowcod
函数柯里化的案例 compose 函数
_
01-09 406
compose 将 加法函数 和 乘法函数组合成一个新函数 const add = (num) => num + 10; const multiplay = (num) => num * 2; let compose = function() { let fns = Array.prototype.slice.call(arguments); return function(num) { for (var i = fns.length - 1; i &g
promise - 3.发布订阅和观察者模式
qq_35432512的博客
06-30 654
1. 发布订阅 大白话解释 订阅好一件事，当这件事发生的时候，触发对应的函数 订阅： on 发布：emit promise 内部也是基于发布订阅的 好处 多个类之间可以解耦合 特点 订阅方和发布方没有任何的关系 实现 let fs = require('fs') let e = { _obj: {}, _callback: [], on(callBack) { // 订阅就是将函数放到数组中 this._callback.push(cal
手写promise（一）
weixin_43956427的博客
03-02 156
Promise为JS的异步编程提供了一种解决方法 JS异步编程的方式还有： 1.发布订阅模式 2.回调函数 3.事件监听 先看下回调函数怎么实现异步编程 回调函数：函数当作参数进行传递， 当满足一定条件时，这个函数被执行 回调函数并不会马上被执行。它会在包含它的函数内的某个特定时间点被“回调”（就像它的名字一样） 模拟请求数据，当拿到数据后，打印出来 这里的回调就是打印 function showData(data) { console.log(data) } function getData(cb) {
typescript中的curry(柯里化)学习笔记
小吴同学的博客
10-18 1636
ts中的curry :柯里化，实际上就是把接收多个参数的函数变换成接收一个单一参数（最初函数的第一个参数）的函数，如果其他的参数是必要的，返回接收余下的参数且返回结果。 第一个例子：实现加法的柯里化 /* 前端使用柯里化的用途主要是简化代码结构，提高系统的维护性，一个 方法，只有一个参数，强调了功能的单一性，很自然就做到了功能内聚， 降低耦合 优点：降低代码的重复，提高代码的适应性 */ var Add = (x:number, y:number) => { return x+y; }
使用 TS 和 class 实现一个简易 Promise
weixin_45177667的博客
06-02 620
前言 最近在看书学习的过程中，发现自己对 Promise 以及宏任务、微任务之间的关系还掌握得不够熟练，于是决定学习百家之长，自己动手实现一个 Promise，当然，就算如今这种行为已经烂了大街，我也想特立独行一些，于是就用上了 typescript 和 class。 基本接口 首要的就是 Promise 独一无二的三个状态 type StatusType = 'pending' | 'fulfilled' | 'rejected'; 然后是声明时需要传入的函数 executor interface On
JS函数式编程思维：柯里化、闭包
htong521的博客
11-06 937
偏函数（Partial Application）： 探讨柯里化之前，我们先聊一聊很容易跟其混淆的另一个概念——偏函数（Partial Application）。在维基百科中，对 Partial Application 的定义是这样的： In computer science, partial application (or partial function application) refe...
Promise学习笔记（尚硅谷）
Ch_ensf的博客
05-16 1333
一、Promise 的理解和使用 二、手写 Promise
有关prototype的理解
helloschurmi的博客
10-26 1051
prototype（指针）是指向通过构造函数创建某个实例的原型对象，原型对象的特点就是：所有对象实例都可以共享它包含的属性和方法。但是其实prototype是每个构造函数的属性而已，只能说万物皆对象罢了。 所以创建一个函数就会，为该函数创建一个protopyte属性，这个属性指向函数的原型对象。默认情况下，所有的原型对象会获得一个constructor属性，这个属性是一个指向pr...
Promise.allSettled方法
qq_44675204的博客
08-10 1524
Promise.allSettled方法是ES2020新增的特性，可以执行多个Promise对象，获取多个Promise状态。相比于Promise的all方法，可以获取成功或失败的所有状态，因为Promise的all方法遇到一个rejected就会立即停止。 let p1 = new Promise((res) => { setTimeout(()=>{ res('P1'); }, 1000) }) let p2 = new Promise((res,rej) =
JavaScript函数柯里化详解：原理与实现
柯里化的实现方式是定义一个内部函数`y`，它接受当前未使用的参数，并递归地调用`sum`函数，直到累积所有的参数。同时，`y`的`toString`和`valueOf`方法被重写，使得当函数被直接转换为字符串或值时，会返回当前已...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值