buffer: stricter Buffer.isBuffer

benchmark/buffers/buffer-isbuffer.js

@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../common');
+const { Buffer } = require('buffer');
+
+function FakeBuffer() {}
+FakeBuffer.prototype = Object.create(Buffer.prototype);
+
+// Refs: https://github.com/nodejs/node/issues/9531#issuecomment-265611061
+class ExtensibleBuffer extends Buffer {
+  constructor() {
+    super(new ArrayBuffer(0), 0, 0);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+const inputs = {
+  primitive: false,
+  object: {},
+  fake: new FakeBuffer(),
+  subclassed: new ExtensibleBuffer(),
+  fastbuffer: Buffer.alloc(1),
+  slowbuffer: Buffer.allocUnsafeSlow(0),
+  uint8array: new Uint8Array(1)
+};
+
+const bench = common.createBenchmark(main, {
+  type: Object.keys(inputs),
+  n: [1e7]
+});
+
+function main(conf) {
+  const n = conf.n | 0;
+  const input = inputs[conf.type];
+
+  bench.start();
+  for (var i = 0; i < n; i++)
+    Buffer.isBuffer(input);
+  bench.end(n);
+}

lib/_http_outgoing.js

@@ -645,7 +645,7 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
     return true;
   }
 
-  if (!fromEnd && typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
+  if (!fromEnd && typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {
     throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'first argument',
                                ['string', 'buffer']);
   }
@@ -743,7 +743,7 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
 
   var uncork;
   if (chunk) {
-    if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
+    if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {
       throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'first argument',
                                  ['string', 'buffer']);
     }

lib/buffer.js

@@ -420,7 +420,14 @@ function fromObject(obj) {
 // Static methods
 
 Buffer.isBuffer = function isBuffer(b) {
-  return b instanceof Buffer;
+  if (!isUint8Array(b))
+    return false;
+  // Subclassing Buffer is not officially supported currently, and actually
+  // subclassing it requires some awkward code that users are unlikely to do.
+  // Therefore prioritize the fast case over the full `instanceof`.
+  // Refs: https://github.com/nodejs/node/issues/9531#issuecomment-265611061
+  const proto = Object.getPrototypeOf(b);
+  return proto === Buffer.prototype || proto instanceof Buffer.prototype;
 };
 
 
@@ -567,15 +574,15 @@ Buffer.byteLength = byteLength;
 Object.defineProperty(Buffer.prototype, 'parent', {
   enumerable: true,
   get() {
-    if (!(this instanceof Buffer))
+    if (!Buffer.isBuffer(this))
       return undefined;
     return this.buffer;
   }
 });
 Object.defineProperty(Buffer.prototype, 'offset', {
   enumerable: true,
   get() {
-    if (!(this instanceof Buffer))
+    if (!Buffer.isBuffer(this))
       return undefined;
     return this.byteOffset;
   }

lib/fs.js

@@ -2198,7 +2198,7 @@ WriteStream.prototype.open = function() {
 
 
 WriteStream.prototype._write = function(data, encoding, cb) {
-  if (!(data instanceof Buffer))
+  if (!Buffer.isBuffer(data))
     return this.emit('error', new Error('Invalid data'));
 
   if (typeof this.fd !== 'number') {

lib/net.js

@@ -694,7 +694,7 @@ protoGetter('localPort', function localPort() {
 
 
 Socket.prototype.write = function(chunk, encoding, cb) {
-  if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
+  if (typeof chunk !== 'string' && !Buffer.isBuffer(chunk)) {
     throw new TypeError(
       'Invalid data, chunk must be a string or buffer, not ' + typeof chunk);
   }
@@ -752,7 +752,7 @@ Socket.prototype._writeGeneric = function(writev, data, encoding, cb) {
     if (err === 0) req._chunks = chunks;
   } else {
     var enc;
-    if (data instanceof Buffer) {
+    if (Buffer.isBuffer(data)) {
       enc = 'buffer';
     } else {
       enc = encoding;
@@ -821,7 +821,7 @@ protoGetter('bytesWritten', function bytesWritten() {
     return undefined;
 
   state.getBuffer().forEach(function(el) {
-    if (el.chunk instanceof Buffer)
+    if (Buffer.isBuffer(el.chunk))
       bytes += el.chunk.length;
     else
       bytes += Buffer.byteLength(el.chunk, el.encoding);
@@ -832,7 +832,7 @@ protoGetter('bytesWritten', function bytesWritten() {
     for (var i = 0; i < data.length; i++) {
       const chunk = data[i];
 
-      if (data.allBuffers || chunk instanceof Buffer)
+      if (data.allBuffers || Buffer.isBuffer(chunk))
         bytes += chunk.length;
       else
         bytes += Buffer.byteLength(chunk.chunk, chunk.encoding);

lib/readline.js

@@ -973,7 +973,7 @@ Interface.prototype._ttyWrite = function(s, key) {
         // falls through
 
       default:
-        if (s instanceof Buffer)
+        if (Buffer.isBuffer(s))
           s = s.toString('utf-8');
 
         if (s) {

test/parallel/test-buffer-isbuffer.js

@@ -0,0 +1,31 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Buffer } = require('buffer');
+
+const t = (val, exp) => assert.strictEqual(Buffer.isBuffer(val), exp);
+
+function FakeBuffer() {}
+FakeBuffer.prototype = Object.create(Buffer.prototype);
+
+class ExtensibleBuffer extends Buffer {
+  constructor() {
+    super(new ArrayBuffer(0), 0, 0);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+t(0, false);
+t(true, false);
+t('foo', false);
+t(Symbol(), false);
+t(null, false);
+t(undefined, false);
+t(() => {}, false);
+
+t({}, false);
+t(new Uint8Array(2), false);
+t(new FakeBuffer(), false);
+t(new ExtensibleBuffer(), true);
+t(Buffer.from('foo'), true);
+t(Buffer.allocUnsafeSlow(2), true);

test/parallel/test-util.js

@@ -96,6 +96,7 @@ assert.strictEqual(true, util.isPrimitive(NaN));
 assert.strictEqual(true, util.isPrimitive(Symbol('symbol')));
 
 // isBuffer
+assert.strictEqual(util.isBuffer, Buffer.isBuffer);
 assert.strictEqual(false, util.isBuffer('foo'));
 assert.strictEqual(true, util.isBuffer(Buffer.from('foo')));