手动实现 String.GetHashCode()？ [复制]

Question

我们有一个用 .NET 编写的遗留系统，我们正在将其迁移到 Node.js。

原系统使用("some string value").GetHashCode()根据用户数据生成一些token。

我正在寻找一种在 JavaScript 中实现此功能的方法，以便将系统的这一部分移植到 Node.js。

因此，我对String.GetHashCode() 的实际工作方式很感兴趣。某处有记录的算法吗？它甚至是一种稳定的算法，还是会在各种 .NET 版本中发生变化？

我试图找到有关它的实现的一些细节，但这对我来说真的很难，因为 .NET 不是我的主要技术，而且我并不真正熟悉它的资源和信息来源。

Answer 1

取自微软的Reference Source，一种实现是：

        // Gets a hash code for this string.  If strings A and B are such that A.Equals(B), then
        // they will return the same hash code.
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public override int GetHashCode() {

#if FEATURE_RANDOMIZED_STRING_HASHING
            if(HashHelpers.s_UseRandomizedStringHashing)
            {
                return InternalMarvin32HashString(this, this.Length, 0);
            }
#endif // FEATURE_RANDOMIZED_STRING_HASHING

            unsafe {
                fixed (char *src = this) {
                    Contract.Assert(src[this.Length] == '\0', "src[this.Length] == '\\0'");
                    Contract.Assert( ((int)src)%4 == 0, "Managed string should start at 4 bytes boundary");

#if WIN32
                    int hash1 = (5381<<16) + 5381;
#else
                    int hash1 = 5381;
#endif
                    int hash2 = hash1;

#if WIN32
                    // 32 bit machines.
                    int* pint = (int *)src;
                    int len = this.Length;
                    while (len > 2)
                    {
                        hash1 = ((hash1 << 5) + hash1 + (hash1 >> 27)) ^ pint[0];
                        hash2 = ((hash2 << 5) + hash2 + (hash2 >> 27)) ^ pint[1];
                        pint += 2;
                        len  -= 4;
                    }

                    if (len > 0)
                    {
                        hash1 = ((hash1 << 5) + hash1 + (hash1 >> 27)) ^ pint[0];
                    }
#else
                    int     c;
                    char *s = src;
                    while ((c = s[0]) != 0) {
                        hash1 = ((hash1 << 5) + hash1) ^ c;
                        c = s[1];
                        if (c == 0)
                            break;
                        hash2 = ((hash2 << 5) + hash2) ^ c;
                        s += 2;
                    }
#endif
#if DEBUG
                    // We want to ensure we can change our hash function daily.
                    // This is perfectly fine as long as you don't persist the
                    // value from GetHashCode to disk or count on String A 
                    // hashing before string B.  Those are bugs in your code.
                    hash1 ^= ThisAssembly.DailyBuildNumber;
#endif
                    return hash1 + (hash2 * 1566083941);
                }
            }
        }

这在 .NET 版本之间不稳定，并且从分散在 string.cs 源代码周围的 cmets 来看，它甚至可能在同一进程内的跨 AppDomain 之间不稳定。

如果您想要一个真实、稳定的哈希码，可以“安全”地保存在 AppDomain 之外，请查看 System.Security.Cryptography 中的哈希函数。 MD5 对于低安全性工作是可以接受的，SHAx 的风格更好。

真正的哈希只是一种方法，不可能真正反转哈希，因为它是一个“有损”的过程。如果从您那里获得代码的开发人员声称他们可以反转哈希，那么他们要么是在撒谎，要么是错误的，或者没有实现正确的哈希。

Answer 2

添加to Bradley's answer 这是一个基于String.GetHashCode() 的64 位实现的稳定哈希码，它没有使用我不久前为回答而写的不安全代码。

public static class StringExtensionMethods
{
    public static int GetStableHashCode(this string str)
    {
        unchecked
        {
            int hash1 = 5381;
            int hash2 = hash1;

            for(int i = 0; i < str.Length && str[i] != '\0'; i += 2)
            {
                hash1 = ((hash1 << 5) + hash1) ^ str[i];
                if (i == str.Length - 1 || str[i+1] == '\0')
                    break;
                hash2 = ((hash2 << 5) + hash2) ^ str[i+1];
            }

            return hash1 + (hash2*1566083941);
        }
    }
}