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

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

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

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 2 months ago):