Создание хэша из строки в Javascript

Мне нужно преобразовать строки в какую-либо форму хэша. Возможно ли это в JavaScript?

Я не использую серверный язык, поэтому я не могу этого сделать.

Ответ 1

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/

Ответ 2

ИЗМЕНИТЬ

на основе моих тестов 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);              
}

Ответ 3

Примечание: Даже с лучшим 32-битным хешем столкновения рано или поздно произойдут.

Вероятность коллизии хеша может быть рассчитана как , приблизительно как (смотрите здесь). Это может быть выше, чем предполагает интуиция:
Предполагая 32-битный хэш и k = 10000 элементов, коллизия произойдет с вероятностью 1,2%. Для 77 163 выборок вероятность становится 50%! (калькулятор).
Я предлагаю обходной путь внизу.

В ответе на этот вопрос Какой алгоритм хеширования лучше всего подходит для уникальности и скорости?, Ян Бойд опубликовал хороший углубленный анализ. Короче говоря (насколько я понимаю) он приходит к выводу, что Murmur лучше, а затем FNV-1a.
Алгоритм Javas String.hashCode(), предложенный Эсмиралхой, кажется вариантом DJB2.

FNV-1a имеет лучшее распределение, чем DJB2, но медленнее
DJB2 быстрее, чем FNV-1a, но имеет тенденцию вызывать больше коллизий
MurmurHash3 лучше и быстрее, чем DJB2 и FNV-1a (но оптимизированная реализация требует больше строк кода, чем FNV и DJB2)

Некоторые тесты с большими входными строками здесь: http://jsperf.com/32-bit-hash
При хешировании коротких входных строк производительность шума снижается по сравнению с DJ2B и FNV-1a: http://jsperf.com/32-bit-hash/3

В общем, я бы порекомендовал murmur3.
Смотрите здесь для реализации JavaScript: https://github.com/garycourt/murmurhash-js

Если входные строки короткие и производительность важнее качества распространения, используйте DJB2 (как предложено в принятом ответе esmiralha).

Если качество и небольшой размер кода важнее скорости, я использую эту реализацию FNV-1a (на основе этого кода).

