Benchmark: filter unsafe token 10w

Script Preparation code:

var params = Array.from({length: 30}).reduce((p, n, i) => {
  p['key' + i] = 'value' + i;
  return p;
}, {});

function runTest(fn, cnt) {
	while(cnt--) {fn();}
}

Tests:

Deep Clone
function fixParams(params) { const token = 'xxxxxxxxxxxxxxxxxxxx'; if (typeof params === 'object' && token) { try { const reg = new RegExp(token, 'g'); const str = JSON.stringify(params); str.replace(reg, 'yyyyyyyyyyyyy'); params = JSON.parse(str); } catch (e) { console.log(e); } } return params; } runTest(() => fixParams(params), 100000)
Iterate All keys
function deepReplace(params, regex, replacement) { for (let key in params) { if (typeof params[key] === 'object') { deepReplace(params[key], regex, replacement); } else if (regex.test(params[key])) { params[key] = params[key].replace(regex, replacement); } } } function fixParams(params) { const token = 'xxxxxxxxxxxxxxxxxxxx'; if (typeof params === 'object' && token) { try { const reg = new RegExp(token, 'g'); params = deepReplace(params, reg, 'yyyyyyyyyyyyy'); } catch (e) { console.log(e); } } return params; } runTest(() => fixParams(params), 100000)
Deep Clone, but not parse
function fixParams(params) { const token = 'xxxxxxxxxxxxxxxxxxxx'; if (typeof params === 'object' && token) { try { const reg = new RegExp(token, 'g'); const str = JSON.stringify(params); if (reg.test(str)) { str.replace(reg, 'yyyyyyyyyyyyy'); params = JSON.parse(str); } } catch (e) { console.log(e); } } return params; } runTest(() => fixParams(params), 100000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Deep Clone
Iterate All keys
Deep Clone, but not parse

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 break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark consists of three test cases that measure the performance of JavaScript functions involved in cloning or replacing data using regular expressions (regex). The test cases are designed to exercise different aspects of these operations, which can be useful for identifying performance bottlenecks in JavaScript applications.

**Test Cases**

1. **Deep Clone**: This test case measures the time it takes to perform a deep clone of an object using `JSON.parse()` and `JSON.stringify()`. The function `fixParams(params)` creates a regular expression pattern from the input object's keys, which is then used to replace the original values with a new string representation. The resulting object is then parsed back into its original form.
2. **Iterate All Keys**: This test case measures the time it takes to iterate over all keys of an object using regex and replace their values. The function `deepReplace(params, regex, replacement)` recursively replaces the values of objects within the input object with new values using regex.
3. **Deep Clone, but not parse**: This test case is similar to the first one, but it skips parsing the resulting string back into an object.

**Library and Features**

The benchmark uses the following libraries and features:

* `Array.from()`: a modern JavaScript method for creating an array from an iterable.
* `RegExp`: a built-in JavaScript class for working with regular expressions.
* `JSON.parse()` and `JSON.stringify()`: built-in JavaScript methods for parsing and stringifying JSON data.

**Options Compared**

The benchmark compares different approaches to cloning or replacing data using regex:

1. **Deep Clone**: uses `JSON.parse()` and `JSON.stringify()` to create a deep clone of the input object.
2. **Iterate All Keys**: uses `RegExp` to iterate over all keys of the input object and replace their values using regex.
3. **Deep Clone, but not parse**: skips parsing the resulting string back into an object.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Deep Clone**:
	* Pros: predictable performance, easy to implement.
	* Cons: may introduce additional overhead due to parsing and stringifying JSON data.
2. **Iterate All Keys**:
	* Pros: can handle complex object structures, flexible replacement logic.
	* Cons: may be slower due to regex iteration and replacement, potentially introduces security risks if not implemented carefully.
3. **Deep Clone, but not parse**:
	* Pros: avoids additional overhead of parsing and stringifying JSON data.
	* Cons: performance may vary depending on the specific use case and object structure.

**Other Considerations**

When selecting an approach for cloning or replacing data in JavaScript, consider the following factors:

* Performance requirements: If high performance is crucial, a more optimized approach like `JSON.parse()` and `JSON.stringify()` might be preferred.
* Data complexity: For complex object structures, `Iterate All Keys` may be a better choice to handle nested objects.
* Security risks: Be cautious when using regex for security-critical operations, as it can introduce vulnerabilities if not implemented carefully.

**Alternatives**

If you're interested in exploring alternative approaches, consider the following options:

1. **Lodash**: a popular JavaScript library that provides utility functions for working with arrays and objects, including deep cloning.
2. **Underscore.js**: another widely used JavaScript library that offers functional programming utilities, including array manipulation and object iteration.
3. **Native JavaScript methods**: explore other native JavaScript methods like `Object.assign()`, `Array.prototype.map()`, or `Array.prototype.forEach()` for cloning or replacing data.

Keep in mind that each approach has its trade-offs, and the best choice depends on your specific use case and performance requirements.

Latest run results:

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

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

Browser/OS: Mobile Safari 16 on iOS 16.5

View result in a separate tab

Test name	Executions per second
Deep Clone	4.7 Ops/sec
Iterate All keys	21.9 Ops/sec
Deep Clone, but not parse	16.9 Ops/sec

Related benchmarks:

filter unsafe token 10w (version: 0)

Comparing performance of: Deep Clone vs Iterate All keys vs Deep Clone, but not parse

Created: 6 months ago by: Registered User

Jump to the latest result

Deep Clone

Iterate All keys

Deep Clone, but not parse

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