Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
11111111
(version: 0)
Comparing performance of:
2341234 vs 21341234 vs 1234234 vs 123412344
Created:
2 years ago
by:
Guest
Go to the latest result
HTML Preparation code:
12341234
Script Preparation code:
var array = [1,2,3];
Tests:
2341234
var d = array[array.length - 1];
21341234
var z = array.at(-1);
1234234
var d2 = array[1];
123412344
var z2 = array.at(1);
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (4)
Previous results
Fork
Test case name
Result
2341234
21341234
1234234
123412344
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
2 years ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36
Browser/OS:
Chrome 122 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=509232" width="100%" height="500px"></iframe>
1234234
8.4M/s
21341234
8.3M/s
123412344
8.3M/s
2341234
4.4M/s
View exact numbers
Test name
Executions per second
✓
1234234
8,362,130 Ops/sec
21341234
8,322,617 Ops/sec
123412344
8,272,000 Ops/sec
2341234
4,433,176 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
I'd be happy to help explain the JavaScript microbenchmarking test case. **Benchmark Definition** The benchmark definition is represented by a JSON object that contains information about the test. In this case, it has four fields: * `Name`: A unique identifier for the benchmark. * `Description`: An optional field that provides a description of the benchmark (which is empty in this case). * `Script Preparation Code`: A JavaScript code snippet that is executed before running the benchmark. This code initializes an array variable `array` with three elements: `[1, 2, 3]`. * `Html Preparation Code`: An HTML code snippet that is executed before running the benchmark (this field contains a random string of numbers). **Individual Test Cases** The test cases are represented by an array of objects, each containing: * `Benchmark Definition`: A JavaScript code snippet that defines a variable and uses it to access an element in the `array` variable. * `Test Name`: A unique identifier for each test case. In this case, there are four test cases: 1. `var d = array[array.length - 1];`: This test case uses the negative indexing feature (`-1`) to access the last element of the `array`. 2. `var z = array.at(-1);`: This test case uses the `at()` method with a negative index to access the last element of the `array`. The `at()` method is introduced in ECMAScript 2019 (ES10). 3. `var d2 = array[1];`: This test case uses direct indexing (`[]`) to access the second element of the `array`. 4. `var z2 = array.at(1);`: This test case uses the `at()` method with a positive index to access the second element of the `array`. **Pros and Cons** The choice of accessing an element in an array depends on various factors, including performance, readability, and maintainability. * Direct indexing (`[]`): This approach is simple and easy to read, but it may be slower than using methods like `at()` or negative indexing. * Negative indexing: Using negative indices can be more readable and efficient than direct indexing, especially for large arrays. * `at()` method: The `at()` method provides a more explicit way of accessing elements in an array, but it requires support from modern browsers. Its performance may vary depending on the browser implementation. **Library and Special JS Features** The `at()` method is introduced in ECMAScript 2019 (ES10) and is supported by most modern browsers. Other alternatives to direct indexing or negative indexing include using `slice()` or other array methods, but these approaches are often less efficient than accessing elements directly. **Alternatives** If you're looking for alternative ways to access elements in an array, consider the following: * Using `Array.prototype.slice()`: This method creates a new array with a specified subset of elements from the original array. * Using `Array.prototype.indexOf()` or `Array.prototype.lastIndexOf()`: These methods return the index of the first occurrence of a specified element in the array.
Related benchmarks
array.length = 0 vs []
Comments
Confirm delete:
Do you really want to delete benchmark?