JavaScript的简单（非安全）哈希函数？

可能重复：

有人能推荐一个用（浏览器兼容的）JavaScript编写的简单（即几十行代码，而不是几百行）哈希函数吗？理想情况下，我希望在将字符串作为输入传递时，生成类似于32个字符的十六进制字符串的内容，这是MD5、SHA1等的典型输出。它不必是加密安全的，只是能够合理地抵抗冲突。（我最初的使用案例是URL，但我将来可能想在其他字符串上使用它。）

查看此内容。它的BSD许可，非常易于使用。例如：

md5 = hex_md5("message to digest")

---

查看这些实现

• （SHA-1算法）
• （针对SHA-1、MD5、HMAC和其他的实施）

---

有许多用JS编写的哈希函数的实现。例如：
• SHA-1：
• SHA-256：
• MD5：

---

如果您不需要安全性，您也可以使用base64，它不是散列函数，没有固定的输出，可以由用户简单解码，但看起来更轻，可以用于隐藏值：
我自己没有验证过，但您可以看看这个。看起来很短
使用此原型，您只需对任何字符串调用

.hashCode（）

，例如

“some string”.hashCode（）

，并接收数字哈希代码（更具体地说，是Java等效代码），例如1395333309

String.prototype.hashCode=function（）{
var散列=0；
如果（this.length==0）{
返回散列；
}
for（var i=0；i//Sergey.Shuchkin[t]gmail.com创建字符串哈希的简单但不可靠的函数
//警报（strhash（'http://www.w3schools.com/js/default.asp）；/6mn6tf7st333r2q4o134o58888
函数strhash（str）{
如果（str.length%32>0）str+=Array（33-str.length%32）.join（“z”）；
变量散列=''，字节=[]，i=j=k=a=0，dict=['a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'u'，'v'，'w'，'x'，'y'，'1'，'2'，'3'，'4'，'m'，'m'，'n'，'n'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'t'，'u'，'v'，'w'，'w'，'x'，'x'，'y y'，'1'，'2'，'3'，'4'，'5'，'5'，'7'，'9'；
对于（i=0；i

简单对象哈希器：

(function () {
    Number.prototype.toHex = function () {
        var ret = ((this<0?0x8:0)+((this >> 28) & 0x7)).toString(16) + (this & 0xfffffff).toString(16);
        while (ret.length < 8) ret = '0'+ret;
        return ret;
    };
    Object.hashCode = function hashCode(o, l) {
        l = l || 2;
        var i, c, r = [];
        for (i=0; i<l; i++)
            r.push(i*268803292);
        function stringify(o) {
            var i,r;
            if (o === null) return 'n';
            if (o === true) return 't';
            if (o === false) return 'f';
            if (o instanceof Date) return 'd:'+(0+o);
            i=typeof o;
            if (i === 'string') return 's:'+o.replace(/([\\\\;])/g,'\\$1');
            if (i === 'number') return 'n:'+o;
            if (o instanceof Function) return 'm:'+o.toString().replace(/([\\\\;])/g,'\\$1');
            if (o instanceof Array) {
                r=[];
                for (i=0; i<o.length; i++) 
                    r.push(stringify(o[i]));
                return 'a:'+r.join(';');
            }
            r=[];
            for (i in o) {
                r.push(i+':'+stringify(o[i]))
            }
            return 'o:'+r.join(';');
        }
        o = stringify(o);
        for (i=0; i<o.length; i++) {
            for (c=0; c<r.length; c++) {
                r[c] = (r[c] << 13)-(r[c] >> 19);
                r[c] += o.charCodeAt(i) << (r[c] % 24);
                r[c] = r[c] & r[c];
            }
        }
        for (i=0; i<r.length; i++) {
            r[i] = r[i].toHex();
        }
        return r.join('');
    }
}());

（函数（）{
Number.prototype.toHex=函数（）{
var ret=（（this>28）和0x7））.toString（16）+（this&0xfffffff）.toString（16）；
而（ret.length<8）ret='0'+ret；
返回ret；
};
Object.hashCode=函数hashCode（o，l）{
l=l | | 2；
var i，c，r=[]；
对于（i=0；iIs）您不想使用sha1有一个特殊的原因吗？在jsI中有很多这样的例子。我想用一些其他大约50行的代码来打包它；我不希望我的哈希函数是“有趣”的10倍长bits。我想我现在明白你的意思了。你为什么不能使用include？你真的需要只使用一个文件吗？是的，我可以，如果必要的话，我准备这样做，但我更喜欢一些自我包含的东西，我可以在github或类似的网站上发布作为要点。
window.hashJoaat=function（b）{for（var a=0，c=b.length；c--）a+=b.charCodeAt（c），a+=a6；a+=a11；return（（a+（a>0）.toString（16）}；
我已经发现了这一点，它会起作用，但我希望得到更小更简单的东西。另外，“消息摘要”不是
hex_md5（message）
的结果吗？是的摘要，参数是您想要摘要的消息-因此“要摘要的消息”。但无论如何，您希望以哪种方式实现更简单？该实现是一个不到400行的简单JavaScript文件。您只需要一个函数还是什么？这对我来说现在更有意义了；以前您有类似于“fb6cecc85a100197ae3ad68d1f9f2886”的内容“

，对吗？（找不到答案的修订版。）是的，我纠正了。但是你能详细说明一下简单性问题吗：你想用哪种方式来创建一个更简单的库？字符串的base64编码与原始字符串的长度大致相同；我想要一些更短的东西，比如散列。顺便说一句，base64甚至比输入还要长。这个脚本会污染global范围包含以下变量：

j

，

k

，

a

。这是因为它们不是

var

语句的一部分，只是计算为

var i

的表达式的一部分。相反，请使用

var i，j，k，a；i=j=k=a=0；

。是的，JS编写得不好，但它是应用程序ears直接解决OP的问题，并提供示例代码。谢谢！SHA1和MD5的速度慢得离谱。我做了一系列比较测试，结果证明Java的哈希实现速度最快，冲突也最少（在相对统一的数据上）和其他人一样，我也尝试过。非常简短。非常酷！唯一的问题是，这会用非Ecmascript方法污染

字符串的
原型
。我会将其重写为独立函数，可能会将其放在您的util库中。另一件事是，它会创建一个全局变量
I
，因为他忘记了
循环中的var
关键字。但是这些问题很容易解决。微优化：删除
if（this.length==0）{return hash}
块，因为它是冗余的（执行
for
时长度为正，否则默认情况下返回0）。我是否遗漏了什么？在一行：
数组.from（str）。reduce(（hash，char）=>0 |（31*hash+char.charCodeAt（0）），0）
（其中
str
i
// Simple but unreliable function to create string hash by Sergey.Shuchkin [t] gmail.com
// alert( strhash('http://www.w3schools.com/js/default.asp') ); // 6mn6tf7st333r2q4o134o58888888888
function strhash( str ) {
    if (str.length % 32 > 0) str += Array(33 - str.length % 32).join("z");
    var hash = '', bytes = [], i = j = k = a = 0, dict = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','1','2','3','4','5','6','7','8','9'];
    for (i = 0; i < str.length; i++ ) {
        ch = str.charCodeAt(i);
        bytes[j++] = (ch < 127) ? ch & 0xFF : 127;
    }
    var chunk_len = Math.ceil(bytes.length / 32);   
    for (i=0; i<bytes.length; i++) {
        j += bytes[i];
        k++;
        if ((k == chunk_len) || (i == bytes.length-1)) {
            a = Math.floor( j / k );
            if (a < 32)
                hash += '0';
            else if (a > 126)
                hash += 'z';
            else
                hash += dict[  Math.floor( (a-32) / 2.76) ];
            j = k = 0;
        }
    }
    return hash;
}

(function () {
    Number.prototype.toHex = function () {
        var ret = ((this<0?0x8:0)+((this >> 28) & 0x7)).toString(16) + (this & 0xfffffff).toString(16);
        while (ret.length < 8) ret = '0'+ret;
        return ret;
    };
    Object.hashCode = function hashCode(o, l) {
        l = l || 2;
        var i, c, r = [];
        for (i=0; i<l; i++)
            r.push(i*268803292);
        function stringify(o) {
            var i,r;
            if (o === null) return 'n';
            if (o === true) return 't';
            if (o === false) return 'f';
            if (o instanceof Date) return 'd:'+(0+o);
            i=typeof o;
            if (i === 'string') return 's:'+o.replace(/([\\\\;])/g,'\\$1');
            if (i === 'number') return 'n:'+o;
            if (o instanceof Function) return 'm:'+o.toString().replace(/([\\\\;])/g,'\\$1');
            if (o instanceof Array) {
                r=[];
                for (i=0; i<o.length; i++) 
                    r.push(stringify(o[i]));
                return 'a:'+r.join(';');
            }
            r=[];
            for (i in o) {
                r.push(i+':'+stringify(o[i]))
            }
            return 'o:'+r.join(';');
        }
        o = stringify(o);
        for (i=0; i<o.length; i++) {
            for (c=0; c<r.length; c++) {
                r[c] = (r[c] << 13)-(r[c] >> 19);
                r[c] += o.charCodeAt(i) << (r[c] % 24);
                r[c] = r[c] & r[c];
            }
        }
        for (i=0; i<r.length; i++) {
            r[i] = r[i].toHex();
        }
        return r.join('');
    }
}());