函数hashCode（str）{return str.split（“”）.reduce（（prevHash，currVal）=>（（（prevHash<<5）-previvHash）+currVal.charCodeAt（0））|0，0）；}//测试console.log（“hashCode（\“Hello！\”）：“，hashCode（'Hello！'））；

我将这两种解决方案（用户esmiralha和lordflad）结合在一起，得到了一个对于支持js函数reduce（）并且仍然兼容旧浏览器的浏览器来说应该更快的函数：

String.prototype.hashCode = function() {

    if (Array.prototype.reduce) {
        return this.split("").reduce(function(a,b){a=((a<<5)-a)+b.charCodeAt(0);return a&a},0);   
    } else {

        var hash = 0, i, chr, len;
        if (this.length == 0) return hash;
        for (i = 0, len = this.length; i < len; i++) {
        chr   = this.charCodeAt(i);
        hash  = ((hash << 5) - hash) + chr;
        hash |= 0; // Convert to 32bit integer
        }
        return hash;
    }
};

例子：

my_string = 'xyz';
my_string.hashCode();

得益于mar10的示例，我找到了一种在C#和Javascript中为FNV-1a获得相同结果的方法。如果存在unicode字符，为了提高性能，将放弃上面的部分。不知道为什么在哈希时维护这些路径会很有用，因为我现在只哈希url路径。

C#版本

private static readonly UInt32 FNV_OFFSET_32 = 0x811c9dc5;   // 2166136261
private static readonly UInt32 FNV_PRIME_32 = 0x1000193;     // 16777619

// Unsigned 32bit integer FNV-1a
public static UInt32 HashFnv32u(this string s)
{
    // byte[] arr = Encoding.UTF8.GetBytes(s);      // 8 bit expanded unicode array
    char[] arr = s.ToCharArray();                   // 16 bit unicode is native .net 

    UInt32 hash = FNV_OFFSET_32;
    for (var i = 0; i < s.Length; i++)
    {
        // Strips unicode bits, only the lower 8 bits of the values are used
        hash = hash ^ unchecked((byte)(arr[i] & 0xFF));
        hash = hash * FNV_PRIME_32;
    }
    return hash;
}

// Signed hash for storing in SQL Server
public static Int32 HashFnv32s(this string s)
{
    return unchecked((int)s.HashFnv32u());
}

JavaScript版本

var utils = utils || {};

utils.FNV_OFFSET_32 = 0x811c9dc5;

utils.hashFnv32a = function (input) {
    var hval = utils.FNV_OFFSET_32;

    // Strips unicode bits, only the lower 8 bits of the values are used
    for (var i = 0; i < input.length; i++) {
        hval = hval ^ (input.charCodeAt(i) & 0xFF);
        hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
    }

    return hval >>> 0;
}

utils.toHex = function (val) {
    return ("0000000" + (val >>> 0).toString(16)).substr(-8);
}

这里是一个紧凑的ES6友好可读片段

const stringHashCode = str => {
  let hash = 0
  for (let i = 0; i < str.length; ++i)
    hash = Math.imul(31, hash) + str.charCodeAt(i)

  return hash | 0
}

我尝试了将字符代码转换为十六进制字符串的简单串联。这有一个相对狭窄的目的，即只需要与服务器端交换SHORT字符串（例如标题、标签）的哈希表示，因为不相关的原因，服务器端无法轻松实现接受的hashCode Java端口。显然，这里没有安全应用程序。

String.prototype.hash = function() {
  var self = this, range = Array(this.length);
  for(var i = 0; i < this.length; i++) {
    range[i] = i;
  }
  return Array.prototype.map.call(range, function(i) {
    return self.charCodeAt(i).toString(16);
  }).join('');
}

这可以通过Undercore变得更加简洁和浏览器宽容。例子：

"Lorem Ipsum".hash()
"4c6f72656d20497073756d"

我想，如果你想以类似的方式对更大的字符串进行散列，你可以减少字符代码并对结果进行十六进制，而不是将单个字符连接在一起：

String.prototype.hashLarge = function() {
  var self = this, range = Array(this.length);
  for(var i = 0; i < this.length; i++) {
    range[i] = i;
  }
  return Array.prototype.reduce.call(range, function(sum, i) {
    return sum + self.charCodeAt(i);
  }, 0).toString(16);
}

'One time, I hired a monkey to take notes for me in class. I would just sit back with my mind completely blank while the monkey scribbled on little pieces of paper. At the end of the week, the teacher said, "Class, I want you to write a paper using your notes." So I wrote a paper that said, "Hello! My name is Bingo! I like to climb on things! Can I have a banana? Eek, eek!" I got an F. When I told my mom about it, she said, "I told you, never trust a monkey!"'.hashLarge()
"9ce7"

当然，与此方法冲突的风险更大，尽管您可以在reduce中摆弄算法，但您希望多样化并延长哈希。

添加这一点是因为还没有人这样做，而这似乎是用哈希来要求和实现的，但它总是做得很糟糕。。。

这需要一个字符串输入和您希望哈希值相等的最大值，并根据字符串输入生成一个唯一的数字。

您可以使用它来生成图像数组中的唯一索引（如果您希望为用户返回一个特定的化身，该化身是随机选择的，但也是基于其名称选择的，因此它将始终分配给具有该名称的人）。

当然，您也可以使用它将索引返回到颜色数组中，例如根据某人的姓名生成独特的化身背景颜色。

function hashInt (str, max = 1000) {
    var hash = 0;
    for (var i = 0; i < str.length; i++) {
      hash = ((hash << 5) - hash) + str.charCodeAt(i);
      hash = hash & hash;
    }
    return Math.round(max * Math.abs(hash) / 2147483648);
}