请实现一个简单的事件机制，能够实现对事件的触发和监听。

function EventEmit() {
    var obj = {}
    var eventNames = []
    var pid = 0

    function on(eventName, callback) {
        if (eventName in obj) {
            obj[eventName].callbacks.push(callback)  }
        else {
            obj[eventName]= {
                pid: pid++,
                callbacks: []
            }
            obj[eventName].callbacks.push(callback)
            eventNames.push(eventName)
        }
    }

    function trigger(eventName) {
        for( var i in obj) {
            if(i == eventName) {
                obj[eventName].callbacks.map(function (callback) {
                    callback()
                })
            }
        }

    }
    return {
        on: on,
        trigger: trigger
   }
}

const EventEmitter = {
    on:function(type,handle){
        //创建一个缓存
        this.cache = {};
        console.log(this);
        //判断是否有这个类型的事件
        if(!this.cache[type]){
            //没有则创建一个
            this.cache[type] = [handle];
        }else{
            //已经存在就推入
            this.cache[type].push(handle);
        }
    },
    trigger:function(type){
        //判断是否传入了参数，如果传入了就把它填进一个数组中
        var params = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : [];
        if(this.cache[type]){
            this.cache[type].forEach(item => {
                //执行函数，并将参数传入
                item(params);
            })
        }
    }
}

   class EventEmitter {
  constructor() {
    this.obj = {}
  }

  on(eventName) {
    for (let n in this.obj) {
      if (n == eventName) {
        this.obj[n].cbs.map(cb => {
          cb()
        })
      }
    }
  }

  emit(eventName, cb) {
    let obj = this.obj
    if (eventName in obj) {
      obj[eventName].cbs.push(cb)
    } else {
      obj[eventName] = {
        cbs: []
      }
      obj[eventName].cbs.push(cb)
    }
  }
}

let eventEmitter = new EventEmitter()
// 发布
eventEmitter.emit('test', () => {
  console.log("定义了时间")
})
// 订阅
eventEmitter.on('test')

class EventEmiter {
  constructor() {
    this.event = [];
    this.handler = {};
  }
  emit(eventName) {
    this.event.push(eventName);
    this.event = [...new Set(this.event)];
  }
  on(eventName, callback) {
    const that = this;
    this.handler[eventName] = setInterval(() => {
      if (that.event.includes(eventName)) {
        that.event = that.event.filter((x) => x !== eventName);
        clearInterval(that.handler[eventName]);
        callback();
      }
    }, 0);
  }
}

function EventEmitter(element){
    this.on=function(name,callback){
        element.addEventListener(name,callback)
    }
    this.trigger=function(name){
        // 创建事件
        var eve=new Event(name)
        // 触发事件
        element.dispatchEvent(eve);
    }
}
var ele=new EventEmitter(document.getElementById('one'));
// 监听事件
ele.on('test',function(){
    console.log("自定义事件被触发了")
})
// 触发事件
ele.trigger('test')

	
	

		Element.prototype.methods = {};
        Element.prototype.监听 = function(method, fun){
            try{
                this.methods[method].push(fun);
            }catch{
                this.methods[method] = [];
                this.methods[method].push(fun);
            }
        }
        Element.prototype.触发 = function(method){
            this.methods[method].forEach(element => {
                let promise = new Promise(function(resolve,reject){
                    resolve(); //不知道传啥。
                })
                promise.then(element);
            });
        }
//-------------------------
	

	

		document.body.监听('说话',function(){
	

	

		    console.log("好瞌睡。。。");
	

	

		})
	

	

		document.body.触发('说话');
	

	

		
	

	

		//好瞌睡。。。
	

	

		//undefined