Benchmark: parse hex to bytes - test capacitor bluetooth-le conversion fixed

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;
}

function parseHex7(value) {
    const numbers = value
        .trim()
        .split(' ')
        .filter((e) => e !== '')
        .map((s) => parseInt(s, 16));
    return numbers;
}

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);
bluetooth-le
parseHex7(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
bluetooth-le

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark outlined in the provided JSON is focused on various methods of parsing a hex-encoded string into an array of byte values. The core goal is to compare different JavaScript implementations that process a hex string generated by the test preparation code, particularly in the context of a Bluetooth Low Energy (BLE) conversion, which is relevant in many IoT and mobile applications.

### Benchmark Methods Overview

1. **parseHex1 (original)**
   - **Description**: This method uses a straightforward approach where it first removes all non-hex characters using a regex replacement, then processes the resulting hex string in pairs to build an array of byte values.
   - **Pros**: Simple and easy to understand.
   - **Cons**: The regex `replace` can be costly in terms of performance due to string manipulation, especially for larger hex strings.

2. **parseHex2 (ES5 replace match map)**
   - **Description**: This variant combines regex replacement with a `match` method to directly find pairs of hex digits, which are then converted to integers using `parseInt`.
   - **Pros**: Cleaner separation of concerns; leverages built-in methods for brevity.
   - **Cons**: Similar performance issues as the original method with regex handling.

3. **parseHex3 (match without replace)**
   - **Description**: This method directly matches the hex characters while skipping the replacement phase.
   - **Pros**: More efficient as it eliminates additional string manipulation.
   - **Cons**: Slightly more complex due to manual index management when extracting pairs.

4. **parseHex4 (iteration with replace)**
   - **Description**: This variant iterates through the string with a `replace` callback to extract and convert hex pairs to byte values.
   - **Pros**: Efficient in extracting values as it processes pairs on-the-fly.
   - **Cons**: Still involves regex, which can add overhead.

5. **parseHex5 (looping with exec)**
   - **Description**: This approach employs the `exec` method of a regex pattern, allowing it to pull pairs of hex values in a loop.
   - **Pros**: Efficient as each match is processed immediately, reducing the need for separate data structures.
   - **Cons**: Performance may still be variable depending on the regex engine's implementation.

6. **parseHex6 (non-regex)**
   - **Description**: This method avoids using regex entirely and manually examines characters to build byte values.
   - **Pros**: Potentially faster as it eliminates regex overhead; operates directly on character codes.
   - **Cons**: More complex code may decrease readability.

7. **parseHex7 (bluetooth-le)**
   - **Description**: This function splits the input string into components, filters out empty entries, and converts the hex values directly using `parseInt`.
   - **Pros**: The clarity of operation; handles varying spacing well.
   - **Cons**: Slightly more code overhead due to the need for multiple method calls.

### Observations and Performance Results

Upon running the benchmarks, we see that `parseHex6 (non-regex)` was the fastest, achieving over 3500 executions per second. This indicates that the removal of regex overhead can significantly boost performance, especially for tasks that demand high efficiency, such as those encountered in mobile or IoT applications.

Other approaches, particularly those involving regex, tend to fall short in execution speed. For example, `parseHex1 (original)` and `parseHex2 (ES5 replace match map)` recorded much lower execution rates (under 800 executions per second), indicating that while they are simpler to implement and understand, they are less suitable for performance-critical applications.

### Alternatives

- **WebAssembly**: For extremely performance-sensitive tasks, compiling parsing logic into WebAssembly could provide better execution speeds due to its optimized execution model.
- **Typed Arrays**: Utilizing typed arrays (like `Uint8Array`) can be beneficial for applications where memory efficiency and performance are critical, particularly when dealing with binary data.
- **Third-party Libraries**: Libraries such as `buffer` (common in Node.js) provide robust mechanisms for handling binary data, including sophisticated parsing capabilities that might reduce the burden of manual implementation.
- **Custom Solutions**: Depending on the specific requirements (speed, code complexity, readability), developers might implement a tailor-made parser optimized for their use case.

In summary, while the benchmark tests a variety of parsing methods with varying performance, it highlights the trade-offs between performance and code complexity, allowing engineers to choose the most suitable method for their particular circumstances.

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_8_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148

Browser/OS: Mobile Safari 15 on iOS 15.8.3

View result in a separate tab

Test name	Executions per second
original	747.4 Ops/sec
ES5 replace match map	340.2 Ops/sec
match without replace	729.1 Ops/sec
iteration with replace	395.6 Ops/sec
looping with exec	608.7 Ops/sec
non regex	3582.6 Ops/sec
bluetooth-le	389.8 Ops/sec

Related benchmarks:

parse hex to bytes - test capacitor bluetooth-le conversion fixed (version: 0)

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

Created: one month ago by: Guest

Jump to the latest result

original

ES5 replace match map

match without replace

iteration with replace

looping with exec

non regex

bluetooth-le

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):