Javascript ES6 computational/time complexity of collections

Question

What time complexity (in big-O notation) is provided by the ES6 specification for the Keyed Collections (Set, Map, WeakSet, and WeakMap)?

My expectation, and I expect that of most developers, is that the specifications and implementations would use widely accepted performant algorithms, in which case Set.prototype.has, add and delete to all be O(1) in the average case. The same for the Map and Weak– equivalents.

It is not entirely apparent to me whether the time complexity of the implementations was mandated e.g. in ECMAScript 2015 Language Specification - 6th Edition — 23.2 Set Objects.

Unless I misunderstand it (and it's certainly very possible I do), it looks the ECMA spec mandates that the implementations (e.g. Set.prototype.has) are to use a linear time (O(n)) algorithm. It would strike me as exceedingly surprising that more performant algorithms would not be mandated or even permitted by the spec, and I would be very interested in an explanation for why this is the case.

Answer 1

Right from that very paragraph your linked to:

Set objects must be implemented using [mechanisms] that, on average, provide access times that are sublinear on the number of elements in the collection.

You will find the same sentence for Maps, WeakMaps and WeakSets.

It looks the ECMA spec mandates that the implementations (e.g. Set.prototype.has) are to use a linear time (O(n)) algorithm.

No:

The data structures used in this Set objects specification is only intended to describe the required observable semantics of Set objects. It is not intended to be a viable implementation model.

The observable semantics are mostly related to the predictable iteration order (which still can be implemented efficient and fast). It is indeed expected by the specification that an implementation uses a hash table or something similar with constant access, though trees (with logarithmic access complexity) are allowed as well.

Answer 2

For anyone who is curious, I did a very quick benchmark:

I'm running node 18.16.0.

This has been edited to include data on strings and deletion as users have pointed out there is a performance difference. However, object is still faster in everything I ran.

const benchmarkMap = size => {
    console.time('benchmarkMap');
    var map = new Map();
    for (var i = 0; i < size; i++) map.set(i, i);
    for (var i = 0; i < size; i++) var x = map.get(i);
    console.timeEnd('benchmarkMap');
}

const benchmarkObj = size => {
    console.time('benchmarkObj');
    var obj = {};
    for (var i = 0; i < size; i++) obj[i] = i;
    for (var i = 0; i < size; i++) var x = obj[i];
    console.timeEnd('benchmarkObj');
}

const benchmarkMapStr = size => {
    console.time('benchmarkMapStr');
    var map = new Map();
    for (var i = 0; i < size; i++) map.set(i.toString(), i);
    for (var i = 0; i < size; i++) var x = map.get(i.toString());
    console.timeEnd('benchmarkMapStr');
}

const benchmarkObjStr = size => {
    console.time('benchmarkObjStr');
    var obj = {};
    for (var i = 0; i < size; i++) obj[i.toString()] = i;
    for (var i = 0; i < size; i++) var x = obj[i.toString()];
    console.timeEnd('benchmarkObjStr');
}

const benchmarkMapDel = size => {
    console.time('benchmarkMapDel');
    var map = new Map();
    for (var i = 0; i < size; i++) map.set(i, i);
    for (var i = 0; i < size; i++) {
        var x = map.get(i);
        map.delete(i);
    }
    console.timeEnd('benchmarkMapDel');
}

const benchmarkObjDel = size => {
    console.time('benchmarkObjDel');
    var obj = {};
    for (var i = 0; i < size; i++) obj[i] = i;
    for (var i = 0; i < size; i++) {
        var x = obj[i];
        delete obj[i];
    }
    console.timeEnd('benchmarkObjDel');
}

var size = 1000000;

benchmarkMap(size);
benchmarkObj(size);
benchmarkMapStr(size);
benchmarkObjStr(size);
benchmarkMapDel(size);
benchmarkObjDel(size);

---

This will yield the following results:

benchmarkMap: 189.425ms
benchmarkObj: 41.519ms
benchmarkMapStr: 263.951ms
benchmarkObjStr: 102.959ms
benchmarkMapDel: 271.904ms
benchmarkObjDel: 102.373ms

Answer 3

The question Is the Set.has() method O(1) and Array.indexOf O(n)? is listed as a duplicate of this one, which it isn't exactly (I've voted to re-open). I'll add these benchmarks here anyway, as the benchmarks on the replies to that question fail to show the full range of differences in performance between Set#has and Array#indexOf.

The following is all true as of Chrome 137:

You find that, for larger datasets, Set#has and Map#has are multiple orders of magnitude faster. Which is pretty consistent with what you'd expect for O(n) vs O(1) operations.

Meanwhile, Object#hasOwnProperty slightly outperforms Set#has and Map#has in all cases.

Benchmarking code

const [small, medium, large] = [1e2, 1e4, 1e6]

const configs = [
    { size: small, iterations: large },
    { size: medium, iterations: medium },
    { size: large, iterations: small },
]

for (const { size, iterations } of configs) {
    let dummyVar

    const arr = Array.from({ length: size }, (_, i) => String(i))
    const obj = Object.fromEntries(arr.map(k => [k, true]))
    const set = new Set(arr)
    const map = new Map(Object.entries(obj))

    const valsToTest = Array.from(
        { length: iterations },
        (_, i) => String(Math.floor(Math.random() * size)),
    )

    const title = `dataset size: ${size.toLocaleString()}; iterations: ${iterations.toLocaleString()}`

    console.log(`\n-> ${title}`)

    for (const [target, method] of [
        [arr, 'indexOf'],
        [arr, 'includes'],
        [set, 'has'],
        [map, 'has'],
        [obj, 'hasOwnProperty'],
    ]) {
        const subtitle = `${target.constructor.name}#${method}`

        console.time(subtitle)

        for (const val of valsToTest) {
            dummyVar = target[method](val)
        }

        console.timeEnd(subtitle)
    }
}

My results (Chrome 137)

-> dataset size: 100; iterations: 1,000,000
Array#indexOf: 161.200ms
Array#includes: 176.600ms
Set#has: 49.600ms
Map#has: 41.200ms
Object#hasOwnProperty: 28.800ms

-> dataset size: 10,000; iterations: 10,000
Array#indexOf: 153.500ms
Array#includes: 144.800ms
Set#has: 0.700ms
Map#has: 0.600ms
Object#hasOwnProperty: 0.400ms

-> dataset size: 1,000,000; iterations: 100
Array#indexOf: 159.100ms
Array#includes: 159.200ms
Set#has: 0.200ms
Map#has: 0.100ms
Object#hasOwnProperty: 0.000ms