四月八日

/**
 * Optimized internal one-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */

export default function _curry1(fn) {
  return function f1(a) {
    if (arguments.length === 0 || _isPlaceholder(a)) {
      return f1;
    } else {
      return fn.apply(this, arguments);
    }
  };
}

const _curry2 = function (fn) {
  return function f2(a, b) {
    return a !== undefined && b !== undefined
      ? _isPlaceholder(a) && _isPlaceholder(b)
        ? f2
        : isPlaceholder(a)
          ? _curry1(function (_a) { return fn(_a, b) })
          : _isPlaceholder(b)
            ? _curry1(function (_b) { return fn(a, _b) })
            : fn.apply(this, arguments)
      : a !== undefined
        ? _curry1(function (_b) { return fn(a, _b) })
        : f2
  }
}

/**
 * Optimized internal two-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
export default function _curry2(fn) {
  return function f2(a, b) {
    switch (arguments.length) {
      case 0:
        return f2;
      case 1:
        // 如果a传入的是undefined也是一个参数
        return _isPlaceholder(a)
          ? f2
          : _curry1(function(_b) { return fn(a, _b); });
      default:
        return _isPlaceholder(a) && _isPlaceholder(b)
          ? f2
          : _isPlaceholder(a)
            ? _curry1(function(_a) { return fn(_a, b); })
            : _isPlaceholder(b)
              ? _curry1(function(_b) { return fn(a, _b); })
              : fn(a, b);
    }
  };
}

/**
 * Optimized internal three-arity curry function.
 *
 * @private
 * @category Function
 * @param {Function} fn The function to curry.
 * @return {Function} The curried function.
 */
export default function _curry3(fn) {
  return function f3(a, b, c) {
    switch (arguments.length) {
      case 0:
        return f3;
      case 1:
        return _isPlaceholder(a)
          ? f3
          : _curry2(function(_b, _c) { return fn(a, _b, _c); });
      case 2:
        return _isPlaceholder(a) && _isPlaceholder(b)
          ? f3
          : _isPlaceholder(a)
            ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
            : _isPlaceholder(b)
              ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
              : _curry1(function(_c) { return fn(a, b, _c); });
      default:
        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c)
          ? f3
          // 其中两个是占位符的情况
          : _isPlaceholder(a) && _isPlaceholder(b)
            ? _curry2(function(_a, _b) { return fn(_a, _b, c); })
            : _isPlaceholder(a) && _isPlaceholder(c)
              ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
              : _isPlaceholder(b) && _isPlaceholder(c)
                ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
                // 其中一个是占位符的情况
                : _isPlaceholder(a)
                  ? _curry1(function(_a) { return fn(_a, b, c); })
                  : _isPlaceholder(b)
                    ? _curry1(function(_b) { return fn(a, _b, c); })
                    : _isPlaceholder(c)
                      ? _curry1(function(_c) { return fn(a, b, _c); })
                      : fn(a, b, c);
    }
  };
}

var curry = _curry1(function curry(fn) {
  return curryN(fn.length, fn);
});

export default function _arity(n, fn) {
  /* eslint-disable no-unused-vars */
  switch (n) {
    case 0: return function() { return fn.apply(this, arguments); };
    case 1: return function(a0) { return fn.apply(this, arguments); };
    case 2: return function(a0, a1) { return fn.apply(this, arguments); };
    // ...
    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };
    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
  }
}

var curryN = _curry2(function curryN(length, fn) {
  if (length === 1) {
    return _curry1(fn);
  }
  return _arity(length, _curryN(length, [], fn));
});

function curryN(length, fn) {
  return _curry2(function (length, fn) {
    return length === 1
      ? _curry1(fn)
      : length === 2
        ? _curry2(fn)
        : length === 3
          ? _curry3(fn)
          : _arity(length, _curryN(length, [], fn))
  })
}

