Run results for: trim() vs Regex: Check if string is EmptyOrWhitespace (with flat polyfill for older browsers)

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0

Browser: Firefox 75

Operating system: Windows

Device Platform: Desktop

Date tested: 4 years ago

Test name	Executions per second
isWhitespaceRgx	263505.8 Ops/sec
isWhitespaceTrim	249210.4 Ops/sec
isWhitespaceRgxWEarlyExit	346042.3 Ops/sec
isWhitespaceTrimWEarlyExit	294714.4 Ops/sec
Verify Correctness	1658870.0 Ops/sec
2:isWhitespaceTrimWEarlyExit	310809.2 Ops/sec
2:isWhitespaceRgxWEarlyExit	336585.9 Ops/sec
2:isWhitespaceTrim	273629.6 Ops/sec
2:isWhitespaceRgx	291386.1 Ops/sec

Script Preparation code:

Array.prototype.flat = Array.prototype.flat || function flat(depth) {
  // This is the fastest method: https://www.measurethat.net/Benchmarks/Show/7815/0/array-concat-vs-spread-operator-vs-push-for-array-flat
  if (depth === undefined) { depth = 100; } else if (depth <= 0) { return this; }
  var result = [];
  for (var len = this.length, i = 0, val; i < len; ++i) {
    if (Array.isArray((val = this[i]))) {
      val = val.flat(depth - 1);
      for (var jen = val.length, j = 0; j < jen; ++j) { result.push(val[j]); }
    } else {
      result.push(val);
    }
  }
  return result;
} 
// Generates 400 sample strings at time of writing, some with no whitespace, some that are all whitespace, and some with a little of both
var sampleStrings = Array.from(document.body.childNodes)
                         .map(x=> x.textContent.split('\n'))
                         .flat()
                         .map(x=> x.length>10 && (x.length % 2 > 0) ? x.trim() : x);

var whitespaceRgx = /^\s*$/;
var isWhitespaceRgx = (str) => whitespaceRgx.test(str);
var isWhitespaceTrim = (str) => str.trim().length === 0;

var whitespaceRgxEarlyExit = /^\s+$/;
var isWhitespaceRgxWEarlyExit = (str) => str.length === 0 || whitespaceRgxEarlyExit.test(str);
var isWhitespaceTrimWEarlyExit = (str) => str.length === 0 || str.trim().length === 0;

var methods = [
  isWhitespaceRgx,
  isWhitespaceTrim,
  isWhitespaceRgxWEarlyExit,
  isWhitespaceTrimWEarlyExit
];

Tests:

isWhitespaceRgx
return sampleStrings.map(isWhitespaceRgx);
isWhitespaceTrim
return sampleStrings.map(isWhitespaceTrim);
isWhitespaceRgxWEarlyExit
return sampleStrings.map(isWhitespaceRgxWEarlyExit);
isWhitespaceTrimWEarlyExit
return sampleStrings.map(isWhitespaceTrimWEarlyExit);
Verify Correctness
let results = new Array(methods.length); for(let samples=sampleStrings, len=samples.length, i=0; i<len; ++i){ for (let samp = samples[i], jen = methods.lenth, j=0; j<jen; ++j) { results[j] = methods[j](samp); if (j > 0 && results[j] !== results[j-1]) { throw new Error(`${methods[j].name}:${results[j]} does not match ${methods[j-1].name}:${results[j-1]} for: \n${samp}`); } } }
2:isWhitespaceTrimWEarlyExit
// Run in reverse order from first 4 test return sampleStrings.map(isWhitespaceTrimWEarlyExit);
2:isWhitespaceRgxWEarlyExit
// Run in reverse order from first 4 test return sampleStrings.map(isWhitespaceRgxWEarlyExit);
2:isWhitespaceTrim
// Run in reverse order from first 4 test return sampleStrings.map(isWhitespaceTrim);
2:isWhitespaceRgx
// Run in reverse order from first 4 test return sampleStrings.map(isWhitespaceRgx);

Run results for: trim() vs Regex: Check if string is EmptyOrWhitespace (with flat polyfill for older browsers)

Is "string".trim().length === 0 faster or slower than RegExp /^\s*$/.test("string")

isWhitespaceRgx

isWhitespaceTrim

isWhitespaceRgxWEarlyExit

isWhitespaceTrimWEarlyExit

Verify Correctness

2:isWhitespaceTrimWEarlyExit

2:isWhitespaceRgxWEarlyExit

2:isWhitespaceTrim

2:isWhitespaceRgx