Benchmark: string-hashcode - MeasureThat.net

Script Preparation code:

function hashCode1(str){
  var hash = 0;
  if (str.length == 0) return hash;
  for (i = 0; i < str.length; i++) {
    char = str.charCodeAt(i);
    hash = ((hash<<5)-hash)+char;
    hash = hash & hash; // Convert to 32bit integer
  }
  return hash;
}

function hashCode2(str) {
  var hash = 0, i, chr;
  if (str.length === 0) return hash;
  for (i = 0; i < str.length; i++) {
    chr   = str.charCodeAt(i);
    hash  = ((hash << 5) - hash) + chr;
    hash |= 0; // Convert to 32bit integer
  }
  return hash;
};

function hashCode3(str) {
  var hash = 5381,
      i    = str.length;

  while(i) {
    hash = (hash * 33) ^ str.charCodeAt(--i);
  }
  return hash >>> 0;
}

Tests:

hashCode1
hashCode1('qwerty')
hashCode2
hashCode2('qwerty')
hashCode3
hashCode3('qwerty')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
hashCode1
hashCode2
hashCode3

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
hashCode1	577716.1 Ops/sec
hashCode2	12134375.0 Ops/sec
hashCode3	12714440.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared, and other considerations.

**Benchmark Definition**

The benchmark definition represents three different hash functions: `hashCode1`, `hashCode2`, and `hashCode3`. These functions take a string input and return a 32-bit integer hash code. The goal is to compare the performance of these three implementations.

**Hash Functions**

1. **`hashCode1(str)`**:
	* This function uses a simple iterative approach, shifting and adding characters to generate the hash code.
	* Pros: Easy to understand and implement.
	* Cons: May be slow due to repeated shifts and additions.
2. **`hashCode2(str)`**:
	* Similar to `hashCode1`, but with some minor differences in variable names and bitwise operations.
	* Pros: Possibly slightly faster than `hashCode1` due to optimized bit manipulation.
	* Cons: Similar limitations as `hashCode1`.
3. **`hashCode3(str)`**:
	* This function uses a more complex iterative approach, multiplying the hash code by 33 and XORing it with character codes.
	* Pros: Potentially faster than the first two implementations due to optimized multiplication and XOR operations.
	* Cons: More difficult to understand and implement.

**Comparison**

The benchmark is comparing the performance of these three hash function implementations. The test results show that `hashCode3` performs significantly better than the other two, while `hashCode2` outperforms `hashCode1`.

**Library and Special JS Features**

None of the provided code uses any libraries or special JavaScript features beyond standard ES6 syntax.

**Alternatives**

If you're interested in exploring alternative hash function implementations or testing different algorithms, consider the following:

* MDA Hash: A widely used hashing algorithm that's known for its speed and security.
* FNV-1a Hash: A non-cryptographic hash function designed for fast and uniform distribution.
* MurmurHash3 Hash: A non-cryptographic hash function optimized for performance and uniformity.

Keep in mind that these alternatives might not be as simple to implement as the provided code, but they can offer improved performance and security characteristics.

**Other Considerations**

When working with hash functions, it's essential to consider factors like:

* Collision rates: How often do different input values produce the same output hash code?
* Distribution: How evenly are the possible output hash codes distributed across the 32-bit integer space?
* Security: Are the hash functions suitable for cryptographic purposes or just general-purpose use?

For most use cases, a well-designed and optimized hash function like `hashCode3` should suffice. However, if you're working with critical applications or require extremely high performance, exploring alternative algorithms might be necessary.

Related benchmarks:

string-hashcode (version: 0)

Comparing performance of: hashCode1 vs hashCode2 vs hashCode3

Created: 4 years ago by: Guest

Jump to the latest result

hashCode1

hashCode2

hashCode3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):