/**
 * 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;
}

Повышение вероятности столкновения

Как объясняется здесь, мы можем расширить размер хеш-бита с помощью этого трюка:

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)
}

Используйте его с осторожностью и не ожидайте слишком многого.

Ответ 4

На основании принятого ответа в ES6. Меньше, поддерживается и работает в современных браузерах.

function hashCode(str) {
  return str.split('').reduce((prevHash, currVal) =>
    (((prevHash << 5) - prevHash) + currVal.charCodeAt(0))|0, 0);
}

// Test
console.log("hashCode(\"Hello!\"): ", hashCode('Hello!'));

Ответ 5

Если это кому-то помогает, я объединил два верхних ответа в версии с более старым браузером, которая использует быструю версию, если 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();

Ответ 6

Почти половина ответов - реализации Java String.hashCode, который не является ни качественным, ни супер быстрым. Ничего особенного, просто умножается на 31 каждый раз. Он может быть эффективно реализован в одну строку и намного быстрее с Math.imul:

var jhashcode=s=>{for(var i=0,h;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];

Суть в том, что построение шестнадцатеричной строки становится узким местом в производительности, и массиву нужны два оператора сравнения вместо одного, что не так удобно. Так что имейте это в виду, когда используете его для высокопроизводительных приложений.

И просто для удовольствия, здесь минимальный 32-битный хэш в 88 символов, который все еще превосходит 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}

Ответ 7

Это усовершенствованный и более эффективный вариант:

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;
}

Наслаждайтесь!

Ответ 8

Я немного удивлен, что никто не говорил о новом API SubtleCrypto.

Чтобы получить хэш из строки, вы можете использовать метод 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);
  });

Ответ 9

Благодаря примеру mar10, я нашел способ получить те же результаты в С# и Javascript для FNV-1a. Если присутствуют символы Unicode, верхняя часть отбрасывается ради производительности. Не знаю, почему было бы полезно поддерживать их при хешировании, так как теперь я только хэширую URL-адреса.

Версия С#

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);
}

Ответ 10

Мне нужна была подобная функция (но другая) для создания уникального идентификатора на основе имени пользователя и текущего времени. Итак:

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

edit Jun 2015: для нового кода я использую shortid: https://www.npmjs.com/package/shortid

Ответ 11

Быстрая и краткая, которая была адаптирована отсюда:

String.prototype.hashCode = function() {
  var hash = 5381, i = this.length
  while(i)
    hash = (hash * 33) ^ this.charCodeAt(--i)
  return hash >>> 0;
}

Ответ 12

Мой быстрый (очень длинный) один вкладыш на основе метода FNV Multiply+Xor:

my_string.split('').map(v=>v.charCodeAt(0)).reduce((a,v)=>a+((a<<7)+(a<<3))^v).toString(16);

Ответ 13

Я объединил два решения (пользователи esmiralha и lordvlad), чтобы получить функцию, которая должна быть быстрее для браузеров, поддерживающих js-функцию уменьшить() и по-прежнему совместимую со старыми браузерами:

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();

Ответ 14

Если вы хотите избежать столкновений, вы можете использовать безопасный хэш, например SHA-256. Существует несколько реализаций JavaScript SHA-256.

Я написал тесты для сравнения нескольких реализаций хеширования, см. https://github.com/brillout/test-javascript-hash-implementations.

Или зайдите в http://brillout.github.io/test-javascript-hash-implementations/, чтобы запустить тесты.

Ответ 15

Я немного опаздываю на вечеринку, но вы можете использовать этот модуль: crypto:

const crypto = require('crypto');

const SALT = '$ome$alt';

function generateHash(pass) {
  return crypto.createHmac('sha256', SALT)
    .update(pass)
    .digest('hex');
}

Результат этой функции всегда составляет 64 символа; что-то вроде этого: "aa54e7563b1964037849528e7ba068eb7767b1fab74a8d80fe300828b996714a"

Ответ 16

Я пошел для простой конкатенации кодов char, преобразованных в шестнадцатеричные строки. Это относится к относительно узкой цели, а именно простому хэш-представлению короткой строки (например, заголовков, тегов), которая должна быть обменена с серверной стороной, которая по не соответствующим причинам не может легко реализовать принятый порт Java hashCode. Очевидно, что здесь нет приложения безопасности.

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"

Я предполагаю, что если бы вы хотели использовать более строгие строки с таким же образом, вы могли бы просто уменьшить коды char и исправить итоговую сумму, а не объединить отдельные символы вместе:

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"

Естественно больше риск столкновения с этим методом, хотя вы могли бы играть с арифметикой в сокращении, однако вы хотели разнообразить и удлинить хэш.

Ответ 17

Немного упрощенная версия ответа @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;
}

Ответ 18

С помощью этого решения мы можем указать набор символов, чтобы избежать некоторых проблем, когда значения сохраняются или передаются между уровнями приложений, например: Когда результирующая строка (хеш) производит процентное кодирование и эта строка отправляется контроллеру с использованием метода GET из уровня представления.

function doHashCode() {
    String.prototype.hashCode = function () {
        var text = "";
        var possible = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

        for (var i = 0; i < 15; i++)
            text += possible.charAt(Math.floor(Math.random() * possible.length));
        return text;
    }

    var hash = new String().hashCode();
    $('#input-text-hash').val(hash); // your html input text

}

Ответ 19

Добавление этого, потому что никто еще этого не сделал, и, кажется, об этом много просят и реализуют с помощью хэшей, но это всегда делалось очень плохо...

Он принимает строковый ввод и максимальное число, которое вы хотите, чтобы хеш равнялся, и генерирует уникальное число на основе строкового ввода.

Вы можете использовать это для создания уникального индекса в массиве изображений (если вы хотите вернуть определенный аватар для пользователя, выбранный случайным образом, но также выбранный на основе его имени, поэтому он всегда будет назначен кому-то с таким именем).

Вы также можете использовать это, конечно, для возврата индекса в массив цветов, например, для генерации уникальных фоновых цветов аватара на основе чьего-либо имени.

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);
}

Ответ 20

SubtleCrypto.digest

Я не использую серверный язык, поэтому я не могу сделать это таким образом.

Вы уверены, что не можете сделать это таким образом?

Вы забыли, что используете 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.")));
})();

Ответ 21

Я не вижу причин использовать этот слишком сложный криптографический код вместо готовых к использованию решений, таких как библиотека объектных хэшей и т.д., Полагаясь на поставщика, более продуктивно, экономит время и снижает затраты на обслуживание.

Просто используйте https://github.com/puleos/object-hash

var hash = require('object-hash');

hash({foo: 'bar'}) // => '67b69634f9880a282c14a0f0cb7ba20cf5d677e9'
hash([1, 2, 2.718, 3.14159]) // => '136b9b88375971dff9f1af09d7356e3e04281951'