Map Bench

gistfile1.txt

// Native Map Size x 165,662,711 ops/sec ±8.85% (69 runs sampled)
// Immutable.js Map Size x 2.20 ops/sec ±8.58% (10 runs sampled)
// Immutable.js OrderedMap Size x 1.98 ops/sec ±15.02% (9 runs sampled)
// Native Object Size x 7.17 ops/sec ±1.73% (22 runs sampled)
// Fastest in sizeSuite is Native Map Size

// Native Map Get x 57.17 ops/sec ±0.61% (75 runs sampled)
// Immutable.js Map Get x 4.05 ops/sec ±2.02% (15 runs sampled)
// Immutable.js OrderedMap Get x 3.64 ops/sec ±1.54% (14 runs sampled)
// Native Object Get x 3.95 ops/sec ±2.39% (14 runs sampled)
// Fastest in getSuite is Native Map Get

// Native Map Iterate x 219 ops/sec ±0.59% (88 runs sampled)
// Immutable.js Map Iterate x 12.43 ops/sec ±1.41% (35 runs sampled)
// Immutable.js OrderedMap Iterate x 39.89 ops/sec ±0.75% (54 runs sampled)
// Native Object Iterate x 4.76 ops/sec ±1.50% (16 runs sampled)
// Fastest in iterateSuite is Native Map Iterate

// Native Map Slice x 20,364 ops/sec ±33.87% (13 runs sampled)
// Immutable.js Map Slice x 2.35 ops/sec ±12.76% (10 runs sampled)
// Immutable.js OrderedMap Slice x 2.00 ops/sec ±9.78% (9 runs sampled)
// Native Object Slice x 597,821 ops/sec ±3.64% (98 runs sampled)
// Fastest in sliceSuite is Native Object Slice

import Benchmark from "benchmark"
import { Map as ImmutableMap, OrderedMap as ImmutableOrderedMap, Seq } from "immutable"
const size = 1000000

// Создаем данные для тестирования
const data: [string, number][] = Array.from({ length: size }, (_, i) => [i + "x", i])

// Создаем экземпляры Map и обычного объекта
const nativeMap = new Map<string, number>(data)
const immutableMap = ImmutableMap<string, number>(data)
const immutableOrderedMap = ImmutableOrderedMap<string, number>(data)
const nativeObject: { [key: string]: number } = Object.fromEntries(data)

// Функции для тестирования get
const nativeMapGet = () => {
  for (let i = 0; i < size; i++) {
    nativeMap.get(i + "x")
  }
}

const immutableMapGet = () => {
  for (let i = 0; i < size; i++) {
    immutableMap.get(i + "x")
  }
}

const immutableOrderedMapGet = () => {
  for (let i = 0; i < size; i++) {
    immutableOrderedMap.get(i + "x")
  }
}

const nativeObjectGet = () => {
  for (let i = 0; i < size; i++) {
    nativeObject[i + "x"]
  }
}

// Функции для тестирования итерации
const nativeMapIterate = () => {
  nativeMap.forEach((value, key) => {
    value
  })
}

const immutableMapIterate = () => {
  immutableMap.forEach((value, key) => {
    value
  })
}

const immutableOrderedMapIterate = () => {
  immutableOrderedMap.forEach((value, key) => {
    value
  })
}

const nativeObjectIterate = () => {
  for (const key in nativeObject) {
    if (nativeObject.hasOwnProperty(key)) {
      nativeObject[key]
    }
  }
}

// Функции для тестирования первых N элементов
const nativeMapSlice = () => {
  const next = nativeMap.keys().next().value
  for (let i = 0; i < 100; i++) {
    nativeMap.delete(next as string)
  }
}

const immutableMapSlice = () => {
  immutableMap.slice(100)
}

const immutableOrderedMapSlice = () => {
  immutableOrderedMap.slice(100)
}

const nativeObjectSlice = () => {
  for (let i = 0; i < 100; i++) {
    delete nativeObject[0]
  }
}

const nativeMapSize = () => {
  nativeMap.size
}

const immutableMapSize = () => {
  immutableMap.slice(100)
  immutableMap.size
}

const immutableOrderedMapSize = () => {
  immutableOrderedMap.slice(100)
  immutableOrderedMap.size
}

const nativeObjectSize = () => {
  Object.keys(nativeObject).length
}

// Создаем бенчмарки
const getSuite = new Benchmark.Suite()
const iterateSuite = new Benchmark.Suite()
const sliceSuite = new Benchmark.Suite()
const sizeSuite = new Benchmark.Suite()

// Добавляем тесты для операций get
getSuite
  .add("Native Map Get", nativeMapGet)
  .add("Immutable.js Map Get", immutableMapGet)
  .add("Immutable.js OrderedMap Get", immutableOrderedMapGet)
  .add("Native Object Get", nativeObjectGet)
  .on("cycle", (event: Benchmark.Event) => {
    console.log(String(event.target))
  })
  .on("complete", function (this: Benchmark.Suite) {
    console.log("Fastest in getSuite is " + this.filter("fastest").map("name"))
    console.log()
    iterateSuite.run({ async: true })
  })

sizeSuite
  .add("Native Map Size", nativeMapSize)
  .add("Immutable.js Map Size", immutableMapSize)
  .add("Immutable.js OrderedMap Size", immutableOrderedMapSize)
  .add("Native Object Size", nativeObjectSize)
  .on("cycle", (event: Benchmark.Event) => {
    console.log(String(event.target))
  })
  .on("complete", function (this: Benchmark.Suite) {
    console.log("Fastest in sizeSuite is " + this.filter("fastest").map("name"))
    console.log()
    getSuite.run({ async: true })
  })

// Добавляем тесты для итерации
iterateSuite
  .add("Native Map Iterate", nativeMapIterate)
  .add("Immutable.js Map Iterate", immutableMapIterate)
  .add("Immutable.js OrderedMap Iterate", immutableOrderedMapIterate)
  .add("Native Object Iterate", nativeObjectIterate)
  .on("cycle", (event: Benchmark.Event) => {
    console.log(String(event.target))
  })
  .on("complete", function (this: Benchmark.Suite) {
    console.log("Fastest in iterateSuite is " + this.filter("fastest").map("name"))
    console.log()
    sliceSuite.run({ async: true })
  })

// Добавляем тесты для удаления элементов (slice)
sliceSuite
  .add("Native Map Slice", nativeMapSlice)
  .add("Immutable.js Map Slice", immutableMapSlice)
  .add("Immutable.js OrderedMap Slice", immutableOrderedMapSlice)
  .add("Native Object Slice", nativeObjectSlice)
  .on("cycle", (event: Benchmark.Event) => {
    console.log(String(event.target))
  })
  .on("complete", function (this: Benchmark.Suite) {
    console.log("Fastest in sliceSuite is " + this.filter("fastest").map("name"))
  })

// Запускаем бенчмарки по очереди
sizeSuite.run({ async: true })