// 1. 真实参数个数和length项等 则执行函数
// 2. 实时记录占位符的位置， 新参数优先放到占位符
function _curryN(length, receive, fn) {
  return function fN() {
    var index = 0;
    var zw = 0;
    function findzw(zw, receive) {
      while (zw < receive.length) {
        if (_isPlaceholder(receive[zw])) {
          //指向占位符的前一位， 方便后面处理
          return zw - 1
        }
        zw++
      }
      return zw - 1
    }
    // 找到占位符的位置
    zw = findzw(zw, receive);
    while (index < arguments.length) {
      receive[zw + 1] = arguments[index];
      //更新之后重新查找占位符, 条过当前的占位符
      zw = findzw(zw + 1, receive);
      index++;
    }
    // 没有占位符 则位置+1为参数长度
    if (zw + 1 === length) {
      return fn.apply(this, receive)
    } else {
      // 计算剩余参数
      var j = 0;
      var len = 0
      while (j < receive.length) {
        if (!_isPlaceholder(receive[index])) {
          len++;
        }
        j++
      }
      return _arity(length - len, _curryN(length, receive, fn))
    }
  }
}

function _curryN(length, receive, fn) {
  return function () {
    // 复制已接受参数的数组
    var combined = [];
    // 遍历入参的索引
    var argsIdx = 0;
    // 剩余参数
    var left = length;
    // 遍历已接受参数索引
    var combinedIdx = 0;

    // 如果参数没有复制完成，或新如参没有添加完成则继续执行
    while (combinedIdx < received.length || argsIdx < arguments.length) {
      var result;
      // 通过条件语句处理了占位符的问题
      // 如果老参数没有复制完成，且复制的值不是占位符，或者入参已经都处理了，直接取出当前的老参数，用于复制到新的数组中
      // 通过双指针解决占位符的问题
      if (combinedIdx < received.length &&
        (!_isPlaceholder(received[combinedIdx]) ||
          argsIdx >= arguments.length)) {
        result = received[combinedIdx];
      } else {
        // 如果老参数都复制完，或者时占位符，或者还有新参数没有复制
        // 取一个新参数加到数组中
        result = arguments[argsIdx];
        argsIdx += 1;
      }
      // 添加到新数组中
      combined[combinedIdx] = result;
      // 如果不是占位符剩余参数 -1
      if (!_isPlaceholder(result)) {
        left -= 1;
      }
      combinedIdx += 1;
    }
    // 如果没有剩余参数直接执行
    return left <= 0
      ? fn.apply(this, combined)
      // 否则通过_arity固定新函数的参数个数
      : _arity(left, _curryN(length, combined, fn));
  };
}

let a:number;

const n:number | null | undefined;

n = 1;

let a = 1;

// 如果重新覆盖不同的类型值会提示错误
a = '22'// 错误

let a:1|true;
a = 1;

// 指定数组中的类型
let arr:number[] = [1,2,3]

let arr:Array<number> = [1,2,3]

let arr:any[] = [1,2,3]

let b:{
  name:string,
  age?:number,
  [propName:string]:any
}

let arr:[string，number] = ['123',3.4]

function  fn(...args:any[]) {
  const arg:IArguments = arguments;
}

fn(1,2,3)

enum StatusEnum {
  success = 0,
  error = -1
}

const a: StatusEnum = StatusEnum.success

enum Color { red, gray = 5, black}

const c:Color = Color.red //0
const c1:Color = Color.gray //5
const c2:Color = Color.black //6

const enum Color { red, gray}
console.log(Color.red,Color.gray);

//最终编译为
console.log(0/*Color.red*/,1/*Color.red*/)

const a:any = document.getElementById('app')
a.style.innerHTML = '<div />'

const ele:HTMLElement|null = document.getElementById('app')
ele!.style.color = '<div />'

function fun:void(){
  cosnole.log(1)
}

const fun = (): void => {
  console.log(1)
}

const a: never = (() => { throw new Error })()

function fn(): never {
  throw new Error();
}

function fn(): never {
  while(true){}
  // 需要never类型，永远不会到达的语句
  cosnole.log(1)
}

const d:any = '123'
const s:string = d;// 不会报错

const d:unknow = '123'
const s:string = d;// 回报错

if(typeof d === 'string'){
  s = d
}

s = d as string;

let a: "aaa" | "bbb";
a = "aaa";

type MyType = 1|2|3
const a:MyType = 1;
const a:MyType = 2;
const a:MyType = 3;

function fn(a: number = 2, b?: number, ...c: Array<any>): void {
  if (b) {
    console.log(a, b, c);
  } else {
    console.log(a, b, c);
  }
}

