Benchmark: closure lookup - MeasureThat.net

Script Preparation code:

function serialize(obj){}

var C1 = (function () {
    function C1() {
        this.idToObject = { a: 1 };
    }
    C1.prototype.test = function () {
        serialize(this);
        this.idToObject.a++;
    };
    return C1;
}());

function createC2() {
	var idToObject = {a:1};
    var self = {
      	idToObject: idToObject,
      	test: function () {
            serialize(self);
      		idToObject.a++;
    	}
    };
    
    return self;
}

    function C6() {
        this.idToObject = { a: 1 };
    }
    C6.prototype.test = function () {
        serialize(this);
        this.idToObject.a++;
    };


var c1 = new C1();
var c2 = createC2();

var test3 = createC2().test;
var c4 = new C1();
var test4 = c4.test.bind(c4);
var c5 = new C1();
var test5 = function() { return c5.test(); };
var c6 = new C6();

Tests:

prototype function + "this"
c1.test();
object function + closure
c2.test();
capture method
test3();
bind function
test4();
wrap function
test5();
prototype function + "this" (remove 1 scope)
c6.test();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
prototype function + "this"
object function + closure
capture method
bind function
wrap function
prototype function + "this" (remove 1 scope)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0

Browser/OS: Firefox 56 on Windows 7

View result in a separate tab

Test name	Executions per second
prototype function + "this"	306281984.0 Ops/sec
object function + closure	148630272.0 Ops/sec
capture method	145425712.0 Ops/sec
bind function	130681192.0 Ops/sec
wrap function	148726864.0 Ops/sec
prototype function + "this" (remove 1 scope)	178469824.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript benchmarking test case on the MeasureThat.net website. The test measures the performance of different approaches to creating and calling functions in JavaScript.

**Benchmark Definition:**

The benchmark definition is a script that creates and runs several functions, comparing their execution times. The scripts use different methods to create functions:

1. **Closure lookup**: `C1` function creates a new function using the Immediately Invoked Function Expression (IIFE) pattern, which returns an object with a `test` method.
2. **Object function + closure**: `c2` function creates an object with a `test` method, similar to `C1`, but uses a different syntax.
3. **Capture method**: This approach uses the `bind()` method to create a new function that captures the scope of another function.
4. **Bind function**: This approach uses the `bind()` method to create a new function that binds the context of an existing object.
5. **Wrap function**: This approach wraps an existing function in a new function, creating a new scope.

**Options compared:**

The benchmark compares the execution times of these five approaches:

1. Closure lookup (IIFE)
2. Object function + closure
3. Capture method (bind())
4. Bind function (bind())
5. Wrap function

**Pros and cons of each approach:**

* **Closure lookup (IIFE)**:
	+ Pros: Simple, efficient, and widely supported.
	+ Cons: Can lead to issues with variable scoping and naming conventions.
* **Object function + closure**:
	+ Pros: More readable than IIFE, can be easier to understand for beginners.
	+ Cons: May not be as efficient or compact as IIFE.
* **Capture method (bind())**:
	+ Pros: Allows for more control over the scope and context of a function.
	+ Cons: Can lead to complex code and may not be as intuitive for beginners.
* **Bind function (bind())**:
	+ Pros: Simple and efficient, can be used to create functions with specific contexts.
	+ Cons: May not be suitable for all use cases, as it modifies the original function's behavior.
* **Wrap function**:
	+ Pros: Allows for more control over the execution flow and error handling.
	+ Cons: Can lead to complex code and may not be as efficient.

**Library usage:**

There is no explicit library used in this benchmark. However, the `serialize()` function is likely a custom utility function used to serialize objects for debugging purposes.

**Special JS features or syntax:**

This benchmark does not use any special JavaScript features or syntax beyond what's commonly found in modern JavaScript implementations.

Related benchmarks:

closure lookup (version: 5)

Comparing performance of: prototype function + "this" vs object function + closure vs capture method vs bind function vs wrap function vs prototype function + "this" (remove 1 scope)

Created: 8 years ago by: Registered User

Jump to the latest result

prototype function + "this"

object function + closure

capture method

bind function

wrap function

prototype function + "this" (remove 1 scope)

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