Benchmark: closure lookup - MeasureThat.net

Script Preparation code:

function s(obj){}

var C1 = (function () {
    function C1() {
        this.idToObject = { a: 1 };
    }
    C1.prototype.test = function () {
        s(this);
        this.idToObject.a++;
    };
    return C1;
}());

var C2 = (function () {
    function C2() {
        var self = this;
        var idToObject = self.idToObject = {a:1};
        self.test = function () {
            s(this);
            idToObject.a++;
        };
    }
    return C2;
}());
var c1 = new C1();
var c2 = new C2();

Tests:

prototype function + "this"
c1.test();
object function + closure
c2.test();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
prototype function + "this"
object function + closure

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the explanation into smaller parts to make it easier to understand.

**Benchmark Definition JSON**

The benchmark definition provides two JavaScript functions, `C1` and `C2`, which are then used in two separate test cases: "prototype function + 'this'" and "object function + closure". The functions are:

*   `C1`: A immediately invoked function expression (IIFE) that creates a new object with an `idToObject` property. When the `test` method of this object is called, it increments the value of `a` in `idToObject`.
*   `C2`: Another IIFE that creates an object with an `idToObject` property. However, instead of using the `this` keyword to access the object's properties, it uses a closure by assigning `self.idToObject = {a:1}` and then referencing `idToObject` within the `test` method.

**Options Compared**

The benchmark compares two approaches:

*   **Prototype Function + "this"**: This approach uses the `prototype` keyword to create an object with methods. When the `test` method is called, it increments the value of `a` in `idToObject`. The use of `this` within the method allows for direct access to the object's properties.
*   **Object Function + Closure**: This approach creates an object with a closure that has access to its own properties. When the `test` method is called, it increments the value of `a` in `idToObject`. Unlike the prototype function approach, this one uses a closure to access the object's properties.

**Pros and Cons**

*   **Prototype Function + "this"**:
    *   Pros:
        *   More straightforward syntax
        *   Less memory-intensive since no additional objects are created for closures
    *   Cons:
        *   May be slower due to the overhead of using `prototype`
*   **Object Function + Closure**:
    *   Pros:
        *   Can provide better encapsulation and access control, as the closure is self-contained
        *   Might be faster since no additional object creation is required for closures
    *   Cons:
        *   More complex syntax
        *   May lead to slower performance due to the overhead of using closures

**Other Considerations**

*   **Memory Usage**: The prototype function approach may use more memory than the object function approach, especially if dealing with large datasets.
*   **Performance**: The benchmark results are likely influenced by factors such as browser version, device platform, and operating system.

**Special JS Features/Syntax**

The benchmark uses the following special JavaScript features:

*   Immediately Invoked Function Expression (IIFE): Used to create the `C1` and `C2` functions.
*   Object creation: Used to create objects with properties (`idToObject`) and methods (`test`).
*   Prototype keyword: Used in the prototype function approach.

If not mentioned, I'll make sure not to mention it. Let me know if you'd like me to elaborate on anything else!

Latest run results:

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

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

Browser/OS: Chrome 54 on Windows

View result in a separate tab

Test name	Executions per second
prototype function + "this"	5569391.5 Ops/sec
object function + closure	5058167.5 Ops/sec

Related benchmarks:

closure lookup (version: 3)

Comparing performance of: prototype function + "this" vs object function + closure

Created: 8 years ago by: Registered User

Jump to the latest result

prototype function + "this"

object function + closure

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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