05-如何提升代码可扩展性

const translations = {
  en: {
    greeting: 'Hello',
    message: 'Welcome to our website!'
  },
  fr: {
    greeting: 'Bonjour',
    message: 'Bienvenue sur notre site web !'
  },
  // other language translations...
};

export default translations;

const formValidate = new FormValidate();
formValidate.validate('mobile', '111111'); //false
formValidate.validate('mobile', '13156678909'); //true
formValidate.validate('email', 'aaa'); //false
formValidate.validate('email', 'test@qq.com'); //true

class FormValidate {
    validate(type, value){
        if(type === 'mobile'){
            return /^1[3-9]\d{9}$/.test(value)
        }else if(type === 'email'){
            return /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/.test(value)
        }else {
            return false;
        }
    }
}

class FormValidate {
    validate(type, value){
        if(type === 'username'){
            if(!value) {
                return false;
            }else if(value.length <=30){
                return true;
            } else{
                return false;
            }
        }
        //其他逻辑
    }
}

class FormValidate {
    validateMethods = {};
    validate(type, value){
        if(this.validateMethods[type]){
            return this.validateMethods[type](value);
        }
        return false;
    }
    addValidateMethod(type, validateMethods){
        this.validateMethods[type] = validateMethods;
    }
}

const formValidate = new FormValidate();

formValidate.addValidateMethod('mobile', (value) => /^1[3-9]\d{9}$/.test(value));

formValidate.addValidateMethod('email', (value) => /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/.test(value));

formValidate.addValidateMethod('username', (value) => {
    if(!value) {
        return false;
    }else if(value.length <=30){
        return true;
    } else{
        return false;
    }
});

formValidate.validate('mobile', '111111'); //false
formValidate.validate('mobile', '13156678909'); //true
formValidate.validate('email', 'aaa'); //false
formValidate.validate('email', 'test@qq.com'); //true

// 添加请求拦截器
axios.interceptors.request.use(function (config) {
    // 在发送请求之前做些什么
    return config;
  }, function (error) {
    // 对请求错误做些什么
    return Promise.reject(error);
  });

// 添加响应拦截器
axios.interceptors.response.use(function (response) {
    // 2xx 范围内的状态码都会触发该函数。
    // 对响应数据做点什么
    return response;
  }, function (error) {
    // 超出 2xx 范围的状态码都会触发该函数。
    // 对响应错误做点什么
    return Promise.reject(error);
  });

class Axios {
    constructor(instanceConfig) {
        this.interceptors = {
            request: new InterceptorManager(),
            response: new InterceptorManager()
        };
    }
}

class InterceptorManager {
    constructor() {
        this.handlers = [];
    }
    use(fulfilled, rejected, options) {
        this.handlers.push({
            fulfilled,
            rejected,
            synchronous: options ? options.synchronous : false,
            runWhen: options ? options.runWhen : null
        });
        return this.handlers.length - 1;
    }
}

class Axios {
    request(configOrUrl, config) {
       
        // 去除了其他处理逻辑
        
        const requestInterceptorChain = [];
        //遍历请求拦截器
        this.interceptors.request.forEach((interceptor) => {
            //使用了unshift，所以请求拦截器的执行顺序是后添加先执行
            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
        });

        
        const responseInterceptorChain = [];
        //遍历响应拦截器
        this.interceptors.response.forEach( (interceptor) => {
            responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
        });

        //创建一个执行链条，将请求任务加入链条
        const chain = [dispatchRequest.bind(this), undefined];
        
        //将请求拦截器中的任务加入链条之前
        chain.unshift.apply(chain, requestInterceptorChain);
        //将响应拦截器的任务加入链条之后
        chain.push.apply(chain, responseInterceptorChain);
        
        len = chain.length;
        promise = Promise.resolve(config);
        
        //将链条中的任务通过Promise的方式串到一串
        while (i < len) {
            promise = promise.then(chain[i++], chain[i++]);
        }

        return promise;
    }
}

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

const cors = require("koa2-cors");
app.use(cors());

const serve = require('koa-static')
app.use(serve(__dirname + '/public/'));

class Koa {
    constructor (options) {
        this.middleware = []
    }

    use (fn) {
        if (typeof fn !== 'function') throw new TypeError('middleware must be a function!')
      
        this.middleware.push(fn)
        return this
    }
}

const compose = require('koa-compose')
class Koa {
    //请求回调函数
    callback () {
        //通过compose方法将数组中的中间件转成串行执行的函数
        const fn = compose(this.middleware)

        const handleRequest = (req, res) => {
            const ctx = this.createContext(req, res)
            return this.handleRequest(ctx, fn)
        }

        return handleRequest
    }
    handleRequest (ctx, fnMiddleware) {
        const res = ctx.res
        res.statusCode = 404
        const onerror = err => ctx.onerror(err)
        const handleResponse = () => respond(ctx)
        onFinished(res, onerror)
        
        //调用中间件
        return fnMiddleware(ctx).then(handleResponse).catch(onerror)
    }
}

function compose (middleware) {
  if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
  for (const fn of middleware) {
    if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
  }

 
  return function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}

//实现一个loader，将import的文件中的foo替换为bar
module.exports = function(source) {
    const result = source.replace(/foo/g, 'bar');

    return result
};

class MyPlugin {
  constructor(options) {
    this.options = options;
  }

  apply(compiler) {
    compiler.hooks.emit.tapAsync('MyPlugin', (compilation, callback) => {
      console.log('MyPlugin is running...');
      // 在这里执行自定义的逻辑
      callback();
    });
  }
}

module.exports = MyPlugin;

class MyPlugin {
  apply(compiler) {
  }
}