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

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 defined in the provided JSON tests various methods for parsing a hexadecimal string into an array of byte values. This is done by simulating or generating a random hexadecimal string that includes non-hex characters, which is particularly useful in use cases like parsing Bluetooth LE data formats that often involve hexadecimal representations.

## Options Tested

The benchmark compares the following parsing methods:

1. **parseHex1** - **Original Method**
   - This straightforward approach uses a loop to iterate through the cleaned hexadecimal string (non-hex characters stripped) and converts it into bytes by using substring operations and the `0x` prefix for numeric parsing.
   - **Pros**: Simple to read and understand; straightforward implementation.
   - **Cons**: May be less efficient for longer strings due to repeated substring operations.

2. **parseHex2** - **ES5 Replace Match Map**
   - This method leverages `String.replace()` to remove non-hex characters, and then uses `match()` with a regular expression to extract pairs of characters, which are subsequently mapped to byte values using `parseInt()`.
   - **Pros**: Utilizes built-in JavaScript string methods; compact and expressive.
   - **Cons**: The overhead of multiple string manipulations may slow it down for large strings.

3. **parseHex3** - **Match Without Replace**
   - This approach uses a regex pattern directly to match valid hex characters and then constructs byte values by analyzing matched pairs.
   - **Pros**: Directly processes matched data without intermediate string processing.
   - **Cons**: More complex logic than other methods; may be less readable.

4. **parseHex4** - **Iteration with Replace**
   - Similar to parseHex2, but instead of mapping, it iterates through matches and generates the byte values in a callback function.
   - **Pros**: Avoids intermediate arrays and is more direct.
   - **Cons**: Complexity may hinder readability.

5. **parseHex5** - **Looping with Exec**
   - This method uses a regex with `exec()` to loop through matches, adding byte values found to an array.
   - **Pros**: Provides control over the matching process; efficiency in handling matched pairs.
   - **Cons**: Can be prone to confusion since it mixes two types of operations (exec and byte handling).

6. **parseHex6** - **Non Regex**
   - This implementation manually checks character codes in the hexadecimal string and shifts bits to create byte values.
   - **Pros**: Potentially faster as it avoids regex parsing entirely.
   - **Cons**: Less intuitive and more prone to mistakes; increases complexity.

7. **parseHex7** - **Bluetooth-LE Approach**
   - This function trims input and splits it by spaces, filtering out empty strings before parsing them as hexadecimal.
   - **Pros**: Straightforward parsing for space-separated hex values, which fits the specific use case of Bluetooth LE data.
   - **Cons**: Assumes a specific string format; might be less general but efficient for its intended use case.

## Benchmark Results

The results indicate overall performance (Executions Per Second) for each method in a controlled environment (Chrome, Windows). The `parseHex7` method performs the best at approximately **324,824 operations/second**, showing its effectiveness, particularly where space-separated hex inputs are common, as in Bluetooth LE contexts. Other methods like `parseHex6` and `parseHex1` show significantly lower performance, which highlights that regex-based solutions can vary greatly based on implementation strategy.

## Conclusion

Choosing the right parsing method depends on specific use cases—whether performance or readability is prioritized. While regex-based solutions tend to be powerful and expressive, they often come with a performance cost, especially when handling large volumes of data. Non-regex methods might be more efficient but can sacrifice clarity and maintainability of code.

Alternatives to regex for parsing include using libraries like **Lodash** or **Underscore** that provide utility functions mimicking both processing strategies with built-in optimizations or handling split-map-style processing more intuitively. However, in cases where performance is paramount, a custom, optimized implementation (like `parseHex6`) may yield the best results while requiring thorough testing for edge cases.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
original	1664.9 Ops/sec
ES5 replace match map	438.0 Ops/sec
match without replace	846.1 Ops/sec
iteration with replace	475.8 Ops/sec
looping with exec	810.0 Ops/sec
non regex	3651.8 Ops/sec
bluetooth-le	324824.0 Ops/sec

Related benchmarks:

parse hex to bytes - test capacitor bluetooth-le conversion (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):