Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Arrow function vs bind function2021-reznik
(version: 0)
Comparing performance of:
Arrow function vs Bind function
Created:
3 years ago
by:
Guest
Go to the latest result
Script Preparation code:
arrowFn = () => this bindFn = (function() { return this }).bind(this)
Tests:
Arrow function
bindFn()
Bind function
arrowFn()
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
Arrow function
Bind function
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36
Browser/OS:
Chrome 135 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=600823" width="100%" height="500px"></iframe>
Bind function
218.7M/s
Arrow function
203.5M/s
View exact numbers
Test name
Executions per second
✓
Bind function
218,680,272 Ops/sec
Arrow function
203,461,280 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Let's break down the provided JSON and explain what's being tested, compared, and the pros/cons of each approach. **Benchmark Definition** The benchmark is comparing two ways to call a function: arrow functions and bound functions (also known as method binding). An arrow function is a concise way to define small anonymous functions, while bound functions are used to create a new function that has its `this` context set to the original object. **Script Preparation Code** The script preparation code defines two variables: * `arrowFn`: an arrow function that returns `this`, which means it will inherit the `this` context of its surrounding scope. * `bindFn`: a bound function created by calling the `bind()` method on another function (in this case, a simple function that returns `this`). This sets the `this` context of the resulting function to the original object. **Html Preparation Code** There is no HTML preparation code provided, which means the benchmark doesn't consider any external factors that might affect performance. **Individual Test Cases** The test cases are: * "Arrow function": tests calling an arrow function directly. * "Bind function": tests calling a bound function (created using `bind()`). Now, let's talk about the pros and cons of each approach: **Arrow Functions** Pros: 1. **Concise**: arrow functions are shorter and easier to read than traditional functions. 2. **Lexical scope**: they inherit the `this` context of their surrounding scope. Cons: 1. **Limited control over `this` context**: once an arrow function is created, its `this` context cannot be changed. 2. **No explicit binding**: no way to explicitly bind the function to a specific object or context. **Bound Functions** Pros: 1. **Explicit binding**: using `bind()` allows you to set the `this` context of the resulting function explicitly. 2. **Control over `this` context**: once bound, the function's `this` context cannot be changed. Cons: 1. **Verbose**: creating a bound function requires more code than an arrow function. 2. **Performance overhead**: binding a function can introduce performance overhead due to the creation of a new object and function. **Library Used** None is mentioned in this benchmark, as both arrow functions and bound functions are native JavaScript features. **Special JS Feature or Syntax** No special feature or syntax is used in these test cases, only standard JavaScript concepts. **Alternatives** Other alternatives for calling functions include: 1. **Immediately Invoked Function Expression (IIFE)**: a function that is executed immediately after its definition. 2. **Function expressions**: a generic way to define functions without creating them immediately. 3. **Closures**: a function that has access to its surrounding scope, often used for creating private variables. The choice of approach depends on the specific use case and performance requirements. In general, arrow functions are preferred when concise code is necessary, while bound functions may be used when explicit control over `this` context is required.
Related benchmarks
Arrow function vs bind function
Arrow function vs bind function dont bind
Arrow function vs Bind function - forked
Arrow function vs bind function creation
Comments
Confirm delete:
Do you really want to delete benchmark?