Hashing for objects and lists

[hasenj]

Today I was looking for a way to hash objects in Javascript in order to be able to use objects as keys to hashmaps

I found the cyrb53 hash on StackOverflow.

I liked the idea and tried to extend it to hash not just strings but anything.

I basically noticed the function is split into 3 parts: init, digest, sum

    // ======== init ==========
    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;

    // ======= digest =========
    for (let i = 0, ch; i < str.length; i++) {
        ch = str.charCodeAt(i);
        h1 = Math.imul(h1 ^ ch, 2654435761);
        h2 = Math.imul(h2 ^ ch, 1597334677);
    }

    // ===== sum / finalize =====
    h1 = Math.imul(h1 ^ (h1>>>16), 2246822507) ^ Math.imul(h2 ^ (h2>>>13), 3266489909);
    h2 = Math.imul(h2 ^ (h2>>>16), 2246822507) ^ Math.imul(h1 ^ (h1>>>13), 3266489909);
    return 4294967296 * (2097151 & h2) + (h1>>>0);

I wanted to extend the "digest" part to not only digest strings but also numbers, booleans, and ojects/arrays composed of such.

Here's my first iteration. I started using it and it seems to be working fine (for now anyway)

https://gist.github.com/hasenj/b2f294593f5de4c8c965b83f79eef73b

But in all honesty hashing is something I hardly know anything about. So I'd love some feedback.

// based on cyrb53
// can be used to hash an object or a list
// must always be composed of numbers, booleans, or strings.
// not supported: function, bigint, symbol
export function hashAny(input: any, seed = 0): number {
    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
    function digest(ch: number) {
        h1 = Math.imul(h1 ^ ch, 2654435761);
        h2 = Math.imul(h2 ^ ch, 1597334677);
    }

    function digestString(str: string) {
        for (let i = 0; i < str.length; i++) {
            let ch = str.charCodeAt(i);
            digest(ch)
        }
    }
    function digestObject(obj: any) {
        let keys = Object.keys(obj);
        keys.sort();
        for (let k of keys) {
            digestString(k)
            digestAny(obj[k])
        }
    }
    function digestArray(arr: any[]) {
        for (let i = 0; i < arr.length; i++) {
            digest(i);
            digestAny(arr[i])
        }
    }

    // type consts to identify nulls, etc
    const NUM = 1;
    const BOOL = 2;
    const STRING = 3;
    const ARRAY = 4;
    const OBJECT = 5;
    const NULL = 6;
    const UNDEFINED = 7;

    function digestAny(obj: any) {
        switch (typeof obj) {
            case 'number':
                digest(NUM);
                digest(obj);
                break;
            case 'boolean':
                digest(BOOL);
                digest(obj ? 1 : 0);
                break;
            case 'string':
                digest(STRING);
                digestString(obj);
                break;
            case 'object':
                if (obj === null) {
                    digest(NULL);
                } else if (Array.isArray(obj)) {
                    digest(ARRAY);
                    digestArray(obj);
                } else {
                    digest(OBJECT);
                    digestObject(obj);
                }
                break;
            case 'undefined':
                digest(UNDEFINED);
                break;
            default:
                throw 'Unexpected type'
        }
    }

    digestAny(input);

    h1 = Math.imul(h1 ^ (h1>>>16), 2246822507) ^ Math.imul(h2 ^ (h2>>>13), 3266489909);
    h2 = Math.imul(h2 ^ (h2>>>16), 2246822507) ^ Math.imul(h1 ^ (h1>>>13), 3266489909);
    return 4294967296 * (2097151 & h2) + (h1>>>0);
}