Benchmark: Objects vs JSON Literals vs Others

Objects vs JSON Literals vs Others (version: 0)

Set a field R to the result of field B minus field A, using a variety of different objects

Comparing performance of: Using a new function Object for the fields vs Using dot syntax in an object literal vs Using string keys in an object literal vs Using Class fields vs Using a builtin Map vs Using an array with 3 slots vs Using an object literal with integer keys vs Baseline using normal variables

Created: 5 years ago by: Guest

Jump to the latest result

Script Preparation code:

function ObjCon() {
  this.a = 1
  this.b = 2
  this.r = 0
}
var Literal = {a:1,b:2,r:0}
var Obj = new ObjCon()
class ObjClass {
  constructor() {
    this.a = 1
    this.b = 2
    this.r = 0
  }
}
var Cls = new ObjClass()
var FieldMap = new Map()
FieldMap.set("a", 1)
FieldMap.set("b", 2)
FieldMap.set("r", 0)
var FieldArray = [1,2,0]
var IntObject = {0:1,1:2,2:0}
var A = 1
var B = 2
var R = 0

Tests:

Using a new function Object for the fields
Obj.r = Obj.b - Obj.a
Using dot syntax in an object literal
Literal.r = Literal.b - Literal.a
Using string keys in an object literal
Literal["r"] = Literal["b"] - Literal["a"]
Using Class fields
Cls.r = Cls.b - Cls.a
Using a builtin Map
FieldMap.set("r", FieldMap.get("b") - FieldMap.get("a"))
Using an array with 3 slots
FieldArray[2] = FieldArray[1]-FieldArray[0]
Using an object literal with integer keys
IntObject[2] = IntObject[1]-IntObject[0]
Baseline using normal variables
R = B - A

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using a new function Object for the fields
Using dot syntax in an object literal
Using string keys in an object literal
Using Class fields
Using a builtin Map
Using an array with 3 slots
Using an object literal with integer keys
Baseline using normal variables

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.

Let's break down the provided benchmark and explain what's being tested, compared, and their pros/cons.

**Benchmark Definition**

The benchmark is designed to measure performance differences in assigning values to variables using various approaches:

1. Dot syntax in an object literal (`Literal.r = Literal.b - Literal.a`)
2. String keys in an object literal (`Literal[\"r\"] = Literal[\"b\"] - Literal[\"a\"]`)
3. Class fields (`Cls.r = Cls.b - Cls.a`)
4. Array with 3 slots (`FieldArray[2] = FieldArray[1]-FieldArray[0]`)
5. Object literal with integer keys (`IntObject[2] = IntObject[1]-IntObject[0]`)
6. New function object for the fields (`ObjCon.r = ObjCon.b - ObjCon.a`)
7. Normal variables (baseline) (`R = B - A`)

**Options Comparison**

Here's a brief overview of each approach and their pros/cons:

1. **Dot syntax in an object literal**: Fast and concise, but may lead to errors if not used correctly.
2. **String keys in an object literal**: Similar performance to dot syntax, but adds overhead due to string manipulation.
3. **Class fields**: Efficient and modern way of defining variables, but may not be supported in older browsers or environments.
4. **Array with 3 slots**: Simple and efficient, as arrays are optimized for indexing. However, it assumes a fixed length array.
5. **Object literal with integer keys**: Similar performance to arrays, but provides more flexibility and is easier to read.
6. **New function object for the fields**: Adds overhead due to function creation and garbage collection.
7. **Normal variables (baseline)**: The most basic and widely supported approach, but may be slower than others.

**Performance Results**

The provided execution times show that:

* Dot syntax in an object literal (`Literal.r = Literal.b - Literal.a`) is the fastest.
* String keys in an object literal (`Literal[\"r\"] = Literal[\"b\"] - Literal[\"a\"]`) is similar to dot syntax but slightly slower.
* Class fields (`Cls.r = Cls.b - Cls.a`) and object literal with integer keys (`IntObject[2] = IntObject[1]-IntObject[0]`) are relatively fast, tied for second place.
* Arrays with 3 slots (`FieldArray[2] = FieldArray[1]-FieldArray[0]`) and new function objects for the fields (`ObjCon.r = ObjCon.b - ObjCon.a`) are slower due to their added complexity and overhead.
* Normal variables (baseline) (`R = B - A`) is the slowest, likely due to its simplicity and lack of optimization.

Keep in mind that these results may vary depending on the specific browser, environment, or use case.

Related benchmarks: