Benchmark: JSON.parse vs string.indexOf

Script Preparation code:

var json = JSON.stringify({
  "type": "l2update",
  "product_id": "BTC-USD",
  "time": "2019-08-14T20:42:27.265Z",
  "changes": [
    [
      "buy",
      "10101.80000000",
      "0.162567"
    ]
  ]
});

Tests:

JSON.parse
var o = JSON.parse(json); if (o.type === 'l2update') { // do something cool }
String.indexOf
if (json.indexOf('l2update') !== -1) { // do something cool }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.parse
String.indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 127 on Windows

View result in a separate tab

Test name	Executions per second
JSON.parse	997291.6 Ops/sec
String.indexOf	12262335.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance difference between two approaches to check if a specific string exists in another string: `JSON.parse` and `string.indexOf`.

**Options Being Compared**

1. **JSON.parse**: This method is used to parse a JSON string into a JavaScript object. In this benchmark, it's used to parse the input JSON string.
2. **String.indexOf**: This method is used to search for a substring within another string. In this benchmark, it's used to check if the string `'l2update'` exists in the original JSON string.

**Pros and Cons of Each Approach**

* **JSON.parse**:
	+ Pros: Can be faster when dealing with large strings, as it uses a more efficient algorithm for substring search.
	+ Cons: Requires parsing the entire string into a JavaScript object, which can lead to slower performance compared to `string.indexOf`.
* **String.indexOf**:
	+ Pros: Faster and more lightweight than `JSON.parse`, making it suitable for applications with limited resources.
	+ Cons: May be slower when dealing with large strings or complex substring searches.

**Library Used**

The benchmark uses the built-in `JSON` object in JavaScript, which provides methods for parsing and manipulating JSON data. The `JSON.stringify()` method is used to convert a JavaScript object into a string, while `JSON.parse()` is used to parse a JSON string back into an object.

**Special JS Feature or Syntax**

None mentioned in this benchmark.

**Other Considerations**

The benchmark assumes that the input JSON string contains only ASCII characters. If the string can contain non-ASCII characters, additional considerations may be necessary.

**Alternatives**

Other alternatives for checking if a substring exists within another string include:

* **Substring search algorithms**: Such as Knuth-Morris-Pratt (KMP) or Rabin-Karp algorithms.
* **Regular expressions**: Which provide more complex and powerful string matching capabilities.
* **Custom implementation**: Depending on the specific requirements of the application, it may be possible to implement a custom substring search algorithm.

It's worth noting that the benchmark results will depend on various factors, such as the specific hardware, software, and environment used for testing.

Related benchmarks:

JSON.parse vs string.indexOf (version: 0)

When discriminating a JSON string to determine action, which is faster?

Comparing performance of: JSON.parse vs String.indexOf

Created: 4 years ago by: Guest

Jump to the latest result

JSON.parse

String.indexOf

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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