Benchmark: private method - MeasureThat.net

Script Preparation code:

var A = class A {
  	string = 'string'
  
	test() {
    	return this.string + 'test'
    }
  
  	testRun() {
    	for (let i = 0; i < 1000; i++) {
        	this.test()
        }
    }
}

var PrivateTest = Symbol('PrivateTest')
var B = class B {
  	string = 'string';
  
	[PrivateTest]() {
    	return this.string + 'test'
    }

	testRun() {
    	for (let i = 0; i < 1000; i++) {
        	this[PrivateTest]()
        }
    }
}

function cTest(c) {
	return c.string + 'test'
}
var C = class C {
	string = 'string'
    
    testRun() {
        for (let i = 0; i < 1000; i++) {
       	    cTest(this)
        }
    }
}

var D = class D {
  	string = 'string'
  
	#test() {
    	return this.string + 'test'
    }
  
  	testRun() {
    	for (let i = 0; i < 1000; i++) {
        	this.#test()
        }
    }
}

Tests:

A
var a = new A() a.testRun()
B
var b = new B() b.testRun()
C
var c = new C() c.testRun()
D
var d = new D() d.testRun()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
A
B
C
D

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months ago)

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

Browser/OS: Chrome 141 on Windows

View result in a separate tab

Test name	Executions per second
A	3637874.5 Ops/sec
B	3812586.8 Ops/sec
C	3865260.2 Ops/sec
D	3893900.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and its options.

**Benchmark Definition**

The benchmark definition is a JSON object that represents a script used to test the performance of JavaScript code. It includes:

* A class `A` with methods `test()` and `testRun()`.
* Another class `B` with similar methods, but also using the `[PrivateTest]` syntax to denote a private method.
* Class `C` which calls a function `cTest(c)` to get the string value instead of directly accessing it through `this.string`.
* Class `D` that uses an invalid syntax `#test()` to try and access the test method.

**Options Compared**

The benchmark compares the performance of the following options:

1. **Method 1: Direct Access** - Classes `A`, `C`, and `D` use direct access to the string value using `this.string`.
	* Pros: Simple, easy to read, and well-established syntax.
	* Cons: May lead to slower performance due to method lookup overhead.
2. **Method 2: Property Access with Symbol** - Classes `B` uses property access with a symbol (`[PrivateTest]`) instead of the dot notation.
	* Pros: Can provide better performance by avoiding method lookup, as symbols are faster looked up than strings.
	* Cons: Less readable and less well-established syntax.
3. **Method 3: Function Call** - Class `C` uses a function call (`cTest(this)`) to get the string value instead of direct access.
	* Pros: Can avoid method lookup overhead, but introduces additional function call performance overhead.
	* Cons: Less readable and may not be optimized by the JavaScript engine.

**Library**

There is no explicit library mentioned in the benchmark definition. However, `Symbol` is used to denote a private method, which is a built-in JavaScript feature introduced in ECMAScript 2015 (ES6).

**Special JS Feature/Syntax**

The `[PrivateTest]` syntax is used to denote a private method in Class `B`. This is a special syntax introduced in ECMAScript 2015 (ES6) for private fields and methods.

**Other Alternatives**

Other alternatives could be considered, such as:

1. **Using getter/setter properties**: Instead of using symbols or functions to access the string value.
2. **Using a custom function**: Creating a custom function that returns the string value instead of using direct access.
3. **Using memoization**: Caching the result of expensive function calls to avoid repeated computation.

**Benchmark Preparation Code**

The benchmark preparation code is a script that creates instances of each class and runs their `testRun()` method. The specific code is not shown here, but it's likely that the code creates an array of test cases using the `Benchmark Definition` object provided, and then runs each test case in a loop to measure the execution time.

**Testing Considerations**

When testing JavaScript performance, it's essential to consider factors such as:

1. **Method lookup overhead**: Direct access can lead to slower performance due to method lookup overhead.
2. **Symbol vs. String notation**: Using symbols for private methods can provide better performance but may be less readable.
3. **Function call overhead**: Using functions to access the string value can introduce additional function call performance overhead.
4. **Caching and memoization**: Caching results of expensive function calls can help improve performance by avoiding repeated computation.

When writing benchmarks, it's essential to consider these factors and ensure that the test is fair, accurate, and representative of real-world scenarios.

Related benchmarks:

private method (version: 0)

Comparing performance of: A vs B vs C vs D

Created: 2 years ago by: Registered User

Jump to the latest result

A

B

C

D

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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