我需要将字符串转换为某种形式的哈希。这在JavaScript中可行吗？
我没有使用服务器端语言，所以我不能这样做。
String.prototype.hashCode = function() {
var hash = 0, i, chr;
if (this.length === 0) return hash;
for (i = 0; i < this.length; i++) {
chr = this.charCodeAt(i);
hash = ((hash << 5) - hash) + chr;
hash |= 0; // Convert to 32bit integer
}
return hash;
};
资料来源：http://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
我需要一个类似的功能（但不同）来根据用户名和当前时间生成唯一ID。所以：
window.newId = ->
# create a number based on the username
unless window.userNumber?
window.userNumber = 0
for c,i in window.MyNamespace.userName
char = window.MyNamespace.userName.charCodeAt(i)
window.MyNamespace.userNumber+=char
((window.MyNamespace.userNumber + Math.floor(Math.random() * 1e15) + new Date().getMilliseconds()).toString(36)).toUpperCase()
生产：
2DVFXJGEKL
6IZPAKFQFL
ORGOENVMG
... etc
编辑2015年6月：对于新代码我使用shortid：https://www.npmjs.com/package/shortid
一个快速简洁的改编自here：
String.prototype.hashCode = function() {
var hash = 5381, i = this.length
while(i)
hash = (hash * 33) ^ this.charCodeAt(--i)
return hash >>> 0;
}
我基于FNV的Multiply+Xor方法的快速（非常长）单线程：
my_string.split('').map(v=>v.charCodeAt(0)).reduce((a,v)=>a+((a<<7)+(a<<3))^v).toString(16);
我结合了两个解决方案（用户esmiralha和lordvlad）来获得一个功能，对于支持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();
如果你想避免碰撞，你可能想要使用像secure hash这样的SHA-256。有几种JavaScript SHA-256实现。
我编写了测试来比较几个哈希实现，请参阅https://github.com/brillout/test-javascript-hash-implementations。
或者去http://brillout.github.io/test-javascript-hash-implementations/，进行测试。
我有点迟到了，但你可以使用这个模块：crypto：
const crypto = require('crypto');
const SALT = '$ome$alt';
function generateHash(pass) {
return crypto.createHmac('sha256', SALT)
.update(pass)
.digest('hex');
}
这个函数的结果总是64字符串;像这样的东西："aa54e7563b1964037849528e7ba068eb7767b1fab74a8d80fe300828b996714a"
我找到了转换为十六进制字符串的char代码的简单连接。这用于相对狭窄的目的，即仅需要与服务器端交换的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('');
}
使用Underscore可以使这更简洁，更容易浏览。例：
"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中使用算法，但是你想要多样化并延长散列。
@ esmiralha答案的略微简化版本。
我不会在此版本中覆盖String，因为这可能会导致一些不良行为。
function hashCode(str) {
var hash = 0;
for (var i = 0; i < str.length; i++) {
hash = ~~(((hash << 5) - hash) + str.charCodeAt(i));
}
return hash;
}
添加这个是因为还没有人这样做，这似乎被要求并用哈希实现了很多，但它总是做得很差......
这需要一个字符串输入，以及希望哈希值相等的最大数字，并根据字符串输入生成一个唯一的数字。
您可以使用它来为图像数组生成唯一索引（如果您想为用户返回特定的头像，随机选择，也可以根据其名称选择，因此它将始终分配给具有该名称的人）。
当然，您也可以使用它将索引返回到颜色数组中，例如根据某人的名称生成唯一的头像背景颜色。
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);
}
我没有使用服务器端语言，所以我不能这样做。
你确定你不能这样做吗？
你有没有忘记你正在使用Javascript，这种语言不断发展？
试试SubtleCrypto。它支持SHA-1，SHA-128，SHA-256和SHA-512哈希函数。
async function hash(message/*: string */) {
const text_encoder = new TextEncoder;
const data = text_encoder.encode(message);
const message_digest = await window.crypto.subtle.digest("SHA-512", data);
return message_digest;
} // -> ArrayBuffer
function in_hex(data/*: ArrayBuffer */) {
const octets = new Uint8Array(data);
const hex = [].map.call(octets, octet => octet.toString(16).padStart(2, "0")).join("");
return hex;
} // -> string
(async function demo() {
console.log(in_hex(await hash("Thanks for the magic.")));
})();编辑
基于我的jsperf测试，接受的答案实际上更快：http://jsperf.com/hashcodelordvlad
原版的
如果有人感兴趣，这里有一个改进的（更快）版本，在缺少reduce数组功能的旧浏览器上会失败。
hashCode = function(s){
return s.split("").reduce(function(a,b){a=((a<<5)-a)+b.charCodeAt(0);return a&a},0);
}
我认为没有任何理由使用这种过于复杂的加密代码而不是现成的解决方案，如对象哈希库等。依赖供应商可以提高工作效率，节省时间并降低维护成本。
只需使用https://github.com/puleos/object-hash
var hash = require('object-hash');
hash({foo: 'bar'}) // => '67b69634f9880a282c14a0f0cb7ba20cf5d677e9'
hash([1, 2, 2.718, 3.14159]) // => '136b9b88375971dff9f1af09d7356e3e04281951'
注意：即使使用最佳的32位散列，也会迟早发生冲突。
哈希冲突概率可以计算为（see here）。这可能高于直觉建议： 假设32位散列和k = 10,000项，将发生碰撞，概率为1.2％。对于77,163个样本，概率变为50％！ （calculator）。 我建议在底部找到解决方法。
在回答这个问题Which hashing algorithm is best for uniqueness and speed?时，Ian Boyd发布了一个很好的in depth analysis。简而言之（正如我所解释的那样），他得出的结论是Murmur是最好的，其次是FNV-1a。 esmiralha提出的Java的String.hashCode（）算法似乎是DJB2的变种。
这里有一些带有大输入字符串的基准：http://jsperf.com/32-bit-hash 当短输入字符串被散列时，murmur的性能相对于DJ2B和FNV-1a而下降：http://jsperf.com/32-bit-hash/3
所以一般来说我会推荐murmur3。 请参阅此处获取JavaScript实现：https://github.com/garycourt/murmurhash-js
如果输入字符串很短并且性能比分发质量更重要，请使用DJB2（由esmiralha接受的答案提出）。
如果质量和小代码大小比速度更重要，我使用FNV-1a的实现（基于this code）。
/**
* Calculate a 32 bit FNV-1a hash
* Found here: https://gist.github.com/vaiorabbit/5657561
* Ref.: http://isthe.com/chongo/tech/comp/fnv/
*
* @param {string} str the input value
* @param {boolean} [asString=false] set to true to return the hash value as
* 8-digit hex string instead of an integer
* @param {integer} [seed] optionally pass the hash of the previous chunk
* @returns {integer | string}
*/
function hashFnv32a(str, asString, seed) {
/*jshint bitwise:false */
var i, l,
hval = (seed === undefined) ? 0x811c9dc5 : seed;
for (i = 0, l = str.length; i < l; i++) {
hval ^= str.charCodeAt(i);
hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
}
if( asString ){
// Convert to 8 digit hex string
return ("0000000" + (hval >>> 0).toString(16)).substr(-8);
}
return hval >>> 0;
}
提高碰撞概率
As explained here，我们可以使用这个技巧扩展哈希位大小：
function hash64(str) {
var h1 = hash32(str); // returns 32 bit (as 8 byte hex string)
return h1 + hash32(h1 + str); // 64 bit (as 16 byte hex string)
}
小心使用它，但不要期望太多。
基于ES6中的accepted answer。更小，可维护，适用于现代浏览器。
function hashCode(str) {
return str.split('').reduce((prevHash, currVal) =>
(((prevHash << 5) - prevHash) + currVal.charCodeAt(0))|0, 0);
}
// Test
console.log("hashCode(\"Hello!\"): ", hashCode('Hello!'));如果它可以帮助任何人，我将前两个答案组合成一个较旧的浏览器容忍版本，如果reduce可用则使用快速版本，如果不是，则回退到esmiralha的解决方案。
/**
* @see http://stackoverflow.com/q/7616461/940217
* @return {number}
*/
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);
}
var hash = 0;
if (this.length === 0) return hash;
for (var i = 0; i < this.length; i++) {
var character = this.charCodeAt(i);
hash = ((hash<<5)-hash)+character;
hash = hash & hash; // Convert to 32bit integer
}
return hash;
}
用法如下：
var hash = new String("some string to be hashed").hashCode();
这是一个精致且性能更好的变体：
String.prototype.hashCode = function() {
var hash = 0, i = 0, len = this.length;
while ( i < len ) {
hash = ((hash << 5) - hash + this.charCodeAt(i++)) << 0;
}
return hash;
};
这与Java的标准object.hashCode()的实现相匹配
这里也只返回正的哈希码：
String.prototype.hashcode = function() {
return (this.hashCode() + 2147483647) + 1;
};
这是一个匹配的Java，只返回正的哈希码：
public static long hashcode(Object obj) {
return ((long) obj.hashCode()) + Integer.MAX_VALUE + 1l;
}
请享用！
我有点惊讶没有人谈论过新的SubtleCrypto API。
要从字符串中获取哈希，可以使用subtle.digest方法：
function getHash(str, algo = "SHA-256") {
let strBuf = new TextEncoder('utf-8').encode(str);
return crypto.subtle.digest(algo, strBuf)
.then(hash => {
window.hash = hash;
// here hash is an arrayBuffer,
// so we'll connvert it to its hex version
let result = '';
const view = new DataView(hash);
for (let i = 0; i < hash.byteLength; i += 4) {
result += ('00000000' + view.getUint32(i).toString(16)).slice(-8);
}
return result;
});
}
getHash('hello world')
.then(hash => {
console.log(hash);
});几乎一半的答案是Java的String.hashCode的实现，这既不是高质量也不是超快。这没什么特别的，每次只增加31倍。它可以在一行中高效实现，并且使用Math.imul更快：
const hashstr=s=>{for(var i=h=0;i<s.length;i++)h=Math.imul(31,h)+s.charCodeAt(i)|0;return h}
所以这里有一些不同的东西 - 一个简单，分布均匀的53位哈希。与任何32位散列相比，它速度非常快，提供了更高质量的散列，并且具有更低的冲突率。
const cyrb53 = function(str, seed = 0) {
let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
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);
}
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);
};
它使用类似于xxHash / MurmurHash3的技术，但不是那么彻底。它实现了雪崩（非严格），因此输入中的微小变化会使输出发生很大变化，使其看起来是随机的：
0xc2ba782c97901 = cyrb53("a")
0xeda5bc254d2bf = cyrb53("b")
0xe64cc3b748385 = cyrb53("revenge")
0xd85148d13f93a = cyrb53("revenue")
您还可以为相同输入的备用流提供种子：
0xee5e6598ccd5c = cyrb53("revenue", 1)
0x72e2831253862 = cyrb53("revenue", 2)
0x0de31708e6ab7 = cyrb53("revenue", 3)
从技术上讲，它是一个64位散列（并行两个不相关的32位散列），但JavaScript仅限于53位整数。通过改变十六进制字符串或数组的返回行，仍然可以使用完整的64位：
return (h2>>>0).toString(16).padStart(8,0)+(h1>>>0).toString(16).padStart(8,0);
// or
return [h2>>>0, h1>>>0];
问题是，构造十六进制字符串成为性能瓶颈，数组需要两个比较运算符而不是一个，这不方便。因此，在将其用于高性能应用程序时请记住这一点。
而且只是为了好玩，这里有89个字符的最小32位散列，仍然比FNV / DJB2 / SMDB好：
TSH=s=>{for(var i=0,h=6;i<s.length;)h=Math.imul(h^s.charCodeAt(i++),9**9);return h^h>>>9}
多亏了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);
}