Download and run under github.com/babel/babel/packages/babel-parser/benchmark/

set-has-bench.mjs

import Benchmark from "benchmark";
import { report } from "./util.mjs";

const suite = new Benchmark.Suite();

const reservedWords = [
  "break",
  "case",
  "catch",
  "continue",
  "debugger",
  "default",
  "do",
  "else",
  "finally",
  "for",
  "function",
  "if",
  "return",
  "switch",
  "throw",
  "try",
  "var",
  "const",
  "while",
  "with",
  "new",
  "this",
  "super",
  "class",
  "extends",
  "export",
  "import",
  "null",
  "true",
  "false",
  "in",
  "instanceof",
  "typeof",
  "void",
  "delete",
  // strict
  "implements",
  "interface",
  "let",
  "package",
  "private",
  "protected",
  "public",
  "static",
  "yield",
  // strictBind
  "eval",
  "arguments",
  // reservedWorkLike
  "enum",
  "await",
];

const reservedWordLikeSet = new Set(reservedWords);

const reservedWordObj = Object.create(null);

for (const w of reservedWords) {
  reservedWordObj[w] = void 0;
}

function objectIn(word) {
  return word in reservedWordObj;
}

function setHas(word) {
  return reservedWordLikeSet.has(word);
}

function stringEquals(word) {
  switch (word.length) {
    case 2:
      return word === "do" || word === "if" || word === "in";
    case 3:
      return (
        word === "for" ||
        word === "let" ||
        word === "new" ||
        word === "try" ||
        word === "var"
      );
    case 4:
      return (
        word === "case" ||
        word === "else" ||
        word === "enum" ||
        word === "eval" ||
        word === "null" ||
        word === "this" ||
        word === "true" ||
        word === "void" ||
        word === "with"
      );
    case 5:
      return (
        word === "await" ||
        word === "break" ||
        word === "catch" ||
        word === "class" ||
        word === "const" ||
        word === "false" ||
        word === "super" ||
        word === "throw" ||
        word === "while" ||
        word === "yield"
      );
    case 6:
      return (
        word === "delete" ||
        word === "export" ||
        word === "import" ||
        word === "public" ||
        word === "return" ||
        word === "static" ||
        word === "switch" ||
        word === "typeof"
      );
    case 7:
      return (
        word === "default" ||
        word === "finally" ||
        word === "extends" ||
        word === "package" ||
        word === "private"
      );
    case 8:
      return word === "continue" || word === "debugger" || word === "function";
    case 9:
      return (
        word === "arguments" || word === "interface" || word === "protected"
      );
    case 10:
      return word === "instanceof" || word === "implements";
  }
}

function benchCases(name, implementation) {
  suite.add(`${name} different string`, () => {
    // implementation(new String("break"));
    // implementation(new String("case"));
    // implementation(new String("catch"));
    // implementation(new String("continue"));
    // implementation(new String("debugger"));
    // implementation(new String("default"));
    // implementation(new String("do"));
    // implementation(new String("else"));
    // implementation(new String("finally"));
    // implementation(new String("for"));
    // implementation(new String("function"));
    // implementation(new String("if"));
    // implementation(new String("return"));
    // implementation(new String("switch"));
    // implementation(new String("throw"));
    // implementation(new String("try"));
    // implementation(new String("var"));
    // implementation(new String("const"));
    // implementation(new String("while"));
    // implementation(new String("with"));
    // implementation(new String("new"));
    // implementation(new String("this"));
    // implementation(new String("super"));
    // implementation(new String("class"));
    // implementation(new String("extends"));
    // implementation(new String("export"));
    // implementation(new String("import"));
    // implementation(new String("null"));
    // implementation(new String("true"));
    // implementation(new String("false"));
    // implementation(new String("in"));
    // implementation(new String("instanceof"));
    // implementation(new String("typeof"));
    // implementation(new String("void"));
    // implementation(new String("delete"));
    // implementation(new String("implements"));
    // implementation(new String("interface"));
    // implementation(new String("let"));
    // implementation(new String("package"));
    // implementation(new String("private"));
    // implementation(new String("protected"));
    // implementation(new String("public"));
    // implementation(new String("static"));
    // implementation(new String("yield"));
    // implementation(new String("eval"));
    // implementation(new String("arguments"));
    // implementation(new String("enum"));
    // implementation(new String("await"));

    implementation(new String("instanceog"));
    implementation(new String("implementa"));
  });

  suite.add(`${name} constant string`, () => {
    implementation("instanceog");
    implementation("implementa");
  });
}

benchCases("object brand checks", objectIn);
benchCases("set#has", setHas);
benchCases("string#equals", stringEquals);

suite.on("cycle", report).run();