fn(1)

function fn(a: number): number;
function fn(b: string): string;
function fn(c: any): any {
  if (typeof c === 'number') {
    return c + 1;
  }
};

const fn:(a:number,b:number) => number

class C {
  constructor(n: string) { 
    this.name = n;// 构造函数，为定义的属性赋值
  }
  name: string; // 定义属性 省略前面的public关键字

  readonly age:number =  18 // 只读属性

  static readonly age: number = 1;

  run():void{ // 定义方法
    console.log('void')
  }

}

interface MyObj {
  prop1: string,
  prop2: number
}
interface MyObj {
  prop3: Boolean
}

const obj: MyObj = {
  prop1: '1',
  prop2: 2,
  prop3: true,
}

interface PersonInterface {
  // 只读属性
  readyonly name: string,
  age: number,
  say(method: string): boolean
}

class JiaZhen implements PersonInterface {
  name: string = '1';
  age: number = 1;
  say(method: string): boolean {
    return true;
  }
}

interface PersonInterface{
  name:string,
  new(name:string):Person
}

class Person{
  constructor(name:string) {
  }
}

function  createPerson(Clsss:PersonInterface,name:string) {
    return new Clsss(name);
}

createPerson(Person,'aaa');

class Person {
  constructor(pubilc name:string){
    // 表示添加到实例上。可以通过属性访问
  }
}
new Person().name

function jiazhen<Z>(age: Z): Z {
  return age;
}

jiazhen(19);

jiazhen<Number>(19) // 主动指明泛型

interface Zhen {
  age: number,
  love(who: string): boolean
}

function jiazhen<Z extends Zhen>(obj: Z): any {
  return obj.love;
}

jiazhen<Zhen>({
  age: 1,
  love(a) {
    return true;
  }
})

class A<T>{
  name: T;
  constructor(a: T) {
    this.name = a
  }
}

new A<string>('10')

function enhancer(target:any){
  target.prototype.name = '11';
}

interface Person{
  name:string
}

@enhancer
class Person {
  constructor(){

  }
}

const p = new Person();
p.name;

// 如果装饰的是普通的属性，target指向类的原型
// 如果是static属性，target指向类的定义
function upperCase(target:any,propname:string) {
  let v = target[propname];
  const getter = ()=>v;
  const setter = (newValue:string)=>{
    v =  newValue.toUpperCase();
  }
  delete target[propname];
  Object.defineProperty(target,propname,{
    set:setter,
    get:getter,
    enumerable:true,
    configurable:true
  })
}

interface Person{
  name:string
}

class Person {
  @upperCase
  name = 'girl'
  constructor(){
    
  }
}

const p = new Person();
console.log(p.name);

function unEnumber(enumConfig:boolean) {
  //                                                       属性描述器
  return function unEnumber(target:any,propname:string,propertyDescriptor:PropertyDescriptor) {
    propertyDescriptor.enumerable  = enumConfig;
  }
}

interface Person{
  name:string
}

class Person {
  name = 'girl'
  constructor(){}
  
  // getname 不能枚举
  @unEnumber(false)
  getName(){}
}

const p = new Person();
console.log(p.name);

for(let key in p){
  console.log(key)
}

function trans(target:any,propname:string,propertyDescriptor:PropertyDescriptor) {
  const oldValue = propertyDescriptor.value;
  console.log("1------------")
  propertyDescriptor.value = function getNumber(...args:any[]) {
    args = args.map(item=>Number(item));
    console.log("2------------")
    return oldValue.apply(this,args);
  }
}

interface Person{
  name:string
}

class Person {
  name = 'girl'
  constructor(){}

  @trans
  getNumber(...args:any[]){
    console.log("3------------")
    return args.reduce((sum,item)=>{ sum+=item; return sum },0);
  }

}

const p = new Person();

console.log(p.getNumber('1',2,'3'));

//              类的原型    方法名             被修饰参数的索引
function dubble(target:any,methodName:string,index:number) {
  target.num = 'num'
}

class Person {
  getNumber(@dubble num:number){
    console.log(num);
    console.log(this.num);
  }
}

const p = new Person();

p.getNumber(2);

abstract class Person {
  abstract say(): void
}

