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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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

Fastest: N/A

Slowest: N/A

No previous run results

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