docs: modernize classes in code snippets

Author: GeorgeSapkin

locale/en/docs/guides/domain-postmortem.md

@@ -162,10 +162,9 @@ basic operations:
 'use strict';
 
 const domain = require('domain');
-const EE = require('events');
+const EventEmitter = require('events');
 const fs = require('fs');
 const net = require('net');
-const util = require('util');
 const print = process._rawDebug;
 
 const pipeList = [];
@@ -180,38 +179,40 @@ for (let i = 0; i < buf.length; i++)
   buf[i] = ((Math.random() * 1e3) % 78) + 48; // Basic ASCII
 fs.writeFileSync(FILENAME, buf);
 
-function ConnectionResource(c) {
-  EE.call(this);
-  this._connection = c;
-  this._alive = true;
-  this._domain = domain.create();
-  this._id = Math.random().toString(32).substr(2).substr(0, 8) + (++uid);
+class ConnectionResource extends EventEmitter {
+  constructor(c) {
+    super();
 
-  this._domain.add(c);
-  this._domain.on('error', () => {
-    this._alive = false;
-  });
-}
-util.inherits(ConnectionResource, EE);
-
-ConnectionResource.prototype.end = function end(chunk) {
-  this._alive = false;
-  this._connection.end(chunk);
-  this.emit('end');
-};
+    this._connection = c;
+    this._alive = true;
+    this._domain = domain.create();
+    this._id = Math.random().toString(32).substr(2).substr(0, 8) + (++uid);
 
-ConnectionResource.prototype.isAlive = function isAlive() {
-  return this._alive;
-};
-
-ConnectionResource.prototype.id = function id() {
-  return this._id;
-};
+    this._domain.add(c);
+    this._domain.on('error', () => {
+      this._alive = false;
+    });
+  }
 
-ConnectionResource.prototype.write = function write(chunk) {
-  this.emit('data', chunk);
-  return this._connection.write(chunk);
-};
+  end(chunk) {
+    this._alive = false;
+    this._connection.end(chunk);
+    this.emit('end');
+  }
+
+  isAlive() {
+    return this._alive;
+  }
+
+  id() {
+    return this._id;
+  }
+
+  write(chunk) {
+    this.emit('data', chunk);
+    return this._connection.write(chunk);
+  }
+}
 
 // Example begin
 net.createServer((c) => {
@@ -364,31 +365,33 @@ function dataTransformed(chunk) {
   domain.active.data.connection.write(chunk);
 }
 
-function DataStream(cb) {
-  this.cb = cb;
-  // DataStream wants to use domains for data propagation too!
-  // Unfortunately this will conflict with any domain that
-  // already exists.
-  this.domain = domain.create();
-  this.domain.data = { inst: this };
-}
-
-DataStream.prototype.data = function data(chunk) {
-  // This code is self contained, but pretend it's a complex
-  // operation that crosses at least one other module. So
-  // passing along "this", etc., is not easy.
-  this.domain.run(() => {
-    // Simulate an async operation that does the data transform.
-    setImmediate(() => {
-      for (let i = 0; i < chunk.length; i++)
-        chunk[i] = ((chunk[i] + Math.random() * 100) % 96) + 33;
-      // Grab the instance from the active domain and use that
-      // to call the user's callback.
-      const self = domain.active.data.inst;
-      self.cb(chunk);
+class DataStream {
+  constructor(cb) {
+    this.cb = cb;
+    // DataStream wants to use domains for data propagation too!
+    // Unfortunately this will conflict with any domain that
+    // already exists.
+    this.domain = domain.create();
+    this.domain.data = { inst: this };
+  }
+
+  data(chunk) {
+    // This code is self contained, but pretend it's a complex
+    // operation that crosses at least one other module. So
+    // passing along "this", etc., is not easy.
+    this.domain.run(() => {
+      // Simulate an async operation that does the data transform.
+      setImmediate(() => {
+        for (let i = 0; i < chunk.length; i++)
+          chunk[i] = ((chunk[i] + Math.random() * 100) % 96) + 33;
+        // Grab the instance from the active domain and use that
+        // to call the user's callback.
+        const self = domain.active.data.inst;
+        self.cb(chunk);
+      });
     });
-  });
-};
+  }
+}
 ```
 
 The above shows that it is difficult to have more than one asynchronous API

locale/en/docs/guides/event-loop-timers-and-nexttick.md

@@ -441,19 +441,18 @@ the event loop to proceed, it must hit the **poll** phase, which means
 there is a non-zero chance that a connection could have been received
 allowing the connection event to be fired before the listening event.
 
-Another example is running a function constructor that was to, say,
-inherit from `EventEmitter` and it wanted to call an event within the
-constructor:
+Another example is a class that extends an `EventEmitter` and emits an
+event within the constructor:
 
 ```js
 const EventEmitter = require('events');
-const util = require('util');
 
-function MyEmitter() {
-  EventEmitter.call(this);
-  this.emit('event');
+class MyEmitter extends EventEmitter {
+  constructor() {
+    super();
+    this.emit('event');
+  }
 }
-util.inherits(MyEmitter, EventEmitter);
 
 const myEmitter = new MyEmitter();
 myEmitter.on('event', () => {
@@ -469,22 +468,17 @@ after the constructor has finished, which provides the expected results:
 
 ```js
 const EventEmitter = require('events');
-const util = require('util');
 
-function MyEmitter() {
-  EventEmitter.call(this);
+class MyEmitter extends EventEmitter {
+  constructor() {
+    super();
 
-  // use nextTick to emit the event once a handler is assigned
-  process.nextTick(() => {
-    this.emit('event');
-  });
+    // use nextTick to emit the event once a handler is assigned
+    process.nextTick(() => {
+      this.emit('event');
+    });
+  }
 }
-util.inherits(MyEmitter, EventEmitter);
-
-const myEmitter = new MyEmitter();
-myEmitter.on('event', () => {
-  console.log('an event occurred!');
-});
 ```
 
 [libuv]: https://libuv.org/