class Lisa extends Person {
  say() { }
}

class Person {
  say(){}
}

class Boy extends Person{
  say(){}
}

// 函数重载表示同名的函数如果参数不同函数会重载

// 但是JS中没有重载的概念，下面同名的函数会覆盖上面的函数

// TS中模拟函数重载, 通过不同的参数类型校验

function fn(a: number): number;
function fn(b: string): string;
function fn(c: any): any {
  if (typeof c === 'number') {
    return c + 1;
  }
};

co(function* () {
  return yield Promise.resolve(true);
}).then(function (val) {
  console.log(val);
}, function (err) {
  console.error(err.stack);
});

var fn = co.wrap(function* (val) {
  return yield Promise.resolve(val);
});
 
fn(true).then(function (val) {
 
});

// sllice 引用
var slice = Array.prototype.slice;

// isObject
function isObject(val) {
  return Object == val.constructor;
}

//导出方法
module.exports = co['default'] = co.co = co;

//判断是否是promise对象，只要是实现了thenable的对象都可以视为promise对象
function isPromise(obj) {
  return 'function' == typeof obj.then;
}

function isGenerator(obj) {
  return 'function' == typeof obj.next && 'function' == typeof obj.throw;
}

// 是否是generator函数
function isGeneratorFunction(obj) {
  // 一定是GeneratorFunction构造函数的实例
  // (function(){}).constructor === Function => true
  var constructor = obj.constructor;
  if (!constructor) return false;
  if ('GeneratorFunction' === constructor.name || 'GeneratorF方法
function thunkToPromise(fn) {
  var ctx = this;
  return new Promise(function (resolve, reject) {
    fn.call(ctx, function (err, res) {
      if (err) return reject(err);
      if (arguments.length > 2) res = slice.call(arguments, 1);
      resolve(res);
    });
  });
}

// arrayToPromise yeildable数组转换为promise
function arrayToPromise(obj) {
  // 每一项都转换为promise
  // 第二个参数为toPromise执行时的this值
  return Promise.all(obj.map(toPromise, this));
}

// objectToPromise yieldables对象转为promise
function objectToPromise(obj){
  // 借用 function Object(){}
  var results = new obj.constructor();
  var keys = Object.keys(obj);
  var promises = [];
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    // 每一项转为promise
    var promise = toPromise.call(this, obj[key]);
    if (promise && isPromise(promise)) defer(promise, key);
    // 其他情况直接返回key值
    else results[key] = obj[key];
  }
  return Promise.all(promises).then(function () {
    return results;
  });

  function defer(promise, key) {
    // 提前在results中定义key
    results[key] = undefined;
    promises.push(promise.then(function (res) {
      // 提前一步拿到结果
      // 通常自己的写法为这里直接返回promise
      // 在promise.all 中在遍历结果生成result,这样写法更简洁一点
      results[key] = res;
    }));
  }
}

//把yeild转为Promise对象
function toPromise(obj) {
  // 如果为假直接返回
  if (!obj) return obj;
  //如果已经是promise直接返回
  if (isPromise(obj)) return obj;
  // 如果是generator函数 通过co函数栈为promise
  if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
  // this通过next方法中toPromise.call(ctx, ret.value)来绑定
  if ('function' == typeof obj) return thunkToPromise.call(this, obj);
  if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
  if (isObject(obj)) return objectToPromise.call(this, obj);
  return obj;
}

function co(gen) {
  var ctx = this;
  var args = slice.call(arguments, 1)

  // 把任何东西包装成promise, 从而避免promise调用链

  // 内存泄漏的问题
  // https://github.com/tj/co/issues/180
  return new Promise(function(resolve, reject) {
    
    // 执行Generator函数，返回Generator
    if (typeof gen === 'function') gen = gen.apply(ctx, args);

    // 如果没有next方法，则直接返回
    if (!gen || typeof gen.next !== 'function') return resolve(gen);


    onFulfilled();

    /**
     * @param {Mixed} res
     * @return {Promise}
     * @api private
     * 通过 try catch 捕获执行时错误
     */

    function onFulfilled(res) {
      var ret;
      try {
        ret = gen.next(res);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    /**
     * @param {Error} err
     * @return {Promise}
     * @api private
     */

    function onRejected(err) {
      var ret;
      try {
        ret = gen.throw(err);
      } catch (e) {
        return reject(e);
      }
      next(ret);
    }

    /**
     * Get the next value in the generator,
     * return a promise.
     *
     * @param {Object} ret
     * @return {Promise}
     * @api private
     */

    
    function next(ret) {
      if (ret.done) return resolve(ret.value);
      var value = toPromise.call(ctx, ret.value);
      // 如果可以包装成promise, 通过thenable方法继续调用onFulfilled，执行下一个next, 并把promise的值传入，当作上一个next的结果
      if (value && isPromise(value)) return value.then(onFulfilled, onRejected);
      // 抛出错误
      return onRejected(new TypeError('You may only yield a function, promise, generator, array, or object, '
        + 'but the following object was passed: "' + String(ret.value) + '"'));
    }
  });
}

// 通过柯理化函数，返回一个包含co执行结果的正常函数

co.wrap = function (fn) {
  createPromise.__generatorFunction__ = fn;
  return createPromise;
  function createPromise() {
    return co.call(this, fn.apply(this, arguments));
  }
};

const koa = require('koa');

const app = new koa();

const m1 = async (ctx, next) => {
  console.log(1);
  await next();
  console.log(2);
}

const m2 = async (ctx, next) => {
  console.log(3);
  await next();
  console.log(4);
}
const m3 = async (ctx, next) => {
  console.log(5);
  await next();
  console.log(6);
}

app
  .use(m1)
  .use(m2)
  .use(m3)

app.listen(3000)

const koa = require('koa');
const Router = require('koa-router')

const app = new koa();
const router = new Router();

const m1 = async (ctx, next) => {
  // 应用级中间件最先被访问
  console.log('应用级中间件');
  //通过next进入路由级中间件
  await next();
  if (ctx.status == 404) {
    ctx.body = '404'
  }
}
// 路由级中间件会按照顺序访问
router.get('/', async (ctx, next) => {
  console.log('路由级中间件1');
  await next()
})

router.get('/', async (ctx, next) => {
  console.log('路由级中间件2');
  ctx.body = '路由'
})

app.use(router.routes());

app
  .use(m1)

app.listen(3000)

npm i --save-dev html-webpack-plugin@next //webpack5

plugins: [
  new HtmlWebpackPlugin({
    template:'**.html'
  })
]

yarn add -D sass-node less-loader css-loader style-loader

{
  module: {
    rules: [
      {
        test: /\.scss$/,
        use: [
          'style-loader',
          {
              loader: 'css-loader',
              options: {
                  minimize: false, //压缩css代码, 默认false
                  import: true, //禁止或启用@import, 默认true
                  url: true, //控制url/image-set的解析，会处理成require引入
              }
          }
        , 'sass-loader']
      }
    ]
  },
}

yarn add -D url-loader file-laoder

// 小图片以bash64的方式输出
// 可以处理通过import引入的样式中的图片，js文件中引入的图片文件
// 如果图片大于指定大小会默认交给file-loader处理
// file-loader 会使用options中的配置
{
  test: /\.(png|jpe?g|gif)$/i,
  use: [
    {
      loader: 'url-loader',
      options: {
        limit: 5 * 1024,
        outputPath: 'assets',
        name: '[hash:8].[ext]',
      }
    }
  ]
},
// 处理html中的图片
// 把html字符串中的图片引变成require的形式，
// 最终还是需要使用file-loader 和 url-loader来处理
// 如果生成的src是[object Module]需要关闭，url-loader的模块化规范
{
  test: /\.html$/i,
  use: [{
    loader: 'html-loader',
  }]
},

{
  // exclude:/\.xx$/
  test: /\.(ttf|eot|svg|woff|woff2)$/,
  loader:'file-loader',
  options:{
    name:'[path][name].[ext]'
  }
  
}

yarn add -D webpack-dev-server

devServer:{
  compress: true,
  contentBase: path.join(__dirname, 'dist'),
  open:true
}

const webpackDevServer = require('webpack-dev-server');
const webpack = require('webpack');


const config = require('./webpack.config.js');

const options = {
  contentBase: './dist',
  publicPath: '/',
  hot: true,
  writeToDisk: true,
  open: true
};

webpackDevServer.addDevServerEntrypoints(config, options);
const compiler = webpack(config);
const server = new webpackDevServer(compiler, options);

server.listen(9000, 'localhost', () => {
  console.log('dev server listening on port 9000');
});

var NotifierPlugin = require('friendly-errors-webpack-plugin');
var notifier = require('node-notifier');
var ICON = path.join(__dirname, 'icon.png');
 
new NotifierPlugin({
    onErrors: (severity, errors) => {
      if (severity !== 'error') {
        return;
      }
      const error = errors[0];
      notifier.notify({
        title: "Webpack error",
        message: severity + ': ' + error.name,
        subtitle: error.file || '',
        icon: ICON
      });
    }
  })
]

const fs = require("fs");
const path = require("path");
const vm = require("vm");

const handlerMap = {};
const hotsPath = path.join(__dirname, "hots");

// 加载文件代码 并 监听指定文件夹目录文件内容变动
const loadHandlers = async () => {
  // 遍历出指定文件夹下的所有文件
  const files = await new Promise((resolve, reject) => {
    //https://nodejs.org/dist/latest-v14.x/docs/api/fs.html#fs_fs_readdir_path_options_callback
    //异步读取指定目录下的文件和文件夹，返回一个数组
    fs.readdir(hotsPath, (err, files) => {
      if (err) {
        reject(err);
      } else {
        resolve(files);
      }
    });
  });
  // 初始化加载所有文件 把每个文件结果缓存到handlerMap变量当中
  for (let f in files) {
    handlerMap[files[f]] = await loadHandler(path.join(hotsPath, files[f]));
  }

  // 监听指定文件夹的文件内容变动
  await watchHandlers();
};

// 监视指定文件夹下的文件变动
const watchHandlers = async () => {
  // 这里建议用chokidar的npm包代替文件夹监听 
  // 监听所有子文件夹
  fs.watch(hotsPath, { recursive: true }, async (eventType, filename) => {
    // 获取到每个文件的绝对路径 
    // 包一层require.resolve的原因，拼接好路径以后，它会主动去帮你判断这个路径下的文件是否存在
    //使用require.resolve函数查询模块文件名时并不会加载该模块。
    const targetFile = require.resolve(path.join(hotsPath, filename));
    // 使用require加载一个模块后，模块的数据就会缓存到require.cache中，下次再加载相同模块，就会直接走require.cache
    // 所以我们热加载部署，首要做的就是清除require.cache中对应文件的缓存
    const cacheModule = require.cache[targetFile];
    // 去除掉在require.cache缓存中parent对当前模块的引用，否则会引起内存泄露，具体解释可以看下面的文章
	// 《记录一次由一行代码引发的“血案”》https://cnodejs.org/topic/5aaba2dc19b2e3db18959e63
	// 《一行 delete require.cache 引发的内存泄漏血案》https://zhuanlan.zhihu.com/p/34702356
    if (cacheModule.parent) {    
        cacheModule.parent.children.splice(cacheModule.parent.children.indexOf(cacheModule), 1);
    }
    // 清除指定路径对应模块的require.cache缓存
    require.cache[targetFile] = null;

    // 重新加载发生变动后的模块文件，实现热加载部署效果，并将重新加载后的结果，更新到handlerMap变量当中
    const code = await loadHandler(targetFile)
    handlerMap[filename] = code;
    console.log("热部署文件：", filename, "，执行结果：", handlerMap);
  });
};

// 加载指定文件的代码
const loadHandler = filename => {
  return new Promise((resolve, reject) => {
    //https://nodejs.org/dist/latest-v14.x/docs/api/fs.html#fs_fs_readfile_path_options_callback
    //读取文件中的内容 默认返回buffer
    //当目录为文件夹时抛出错误
    fs.readFile(filename, (err, data) => {
      if (err) {
        resolve(null);
      } else {
        try {
          // 使用vm模块的Script方法来预编译发生变化后的文件代码，检查语法错误，提前发现是否存在语法错误等报错
          new vm.Script(data);
        } catch (e) {
          // 语法错误,编译失败
          reject(e);
          return;
        }
        // 编译通过后，重新require加载最新的代码
        resolve(require(filename));
      }
    });
  });
};

loadHandlers()