Run results for: Performance of object properties in relation with their length

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:109.0) Gecko/20100101 Firefox/111.0

Browser: Firefox 111

Operating system: Mac OS X 10.13

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
Very short keys	115.4 Ops/sec
Short keys	69.6 Ops/sec
Medium keys	198.9 Ops/sec
Long keys	212.6 Ops/sec
Very long keys	208.9 Ops/sec

Script Preparation code:

function uuid() {
  // Public Domain/MIT
  var d = new Date().getTime(); //Timestamp
  var d2 =
    (typeof performance !== "undefined" &&
      performance.now &&
      performance.now() * 1000) ||
    0; //Time in microseconds since page-load or 0 if unsupported
  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
    var r = Math.random() * 16; //random number between 0 and 16
    if (d > 0) {
      //Use timestamp until depleted
      r = (d + r) % 16 | 0;
      d = Math.floor(d / 16);
    } else {
      //Use microseconds since page-load if supported
      r = (d2 + r) % 16 | 0;
      d2 = Math.floor(d2 / 16);
    }
    return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
  });
}

function shortId() {
  // I generate the UID from two parts here
  // to ensure the random number provide enough bits.
  let firstPart = (Math.random() * 46656) | 0;
  let secondPart = (Math.random() * 46656) | 0;
  firstPart = ("000" + firstPart.toString(36)).slice(-3);
  secondPart = ("000" + secondPart.toString(36)).slice(-3);
  return firstPart + secondPart;
}

function shuffle(array) {
  let currentIndex = array.length,
    randomIndex;

  // While there remain elements to shuffle.
  while (currentIndex != 0) {
    // Pick a remaining element.
    randomIndex = Math.floor(Math.random() * currentIndex);
    currentIndex--;

    // And swap it with the current element.
    [array[currentIndex], array[randomIndex]] = [
      array[randomIndex],
      array[currentIndex],
    ];
  }

  return array;
}

const NB_ITEMS = 100000;
var objectWithVeryShortKeys = {};
var veryShortKeys = [];
for (let i = 0; i < NB_ITEMS; i++) {
  let key = shortId();
  objectWithVeryShortKeys[key] = Math.random();
  veryShortKeys.push(key);
}

var objectWithShortKeys = {};
var shortKeys = [];
for (let i = 0; i < NB_ITEMS; i++) {
  let key = uuid();
  objectWithShortKeys[key] = Math.random();
  shortKeys.push(key);
}

var objectWithMediumKeys = {};
var mediumKeys = [];
for (let i = 0; i < NB_ITEMS; i++) {
  let key = `${uuid()}::${uuid()}`;
  objectWithMediumKeys[key] = Math.random();
  mediumKeys.push(key);
}

var objectWithLongKeys = {};
var longKeys = [];
for (let i = 0; i < NB_ITEMS; i++) {
  let key = `${uuid()}::${uuid()}::some_more_text::${uuid()}`;
  objectWithLongKeys[key] = Math.random();
  longKeys.push(key);
}

var objectWithVeryLongKeys = {};
var veryLongKeys = [];
for (let i = 0; i < NB_ITEMS; i++) {
  let key = `${uuid()}::${uuid()}::some_more_text::${uuid()}::${uuid()}::${uuid()}::some_more_text::${uuid()}`;
  objectWithVeryLongKeys[key] = Math.random();
  veryLongKeys.push(key);
}

shuffle(veryShortKeys);
shuffle(shortKeys);
shuffle(mediumKeys);
shuffle(longKeys);
shuffle(veryLongKeys);

Tests:

Very short keys
let str = ""; for (let i = 0; i < 10000; i++) { str += objectWithVeryShortKeys[veryShortKeys[i]]; }
Short keys
let shortKeysStr = ""; for (let i = 0; i < 10000; i++) { shortKeysStr += objectWithShortKeys[shortKeys[i]]; }
Medium keys
let mediumKeysStr = ""; for (let i = 0; i < 10000; i++) { mediumKeysStr += objectWithMediumKeys[mediumKeys[i]]; }
Long keys
let longKeysStr = ""; for (let i = 0; i < 10000; i++) { longKeysStr += objectWithLongKeys[longKeys[i]]; }
Very long keys
let veryLongKeysStr = ""; for (let i = 0; i < 10000; i++) { veryLongKeysStr += objectWithVeryLongKeys[veryLongKeys[i]]; }

Run results for: Performance of object properties in relation with their length

Does the length of an objects properties matter when doing lookups at scale?

Very short keys

Short keys

Medium keys

Long keys

Very long keys