Benchmark: tewgwggweg - MeasureThat.net

Script Preparation code:

var array1 = 
[
  "value1",
  "value2",
  "value3",
  "value4",
  "value5",
  "value6",
  "value7",
  "value8",
  "value9",
  "value10",
  "value11",
  "value12",
  "value13",
  "value14",
  "value15",
  "value16",
  "value17",
  "value18",
  "value19",
  "value20"
];
var array2 =
[
  "value1",
  "value10",
  "value20"
];

Tests:

Array.indexOf()
for(var i = 0, len = array1.length; i < len; i++) { var value = array1[i]; var result = (array2.indexOf(value) !== -1); }
For loop
for(var i = 0, len = array1.length; i < len; i++) { var value = array1[i]; var result = false; for(var j = 0, len = array2.length; j < len; j++) { if(value === array2[j]) { result = true; break; } } }
For loop without break
for(var i = 0, len = array1.length; i < len; i++) { var value = array1[i]; var result = false; for(var j = 0, len = array2.length; j < len; j++) { if(value === array2[j]) { result = true; } } }
Array.indexOf() reversed
for(var i = 0, len = array2.length; i < len; i++) { var value = array2[i]; var result = (array1.indexOf(value) !== -1); }
Array.includes()
for(var i = 0, len = array1.length; i < len; i++) { var result = array2.includes(array1[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.indexOf()
For loop
For loop without break
Array.indexOf() reversed
Array.includes()

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Definition JSON**

The provided JSON represents the benchmark definition, which includes:

* `Name`: The name of the benchmark (not actually used in this example).
* `Description`: A brief description of the benchmark (also not used).
* `Script Preparation Code`: A JavaScript code that sets up an array (`array1`) with 20 elements and another array (`array2`) with 3 elements.
* `Html Preparation Code`: An empty string, indicating that no HTML preparation is required.

**Individual Test Cases**

There are four test cases:

### Test Case 1: Array.indexOf()

This test case uses the `indexOf()` method to search for an element in the `array2` array.

```javascript
for(var i = 0, len = array1.length; i < len; i++) {
  var value = array1[i];
  var result = (array2.indexOf(value) !== -1);
}
```

The purpose of this test case is to measure the performance of the `indexOf()` method.

**Pros and Cons:**

* Pros:
	+ Efficient use of iteration.
	+ Directly tests the `indexOf()` method.
* Cons:
	+ May not cover all edge cases (e.g., searching for an element that doesn't exist).

### Test Case 2: For loop

This test case uses a traditional `for` loop to iterate over the elements in `array1` and check if each element is present in `array2`.

```javascript
for(var i = 0, len = array1.length; i < len; i++) {
  var value = array1[i];
  var result = false;
  
  for(var j = 0, len = array2.length; j < len; j++) {
    if(value === array2[j]) {
      result = true;
      break;
    }
  }
}
```

The purpose of this test case is to measure the performance of a traditional `for` loop.

**Pros and Cons:**

* Pros:
	+ Covers all edge cases (e.g., searching for an element that doesn't exist).
	+ Can be used as a fallback if `indexOf()` is not supported.
* Cons:
	+ May be slower due to the nested loops.

### Test Case 3: For loop without break

This test case uses a traditional `for` loop to iterate over the elements in `array1` and check if each element is present in `array2`, but without using the `break` statement.

The purpose of this test case is to measure the performance of a traditional `for` loop without using the `break` statement.

**Pros and Cons:**

* Pros:
	+ Covers all edge cases (e.g., searching for an element that doesn't exist).
	+ Can be used as a fallback if `indexOf()` is not supported.
* Cons:
	+ May be slower due to the nested loops.

### Test Case 4: Array.includes()

This test case uses the `includes()` method to search for an element in the `array2` array.

```javascript
for(var i = 0, len = array1.length; i < len; i++) {
  var value = array1[i];
  var result = (array2.includes(value));
}
```

The purpose of this test case is to measure the performance of the `includes()` method.

**Pros and Cons:**

* Pros:
	+ Efficient use of iteration.
	+ Directly tests the `includes()` method.
* Cons:
	+ May not cover all edge cases (e.g., searching for an element that doesn't exist).

**Browser Results**

The benchmark results show the performance of each test case across different browsers:

| Test Case | Executions Per Second |
| --- | --- |
| Array.indexOf() | 3341791.25 |
| For loop | 11471107.0 |
| For loop without break | 11471107.0 |
| Array.includes() | 3083388.5 |

The results suggest that the `Array.indexOf()` method is the most efficient, followed by the `For loop` test case. The `For loop without break` and `Array.includes()` test cases are slower.

**Conclusion**

This benchmark demonstrates the performance of different methods for searching an element in a two-dimensional array across multiple browsers. The results suggest that the `Array.indexOf()` method is the most efficient, followed by the traditional `For loop`.

Latest run results:

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

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

Browser/OS: Firefox 58 on Windows

View result in a separate tab

Test name	Executions per second
Array.indexOf()	3341791.2 Ops/sec
For loop	16924544.0 Ops/sec
For loop without break	14566753.0 Ops/sec
Array.indexOf() reversed	11471107.0 Ops/sec
Array.includes()	3083388.5 Ops/sec

Related benchmarks:

tewgwggweg (version: 0)

gwegwgw

Comparing performance of: Array.indexOf() vs For loop vs For loop without break vs Array.indexOf() reversed vs Array.includes()

Created: 7 years ago by: Guest

Jump to the latest result

Array.indexOf()

For loop

For loop without break

Array.indexOf() reversed

Array.includes()

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