Run results for: Object.create(null) vs {} vs Map() key access (heavy)

Run details:

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser: Chrome 114

Operating system: Linux

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
undefined !== nullObject[key]	757.8 Ops/sec
"undefined" !== typeof nullObject[key]	954.8 Ops/sec
key in nullObject	975.5 Ops/sec
!!nullObject[key]	984.0 Ops/sec
Object.hasOwn(nullObject, key)	797.1 Ops/sec
Object.prototype.hasOwnProperty.call(nullObject, key)	771.2 Ops/sec
Object.hasOwn(normalObject, key)	793.3 Ops/sec
normalObject.hasOwnProperty(key)	974.9 Ops/sec
map.has(key)	980.0 Ops/sec

HTML Preparation code:


<script>
// random string function
const generateRandomString = length => {
  let result = ''
  const characters =
    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
  const charactersLength = characters.length
  for (let i = 0; i < length; i++) {
    result += characters.charAt(Math.floor(Math.random() * charactersLength))
  }
  return result
}

// shuffle array
const shuffleArray = array => {
  return array.sort(() => 0.5 - Math.random())
}

// Keys and Values creation
performance.mark('keys-array')

const keys = Array.from({ length: 10000 }, () =>
  generateRandomString(Math.floor(Math.random() * 100))
)

performance.measure('Create keys array', 'keys-array')

performance.mark('values-array')

const values = Array.from({ length: 10000 }, () =>
  generateRandomString(Math.floor(Math.random() * 200))
)

performance.measure('Create values array', 'values-array')

const dummyObject = {}

for (let i = 0; i < keys.length; i++) {
  const [key, value] = [keys[i], values[i]]
  dummyObject[key] = value
}

// Object and Map creation
performance.mark('normal-object')
/* 
const normalObject = Object.create(
  Object.prototype,
  Object.getOwnPropertyDescriptors(nullObject)
)
 */

const normalObject = {}
/* 
for (let i = 0; i < keys.length; i++) {
    normalObject[keys[i]] = values[i]
}
 */
for (let [key, value] of Object.entries(dummyObject)) {
  normalObject[key] = value
}

performance.measure('Create normal object', 'normal-object')

performance.mark('null-object')
/* takes very long time
const nullObject = Object.assign(
  Object.create(null),
  keys.reduce((a, v, i) => ({ ...a, [v]: values[i] }), {})
)
 */

const nullObject = Object.create(null)

for (let [key, value] of Object.entries(dummyObject)) {
  nullObject[key] = value
}

performance.measure('Create null object', 'null-object')

performance.mark('map')

/* 
const map = new Map(Object.entries(nullObject))
 */

const map = new Map()
/* 
for (let i = 0; i < keys.length; i++) {
    map.set(keys[i], values[i])
}
 */

for (let [key, value] of Object.entries(dummyObject)) {
  map.set(key, value)
}

performance.measure('Create map', 'map')

// Get random keys
/* performance.mark('shuffle-array') */

const shuffled = shuffleArray(keys)

/* performance.measure('Shuffle array', 'shuffle-array') */

/* performance.mark('test-keys') */

const testKeys = shuffleArray(
  shuffled
    .slice(0, 1000)
    .concat(
      Array.from({ length: 1000 }, () =>
        generateRandomString(Math.floor(Math.random() * 100))
      )
    )
)

/* performance.measure('Get test keys', 'test-keys') */

const resArr = []

// warm up
for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  const value = nullObject[key]
  resArr.push(!!value ? value.length > 100 : key.length > 50)
}

resArr.length = 0

/*
 * run tests once
 */

performance.mark('undefined-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(undefined !== nullObject[key])
}

performance.measure('undefined test case', 'undefined-case')

resArr.length = 0

performance.mark('typeof-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push('undefined' !== typeof nullObject[key])
}

performance.measure('typeof test case', 'typeof-case')

resArr.length = 0

performance.mark('in-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(key in nullObject)
}

performance.measure('in test case', 'in-case')

resArr.length = 0

performance.mark('boolean-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(!!nullObject[key])
}

performance.measure('boolean test case', 'boolean-case')

resArr.length = 0

performance.mark('hasOwn-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(Object.hasOwn(nullObject, key))
}

performance.measure('hasOwn test case', 'hasOwn-case')

resArr.length = 0

performance.mark('prototype-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(Object.prototype.hasOwnProperty.call(nullObject, key))
}

performance.measure('prototype test case', 'prototype-case')

resArr.length = 0

//

performance.mark('hasOwn-normal-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(Object.hasOwn(normalObject, key))
}

performance.measure('hasOwn normal test case', 'hasOwn-normal-case')

resArr.length = 0

performance.mark('hasOwnProperty-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(normalObject.hasOwnProperty(key))
}

performance.measure('hasOwnProperty test case', 'hasOwnProperty-case')

resArr.length = 0

//

performance.mark('has-case')

for (let i = 0; i < testKeys.length; i++) {
  const key = testKeys[i]
  resArr.push(map.has(key))
}

performance.measure('has test case', 'has-case')

resArr.length = 0

// get duration
performance.getEntries().forEach(entry => {
  if (entry.entryType === 'measure') {
    console.log(`${entry.name}'s duration: ${entry.duration}`)
  }
})

</script>

Tests:

undefined !== nullObject[key]
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(undefined !== nullObject[key]) } resArr.length = 0
"undefined" !== typeof nullObject[key]
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push('undefined' !== typeof nullObject[key]) } resArr.length = 0
key in nullObject
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(key in nullObject) } resArr.length = 0
!!nullObject[key]
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(!!nullObject[key]) } resArr.length = 0
Object.hasOwn(nullObject, key)
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(Object.hasOwn(nullObject, key)) } resArr.length = 0
Object.prototype.hasOwnProperty.call(nullObject, key)
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(Object.prototype.hasOwnProperty.call(nullObject, key)) } resArr.length = 0
Object.hasOwn(normalObject, key)
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(Object.hasOwn(normalObject, key)) } resArr.length = 0
normalObject.hasOwnProperty(key)
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(normalObject.hasOwnProperty(key)) } resArr.length = 0
map.has(key)
for (let i = 0; i < testKeys.length; i++) { const key = testKeys[i] resArr.push(map.has(key)) } resArr.length = 0

Run results for: Object.create(null) vs {} vs Map() key access (heavy)

Testing access to the own properties of a big Object / Map. true / false - 50% / 50% . Caution! Heavy test.

undefined !== nullObject[key]

"undefined" !== typeof nullObject[key]

key in nullObject

!!nullObject[key]

Object.hasOwn(nullObject, key)

Object.prototype.hasOwnProperty.call(nullObject, key)

Object.hasOwn(normalObject, key)

normalObject.hasOwnProperty(key)

map.has(key)