Structure-study-callback

Before和After函数

函数的原型上扩展

    // before函数
    Function.prototype.before = function(beforeFn){
        return (...args)=>{
            beforeFn();
            this(...args)
        }
    }
    // after函数
    Function.prototype.after = function(afterFn){
        return (...args)=>{
            this(...args)
            afterFn()
        }
    }

    const say = (...args)=>{
        console.log('说话',args)
    }
    const newSay = say.before(()=>{
        console.log('你好')
    })

事务

开始的时候 做某件事 结束的时候在做某件事

    // 事务
    const perform = (method,wrappers) => {
        wrappers.forEach(wrap=>{
            wrap.initialize()
        })
        method()
        wrappers.forEach(wrap=>{
            wrap.close()
        })
    }

    perform(()=>{
        console.log('说话')
    },[
        {
           initialize(){
               console.log('初始化1')
           },
           close(){
                console.log('结束1')
           }
        },
        {
           initialize(){
               console.log('初始化2')
           },
           close(){
                console.log('结束2')
           }
        }
    ])

函数柯里化

将一个函数拆分成多个函数

判断数据类型

    const checkType = type => {
        return content => {
            Object.prototype.toString.call(content) === `[object ${type}]`
        }
    }

    let types = ["Number","String","Boolean"]
    let utils = {}
    types.forEach(type=>{
        utils["is"+type] = checkType(type)
    })
    console.log(utils.isString("123"))

函数的柯里化

    let curring = (fn,arr=[]) => {
        // 函数的参数个数
        let len = fn.length;
        return (...args) => {
            arr = arr.concat(args)
            if(arr.length < len){
                return curring(fn,arr)
            }
            return fn(...arr)
        }
    }

    const add = (a, b, c, d, e) => {
        return a + b + c + d + e;
    };
    // 柯里化后的函数

    let r = curring(add)(1)(2)(3)(4)

after 函数

    const after = (times,fn) => {
        return () => {
            if(--times===0){
                fn()
            }
        }
    }
    // after函数解决 并发的异步获取数据

    const fs = require('fs')
    let school = {}

    let newAfter = after(2,()=>{
        console.log(school)
    })

    fs.readFile('name.txt','utf8',(err,data)=>{
        school['name'] = data;
        newAfter()
    })
    fs.readFile('age.txt','utf8',(err,data)=>{
        school['age'] = data;
        newAfter()
    })

发布订阅

    let fs = require('fs')
    let school = {}

    let e = {
        arr:[],
        on(fn){
            this.arr.push(fn)
        },
        emit(){
            this.add.forEach(fn=>fn())
        }
    }

    e.on(()=>{
        if(Object.keys(school).length === 2){
            console.log(school)
        }
    })
    fs.readFile('name.txt','utf8',(err,data)=>{
        school['name'] = data;
        e.emit(); // 发布
    }); 
    fs.readFile('age.txt','utf8',(err,data)=>{
        school['age'] = data;
        e.emit();
    });

观察者

观察者模式包含发布订阅

    class Subject {
        constructor(){
            this.arr = [];
            this.state = '很开心'
        }

        attach(o){
            this.arr.push(o)
        }
        setState(newState){
            this.state = newState
            this.arr.forEach(o=>o.update(newState))
        }
    }

    class Observer{
        constructor(name){
            this.name = name
        }

        update(newState){
            console.log(this.name + '小宝宝:'+newState)
        }
        
    }
    let s = new Subject('小宝宝'); 
    let o1 = new Observer('我');
    let o2 = new Observer('我媳妇')

    s.attach(o1);
    s.attach(o2);
    s.setState('不开心了');