Benchmark: substr vs JSON.parse

Script Preparation code:

var jsonObject = '{"value1": 15, "value2": 16, "value3": "value"}';
var stringObject = '15 16 value';

var bigJsonObject = '{"value1": 15, "value2": 16, "value3": "valueaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}';

var bigStringObject = '15 16 valueaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';

function parseToString(stringValue, number) {
    var result = [];
    
    var prevSpaceIndex = -1;
    for(var i  = 0; i < number - 1; i++) {
        var spaceIndex = stringValue.indexOf(' ', prevSpaceIndex + 1);
        
        result[i] = stringValue.substr(prevSpaceIndex  + 1, spaceIndex - prevSpaceIndex  - 1);
        
        prevSpaceIndex = spaceIndex;
    }
    
    result[result.length] = stringValue.substr(spaceIndex+1);
	
	return result;
}

function parseTestObjectUseArray(value) {
    var array = parseToString(value, 3);
    
    return {
        value1: array[0],
        value2: array[1],
        value3: array[2],
      };  
}

function parseTestObject(stringValue) {
  var firstSpace = stringValue.indexOf(' ');
  var secondSpace = stringValue.indexOf(' ', firstSpace + 1);

  if(firstSpace == -1 || secondSpace == -1) {
	  throw Error("Malformed message");
  }

  return {
    value1: stringValue.substr(0, firstSpace),
    value2: stringValue.substr(firstSpace  + 1, secondSpace - firstSpace  - 1),
    value3: stringValue.substr(secondSpace + 1)
  };
}

Tests:

parseTestObject(stringObject);
var object = parseTestObject(stringObject);
parseTestObject(bigStringObject);
var object = parseTestObject(bigStringObject);
JSON.parse(bigJsonObject);
JSON.parse(bigJsonObject);
JSON.parse(jsonObject);
JSON.parse(jsonObject);
parseTestObjectUseArray(bigStringObject);
var object = parseTestObjectUseArray(bigStringObject);
parseTestObjectUseArray(stringObject);
var object = parseTestObjectUseArray(stringObject);
stringObject to vars
var firstSpace = stringObject.indexOf(' '); var secondSpace = stringObject.indexOf(' ', firstSpace + 1); if(firstSpace == -1 || secondSpace == -1) { throw Error("Malformed message"); } var value1 = stringObject.substr(0, firstSpace); var value2 = stringObject.substr(firstSpace + 1, secondSpace - firstSpace - 1); var value3 = stringObject.substr(secondSpace + 1);
bigStringObject to vars
var firstSpace = bigStringObject.indexOf(' '); var secondSpace = bigStringObject.indexOf(' ', firstSpace + 1); if(firstSpace == -1 || secondSpace == -1) { throw Error("Malformed message"); } var value1 = bigStringObject.substr(0, firstSpace); var value2 = bigStringObject.substr(firstSpace + 1, secondSpace - firstSpace - 1); var value3 = bigStringObject.substr(secondSpace + 1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
parseTestObject(stringObject);
parseTestObject(bigStringObject);
JSON.parse(bigJsonObject);
JSON.parse(jsonObject);
parseTestObjectUseArray(bigStringObject);
parseTestObjectUseArray(stringObject);
stringObject to vars
bigStringObject to vars

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):

LLMs can make mistakes. Check important info.

It looks like you're analyzing benchmarking results from a JavaScript testing tool.

Based on the data, here are some observations and insights:

1. **parseTestObject** is the fastest function to execute among all tests, with an average execution time of 4725 executions per second.
2. `stringObject` and `bigStringObject` functions are close in terms of execution speed, with `stringObject` being slightly faster (average execution time: 4714 seconds).
3. `parseTestObjectUseArray` is the slowest among the three, with an average execution time of 2714 seconds.
4. **JSON.parse** is significantly slower than `parseTestObject`, `stringObject`, and `bigStringObject`.
5. The testing tool is running on a Macintosh device with Intel Core i7 processor.

Some possible conclusions:

* `parseTestObject` might be optimized for performance or have some internal caching mechanism that reduces execution time.
* Using an array to parse objects (in `parseTestObjectUseArray`) seems less efficient than using a single object (in `parseTestObject`).
* JSON parsing is generally slower due to the complexity of the JavaScript Object Notation standard and the need for error handling.

Keep in mind that these are general observations based on benchmarking results, and actual performance may vary depending on specific use cases and environment.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.0.0 Safari/537.36

Browser/OS: Chrome 101 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
parseTestObject(stringObject);	4713716.5 Ops/sec
parseTestObject(bigStringObject);	4725879.0 Ops/sec
JSON.parse(bigJsonObject);	1081994.0 Ops/sec
JSON.parse(jsonObject);	1432461.5 Ops/sec
parseTestObjectUseArray(bigStringObject);	2714189.5 Ops/sec
parseTestObjectUseArray(stringObject);	2674279.2 Ops/sec
stringObject to vars	2152055.0 Ops/sec
bigStringObject to vars	2148301.2 Ops/sec

Related benchmarks:

substr vs JSON.parse (version: 0)

Comparing performance of: parseTestObject(stringObject); vs parseTestObject(bigStringObject); vs JSON.parse(bigJsonObject); vs JSON.parse(jsonObject); vs parseTestObjectUseArray(bigStringObject); vs parseTestObjectUseArray(stringObject); vs stringObject to vars vs bigStringObject to vars

Created: 7 years ago by: Guest

Jump to the latest result

parseTestObject(stringObject);

parseTestObject(bigStringObject);

JSON.parse(bigJsonObject);

JSON.parse(jsonObject);

parseTestObjectUseArray(bigStringObject);

parseTestObjectUseArray(stringObject);

stringObject to vars

bigStringObject to vars

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):