lib: reduce usage of self = this

doc/api/stream.markdown

@@ -1020,15 +1020,14 @@ function SimpleProtocol(source, options) {
   // source is a readable stream, such as a socket or file
   this._source = source;
 
-  var self = this;
   source.on('end', () => {
-    self.push(null);
+    this.push(null);
   });
 
   // give it a kick whenever the source is readable
   // read(0) will not consume any bytes
   source.on('readable', () => {
-    self.read(0);
+    this.read(0);
   });
 
   this._rawHeader = [];

lib/dgram.js

@@ -391,8 +391,7 @@ Socket.prototype.close = function(callback) {
   this._stopReceiving();
   this._handle.close();
   this._handle = null;
-  var self = this;
-  process.nextTick(socketCloseNT, self);
+  process.nextTick(socketCloseNT, this);
 
   return this;
 };

lib/domain.js

@@ -60,7 +60,6 @@ Domain.prototype._disposed = undefined;
 // Called by process._fatalException in case an error was thrown.
 Domain.prototype._errorHandler = function errorHandler(er) {
   var caught = false;
-  var self = this;
 
   // ignore errors on disposed domains.
   //
@@ -89,13 +88,13 @@ Domain.prototype._errorHandler = function errorHandler(er) {
     // as this would throw an error, make the process exit, and thus
     // prevent the process 'uncaughtException' event from being emitted
     // if a listener is set.
-    if (EventEmitter.listenerCount(self, 'error') > 0) {
+    if (EventEmitter.listenerCount(this, 'error') > 0) {
       try {
         // Set the _emittingTopLevelDomainError so that we know that, even
         // if technically the top-level domain is still active, it would
         // be ok to abort on an uncaught exception at this point
         process._emittingTopLevelDomainError = true;
-        caught = self.emit('error', er);
+        caught = this.emit('error', er);
       } finally {
         process._emittingTopLevelDomainError = false;
       }
@@ -111,7 +110,7 @@ Domain.prototype._errorHandler = function errorHandler(er) {
       //
       // If caught is false after this, then there's no need to exit()
       // the domain, because we're going to crash the process anyway.
-      caught = self.emit('error', er);
+      caught = this.emit('error', er);
     } catch (er2) {
       // The domain error handler threw!  oh no!
       // See if another domain can catch THIS error,

lib/https.js

@@ -77,12 +77,11 @@ function createConnection(port, host, options) {
     }
   }
 
-  const self = this;
-  const socket = tls.connect(options, function() {
+  const socket = tls.connect(options, () => {
     if (!options._agentKey)
       return;
 
-    self._cacheSession(options._agentKey, socket.getSession());
+    this._cacheSession(options._agentKey, socket.getSession());
   });
 
   // Evict session on error

lib/net.js

@@ -269,9 +269,8 @@ function writeAfterFIN(chunk, encoding, cb) {
 
   var er = new Error('This socket has been ended by the other party');
   er.code = 'EPIPE';
-  var self = this;
   // TODO: defer error events consistently everywhere, not just the cb
-  self.emit('error', er);
+  this.emit('error', er);
   if (typeof cb === 'function') {
     process.nextTick(cb, er);
   }
@@ -292,9 +291,8 @@ Socket.prototype.read = function(n) {
 
 Socket.prototype.listen = function() {
   debug('socket.listen');
-  var self = this;
-  self.on('connection', arguments[0]);
-  listen(self, null, null, null);
+  this.on('connection', arguments[0]);
+  listen(this, null, null, null);
 };
 
 
@@ -872,7 +870,6 @@ Socket.prototype.connect = function(options, cb) {
     this._sockname = null;
   }
 
-  var self = this;
   var pipe = !!options.path;
   debug('pipe', pipe, options.path);
 
@@ -882,21 +879,20 @@ Socket.prototype.connect = function(options, cb) {
   }
 
   if (typeof cb === 'function') {
-    self.once('connect', cb);
+    this.once('connect', cb);
   }
 
   this._unrefTimer();
 
-  self._connecting = true;
-  self.writable = true;
+  this._connecting = true;
+  this.writable = true;
 
   if (pipe) {
-    connect(self, options.path);
-
+    connect(this, options.path);
   } else {
-    lookupAndConnect(self, options);
+    lookupAndConnect(this, options);
   }
-  return self;
+  return this;
 };
 
 
@@ -1185,11 +1181,10 @@ exports._createServerHandle = createServerHandle;
 
 Server.prototype._listen2 = function(address, port, addressType, backlog, fd) {
   debug('listen2', address, port, addressType, backlog, fd);
-  var self = this;
 
   // If there is not yet a handle, we need to create one and bind.
   // In the case of a server sent via IPC, we don't need to do this.
-  if (self._handle) {
+  if (this._handle) {
     debug('_listen2: have a handle already');
   } else {
     debug('_listen2: create a handle');
@@ -1214,22 +1209,22 @@ Server.prototype._listen2 = function(address, port, addressType, backlog, fd) {
 
     if (typeof rval === 'number') {
       var error = exceptionWithHostPort(rval, 'listen', address, port);
-      process.nextTick(emitErrorNT, self, error);
+      process.nextTick(emitErrorNT, this, error);
       return;
     }
-    self._handle = rval;
+    this._handle = rval;
   }
 
-  self._handle.onconnection = onconnection;
-  self._handle.owner = self;
+  this._handle.onconnection = onconnection;
+  this._handle.owner = this;
 
-  var err = _listen(self._handle, backlog);
+  var err = _listen(this._handle, backlog);
 
   if (err) {
     var ex = exceptionWithHostPort(err, 'listen', address, port);
-    self._handle.close();
-    self._handle = null;
-    process.nextTick(emitErrorNT, self, ex);
+    this._handle.close();
+    this._handle = null;
+    process.nextTick(emitErrorNT, this, ex);
     return;
   }
 
@@ -1240,7 +1235,7 @@ Server.prototype._listen2 = function(address, port, addressType, backlog, fd) {
   if (this._unref)
     this.unref();
 
-  process.nextTick(emitListeningNT, self);
+  process.nextTick(emitListeningNT, this);
 };
 
 
@@ -1508,15 +1503,14 @@ Server.prototype.close = function(cb) {
 
 Server.prototype._emitCloseIfDrained = function() {
   debug('SERVER _emitCloseIfDrained');
-  var self = this;
 
-  if (self._handle || self._connections) {
+  if (this._handle || this._connections) {
     debug('SERVER handle? %j   connections? %d',
-          !!self._handle, self._connections);
+          !!this._handle, this._connections);
     return;
   }
 
-  process.nextTick(emitCloseNT, self);
+  process.nextTick(emitCloseNT, this);
 };
 
 

lib/repl.js

@@ -1122,7 +1122,7 @@ function regexpEscape(s) {
 REPLServer.prototype.convertToContext = function(cmd) {
   const scopeVar = /^\s*var\s*([_\w\$]+)(.*)$/m;
   const scopeFunc = /^\s*function\s*([_\w\$]+)/;
-  var self = this, matches;
+  var matches;
 
   // Replaces: var foo = "bar";  with: self.context.foo = bar;
   matches = scopeVar.exec(cmd);
@@ -1131,9 +1131,9 @@ REPLServer.prototype.convertToContext = function(cmd) {
   }
 
   // Replaces: function foo() {};  with: foo = function foo() {};
-  matches = scopeFunc.exec(self.bufferedCommand);
+  matches = scopeFunc.exec(this.bufferedCommand);
   if (matches && matches.length === 2) {
-    return matches[1] + ' = ' + self.bufferedCommand;
+    return matches[1] + ' = ' + this.bufferedCommand;
   }
 
   return cmd;

test/parallel/test-zlib.js

@@ -125,11 +125,10 @@ SlowStream.prototype.resume = function() {
 
 SlowStream.prototype.end = function(chunk) {
   // walk over the chunk in blocks.
-  var self = this;
-  self.chunk = chunk;
-  self.length = chunk.length;
-  self.resume();
-  return self.ended;
+  this.chunk = chunk;
+  this.length = chunk.length;
+  this.resume();
+  return this.ended;
 };