Benchmark: parse hex to bytes

Script Preparation code:

function test(bin, bytes){
	var r, i;
	hex = '', chars = '\n: -';
	//generate an array of random octets and
	//a corresponding hex string
	for(i = 0; i < bytes; i++){
		r = Math.random() * 0x100 | 0,
		bin[i] = (r & 0xff);
		hex += (r >> 4).toString(16) + (r & 0xf).toString(16);
	}
	//insert non-hex characters at random positions in hex string
	for(i = 0; i < 10; i++){
		r = Math.random() * hex.length | 0;
		hex = hex.slice(0, r) + chars.charAt(r & 3) + hex.slice(r);
	}
  return hex;
}

var expected = [],
    testCase = test(expected, 10000);

function parseHex1(hex){// original
    hex = hex.replace(/[^0-9a-fA-F]/g, '');
    var i, 
        len = hex.length, 
        bin = [];
    for(i = 0; i < len - 1; i += 2){
        bin.push(+('0x' + hex.substring(i, i + 2)));
    }
    return bin;
}

function parseHex2(string) {// replace match map ES5
  return string.replace(/[^0-9a-fA-F]/g, '').match(/[0-9a-fA-F]{2}/g).map(function(hex) {
    return parseInt(hex, 16);
  });
}

function parseHex3(hex){//match without replace
		hex = hex.match(/[\da-f]/gi);
		for(var i = 0; i < hex.length - 1; i += 2){
			hex[i >> 1] = +('0x' + hex[i] + hex[i + 1]);
		}
		hex.length = i >> 1;
		return hex;
}


function parseHex4(hex){// iteration with replace
 		var bin = [];
		hex.replace(/([\da-f])[^\da-f]*([\da-f])/gi,
			function(m, digit1, digit2){
				bin.push(+('0x' + digit1 + digit2));
			}
		);
		return bin;
}

function parseHex5(hex){// looping with exec
		var bin = [],
			regex = /([\da-f])[^\da-f]*([\da-f])/gi,
			result;
		while(result = regex.exec(hex)){
			bin.push(+('0x' + result[1] + result[2]));
		}
		return bin;
}

function parseHex6(hex){// non regex
	var bin = [], i, c, isEmpty = 1, buffer;
	for(i = 0; i < hex.length; i++){
		c = hex.charCodeAt(i);
		if(c > 47 && c < 58 || c > 64 && c < 71 || c > 96 && c < 103){
			buffer = buffer << 4 ^ (c > 64 ? c + 9 : c) & 15;
			if(isEmpty ^= 1){
				bin.push(buffer & 0xff);
			}
		}
	}
	return bin;
}

Tests:

original
parseHex1(testCase);
ES5 replace match map
parseHex2(testCase);
match without replace
parseHex3(testCase);
iteration with replace
parseHex4(testCase);
looping with exec
parseHex5(testCase);
non regex
parseHex6(testCase);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
original
ES5 replace match map
match without replace
iteration with replace
looping with exec
non regex

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition**

The benchmark defines a function `test(bin, bytes)` that generates an array of random octets and its corresponding hex string. The purpose is to parse this hex string.

**Test Cases**

There are six test cases:

1. **Original**: Uses the original implementation `parseHex1`.
2. **ES5 replace match map**: Uses the ES5 implementation with a regular expression.
3. **Match without replace**: Uses an alternative implementation that matches the regex but doesn't use the `replace()` method.
4. **Iteration with replace**: An implementation that iterates over the hex string and replaces characters.
5. **Looping with exec**: An implementation that uses the `exec()` method to parse the hex string.
6. **Non regex**: A custom implementation that manually converts the hex string to an array of octets.

**Browser Benchmarks**

The latest benchmark results show the execution rates for each test case across multiple devices and browsers:

1. **Non regex**: 6823 executions per second
2. **Original**: 2049 executions per second
3. **Match without replace**: 1881 executions per second
4. **Looping with exec**: 1110 executions per second
5. **ES5 replace match map**: 1033 executions per second
6. **Iteration with replace**: 983 executions per second

**Analysis**

The results suggest that:

* The **Non regex** implementation is the fastest, likely due to its optimized nature.
* The **Original** implementation is slower than expected, possibly because it uses a more verbose approach or has some overhead.

The other implementations fall in between, with varying degrees of performance. It's essential to note that these results are specific to this particular benchmark and may not generalize to all use cases.

It's also worth mentioning that the **Looping with exec** implementation is slower than expected, which might be due to the overhead of using `exec()` or some other internal engine-specific optimizations.

In summary, this benchmark provides valuable insights into the performance characteristics of different JavaScript implementations for parsing hex strings.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.7 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.7

View result in a separate tab

Test name	Executions per second
original	2049.3 Ops/sec
ES5 replace match map	1033.9 Ops/sec
match without replace	1881.7 Ops/sec
iteration with replace	983.1 Ops/sec
looping with exec	1110.2 Ops/sec
non regex	6823.9 Ops/sec

Related benchmarks:

parse hex to bytes (version: 4)

Comparing performance of: original vs ES5 replace match map vs match without replace vs iteration with replace vs looping with exec vs non regex

Created: 8 years ago by: Registered User

Jump to the latest result

original

ES5 replace match map

match without replace

iteration with replace

looping with exec

non regex

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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