diff --git a/lib/events.js b/lib/events.js
index 1414a1429dfe3b..3aded39489bea4 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -54,9 +54,6 @@ Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
     return defaultMaxListeners;
   },
   set: function(arg) {
-    // force global console to be compiled.
-    // see https://github.com/nodejs/node/issues/4467
-    console;
     // check whether the input is a positive number (whose value is zero or
     // greater and not a NaN).
     if (typeof arg !== 'number' || arg < 0 || arg !== arg) {
@@ -77,7 +74,8 @@ EventEmitter.init = function() {
     }
   }
 
-  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
     this._events = Object.create(null);
     this._eventsCount = 0;
   }
@@ -163,24 +161,23 @@ function emitMany(handler, isFn, self, args) {
   }
 }
 
-EventEmitter.prototype.emit = function emit(type) {
-  var er, handler, len, args, i, events, domain;
-  var needDomainExit = false;
-  var doError = (type === 'error');
+EventEmitter.prototype.emit = function emit(type, ...args) {
+  let doError = (type === 'error');
 
-  events = this._events;
-  if (events)
-    doError = (doError && events.error == null);
+  const events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
   else if (!doError)
     return false;
 
-  domain = this.domain;
+  const domain = this.domain;
 
   // If there is no 'error' event listener then throw.
   if (doError) {
-    if (arguments.length > 1)
-      er = arguments[1];
-    if (domain) {
+    let er;
+    if (args.length > 0)
+      er = args[0];
+    if (domain !== null && domain !== undefined) {
       if (!er) {
         const errors = lazyErrors();
         er = new errors.Error('ERR_UNHANDLED_ERROR');
@@ -203,37 +200,32 @@ EventEmitter.prototype.emit = function emit(type) {
     return false;
   }
 
-  handler = events[type];
+  const handler = events[type];
 
-  if (!handler)
+  if (handler === undefined)
     return false;
 
-  if (domain && this !== process) {
+  let needDomainExit = false;
+  if (domain !== null && domain !== undefined && this !== process) {
     domain.enter();
     needDomainExit = true;
   }
 
-  var isFn = typeof handler === 'function';
-  len = arguments.length;
-  switch (len) {
-    // fast cases
-    case 1:
+  const isFn = typeof handler === 'function';
+  switch (args.length) {
+    case 0:
       emitNone(handler, isFn, this);
       break;
+    case 1:
+      emitOne(handler, isFn, this, args[0]);
+      break;
     case 2:
-      emitOne(handler, isFn, this, arguments[1]);
+      emitTwo(handler, isFn, this, args[0], args[1]);
       break;
     case 3:
-      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
-      break;
-    case 4:
-      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+      emitThree(handler, isFn, this, args[0], args[1], args[2]);
       break;
-    // slower
     default:
-      args = new Array(len - 1);
-      for (i = 1; i < len; i++)
-        args[i - 1] = arguments[i];
       emitMany(handler, isFn, this, args);
   }
 
@@ -254,13 +246,13 @@ function _addListener(target, type, listener, prepend) {
   }
 
   events = target._events;
-  if (!events) {
+  if (events === undefined) {
     events = target._events = Object.create(null);
     target._eventsCount = 0;
   } else {
     // To avoid recursion in the case that type === "newListener"! Before
     // adding it to the listeners, first emit "newListener".
-    if (events.newListener) {
+    if (events.newListener !== undefined) {
       target.emit('newListener', type,
                   listener.listener ? listener.listener : listener);
 
@@ -271,7 +263,7 @@ function _addListener(target, type, listener, prepend) {
     existing = events[type];
   }
 
-  if (!existing) {
+  if (existing === undefined) {
     // Optimize the case of one listener. Don't need the extra array object.
     existing = events[type] = listener;
     ++target._eventsCount;
@@ -337,10 +329,7 @@ function onceWrapper() {
         return this.listener.call(this.target, arguments[0], arguments[1],
                                   arguments[2]);
       default:
-        const args = new Array(arguments.length);
-        for (var i = 0; i < args.length; ++i)
-          args[i] = arguments[i];
-        this.listener.apply(this.target, args);
+        this.listener.apply(this.target, arguments);
     }
   }
 }
@@ -385,11 +374,11 @@ EventEmitter.prototype.removeListener =
       }
 
       events = this._events;
-      if (!events)
+      if (events === undefined)
         return this;
 
       list = events[type];
-      if (!list)
+      if (list === undefined)
         return this;
 
       if (list === listener || list.listener === listener) {
@@ -422,7 +411,7 @@ EventEmitter.prototype.removeListener =
         if (list.length === 1)
           events[type] = list[0];
 
-        if (events.removeListener)
+        if (events.removeListener !== undefined)
           this.emit('removeListener', type, originalListener || listener);
       }
 
@@ -434,15 +423,15 @@ EventEmitter.prototype.removeAllListeners =
       var listeners, events, i;
 
       events = this._events;
-      if (!events)
+      if (events === undefined)
         return this;
 
       // not listening for removeListener, no need to emit
-      if (!events.removeListener) {
+      if (events.removeListener === undefined) {
         if (arguments.length === 0) {
           this._events = Object.create(null);
           this._eventsCount = 0;
-        } else if (events[type]) {
+        } else if (events[type] !== undefined) {
           if (--this._eventsCount === 0)
             this._events = Object.create(null);
           else
@@ -470,7 +459,7 @@ EventEmitter.prototype.removeAllListeners =
 
       if (typeof listeners === 'function') {
         this.removeListener(type, listeners);
-      } else if (listeners) {
+      } else if (listeners !== undefined) {
         // LIFO order
         for (i = listeners.length - 1; i >= 0; i--) {
           this.removeListener(type, listeners[i]);
@@ -481,23 +470,19 @@ EventEmitter.prototype.removeAllListeners =
     };
 
 EventEmitter.prototype.listeners = function listeners(type) {
-  var evlistener;
-  var ret;
-  var events = this._events;
+  const events = this._events;
 
-  if (!events)
-    ret = [];
-  else {
-    evlistener = events[type];
-    if (!evlistener)
-      ret = [];
-    else if (typeof evlistener === 'function')
-      ret = [evlistener.listener || evlistener];
-    else
-      ret = unwrapListeners(evlistener);
-  }
+  if (events === undefined)
+    return [];
 
-  return ret;
+  const evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return [evlistener.listener || evlistener];
+
+  return unwrapListeners(evlistener);
 };
 
 EventEmitter.listenerCount = function(emitter, type) {
@@ -512,12 +497,12 @@ EventEmitter.prototype.listenerCount = listenerCount;
 function listenerCount(type) {
   const events = this._events;
 
-  if (events) {
+  if (events !== undefined) {
     const evlistener = events[type];
 
     if (typeof evlistener === 'function') {
       return 1;
-    } else if (evlistener) {
+    } else if (evlistener !== undefined) {
       return evlistener.length;
     }
   }