Linked list for-of iterator vs plain while loop

Benchmark created on

Setup

/**
 * A mixin class to add linked list functionality to any class.
 */
function Link(BaseClass = class {}) {
    //
    return class Link extends BaseClass {
        next = null;
        prev = null;

        /**
         * Set this to true if the linked list is circular.
         */
        circular = false;

        insertAfter(link) {
            link.unlink(); // remove from previous list if any
            const next = this.next;
            this.next = link;
            link.prev = this;
            link.next = next;
            if (next)
                next.prev = link;
        }
        
        /**
         * Remove this Link from the linked list.
         */
        unlink() {
            const nextLink = this.next;
            const prevLink = this.prev;
            this.next = this.circular ? this : null;
            this.prev = this.circular ? this : null;
            if (prevLink) prevLink.next = nextLink;
            if (nextLink) nextLink.prev = prevLink;
        }

        /**
         * Returns an iterator for iterating over all Links in th linked list.
         *
         * @param forward - True to iterate forward, false to iterate backward.
         *
         * @param check - True to check for circularity (throws if not
         * circular), false to skip.
         */
        *links(forward = true, check = true) {
            let link = this;
            let next;
            let prev;
            let i = 0;

            do {
                if (!link)
                    throw new NonCircularError();
                next = link.next;
                prev = link.prev;
                
                yield [link, i++];
            } while ((link = forward ? next : prev) != this && (this.circular ? check || (!check && link) : link));
        }
        *linksReverse(check = true) {
            yield* this.links(false, check);
        }
        
        [Symbol.iterator] = this.links;
    };
}
class NonCircularError extends Error {
    constructor() {
        super('Expected linked list to be circular.');
    }
}

class MyLink extends Link() {
	next = this // circular
	prev = this // circular
	circular = true
}

let lastLink

for (const _ of Array.from({length: 100000})) {
	const link = new MyLink()
	lastLink?.insertAfter(link)
	lastLink = link
}

const startLink = lastLink.next

Test runner

Ready to run.

Testing in
TestOps/sec
for-of
for (const [link] of startLink) {
	globalThis.window
}
ready
while loop
let link = startLink
do {
	globalThis.window
} while ((link = link.next) !== startLink)
ready

Revisions

You can edit these tests or add more tests to this page by appending /edit to the URL.