Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
json.parse vs includes2
(version: 1)
Benchmark.js
json.parse vs includes
Comparing performance of:
includes vs json.parse
Created:
3 years ago
by:
Registered User
Go to the latest result
Script Preparation code:
var a='{"type": "111", "msg":"2222"}'
Tests:
includes
a.includes('111') a.includes('111') a.includes('111') a.includes('111') a.includes('111') a.includes('111') a.includes('111') a.includes('111')
json.parse
JSON.parse(a)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
includes
json.parse
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.5845.1064 YaBrowser/23.9.1.1064 (beta) Yowser/2.5 Safari/537.36
Browser/OS:
Yandex Browser 23 on Linux
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=492673" width="100%" height="500px"></iframe>
includes
2.4M/s
json.parse
1.9M/s
View exact numbers
Test name
Executions per second
✓
includes
2,370,760 Ops/sec
json.parse
1,857,551 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's dive into the world of JavaScript microbenchmarks! **What is tested?** The provided JSON represents two benchmark test cases: `includes` and `json.parse`. The tests are designed to compare the performance of these two approaches: 1. **String includes**: This approach checks if a substring exists within a string. 2. **JSON parsing**: This approach parses a JSON string into JavaScript objects. **Options compared** The benchmarks compare the execution time of the following options: * `includes` (using the dot notation): `a.includes('111')` * `json.parse` (using the built-in `JSON.parse()` function): `JSON.parse(a)` **Pros and cons** Here's a brief overview of each approach: 1. **String includes** (`includes`): * Pros: + Simple and concise + Fast for small strings * Cons: + May lead to incorrect results if the substring is not found ( returns `false`) + Can be slower for larger strings due to string manipulation 2. **JSON parsing** (`json.parse`): * Pros: + More robust and accurate, as it handles nested objects and arrays correctly + Can handle larger data structures without significant performance impact * Cons: + May have higher overhead due to the need to parse the JSON string **Library** In this case, no external library is used. The `includes` method is a built-in JavaScript function, while `JSON.parse()` relies on the built-in `JSON` object. **Special JS feature or syntax** There doesn't seem to be any specific feature or syntax being tested in these benchmarks. However, it's worth noting that some browsers might have different behavior when using `includes` due to their implementation of this method (e.g., some use a trie data structure). **Other alternatives** If you're looking for alternative approaches to string includes or JSON parsing, consider the following: * For string includes: + Use a regex pattern: `a.match(/111/g)` (note that this will return an array, so you may need to adjust your test) + Implement your own substring searching algorithm (e.g., using Boyer-Moore string matching) * For JSON parsing: + Use the `eval()` function, which can parse JSON strings, but is generally considered less safe due to security concerns + Use a third-party library like `jsonlint` or `js-yaml` for more robust and flexible JSON parsing options Keep in mind that these alternatives might not be as optimized or efficient as the built-in methods used in these benchmarks.
Related benchmarks
JSON.parse vs string.split small fixed array
JSON.parse vs object literal
JSON.parse vs string.splitd
JSON.parse vs string.splitds
Comments
Confirm delete:
Do you really want to delete benchmark?