Benchmark: Promo Contains - MeasureThat.net

HTML Preparation code:

<html>
    <head>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>
        <script>
        underscore = _;
        </script>


        <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.12.0/lodash.min.js"></script>

        <script>
        lodash = _;
        </script>
    </head>
    <body>
    </body>
</html>

Script Preparation code:

var PromosArray = [
    {
        type: "regular",
        display: "$123.00"
    },
    {
        type: "markdown",
        display: "$100.00"
    },
    {
        type: "promo",
        display: "$80.00"
    }
];

var PromosObject = {
    regular: "$123.00",
    markdown: "$100.00",
    promo: "$80.00"
};

function contains(array, type) {
    for (var i = 0; i < array.length; i++) {
        if (array[i]["type"] === type) {
            return true;
        }
    }

    return false;
}

function testArrayContains() {
  contains(PromosArray, "regular");
  contains(PromosArray, "markdown");
  contains(PromosArray, "promo");
}

  
function testObjectContains() {
    if (PromosObject.regular) {
        // skip display logic
    }

    if (PromosObject.markdown) {
        // skip display logic
    }

    if (PromosObject.promo) {
        // skip display logic
    }
}

function testUnderscoreContains() {
    underscore.some(PromosArray, "type", "regular");
    underscore.some(PromosArray, "type", "markdown");
    underscore.some(PromosArray, "type", "promo");
}

function testLodashContains() {
    lodash.some(PromosArray, "type", "regular");
    lodash.some(PromosArray, "type", "markdown");
    lodash.some(PromosArray, "type", "promo");
}

Tests:

testArrayContains
testArrayContains();
testObjectContains
testObjectContains();
testUnderscoreContains
testUnderscoreContains();
testLodashContains
testLodashContains();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
testArrayContains
testObjectContains
testUnderscoreContains
testLodashContains

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript code is crucial for optimizing and improving application performance.

The provided benchmark definition JSON represents four test cases that check if certain types exist in arrays and objects.

**Array Search Methods**

1. **Vanilla `contains` function**: This method uses a simple `for` loop to iterate through the array and checks if the specified type exists.
	* Pros: Easy to implement, no additional dependencies required.
	* Cons: Can be slow for large arrays due to the linear search algorithm.
2. **Underscore.js `some` method**: This is a popular utility library that provides an efficient way to check if any elements in an array meet a condition.
	* Pros: Fast and optimized, part of a well-maintained library with good performance characteristics.
	* Cons: Requires including the Underscore.js library, which may add extra overhead.
3. **Lodash.js `some` method**: Similar to the Underscore.js implementation, but from another popular utility library.
	* Pros: Fast and optimized, part of a well-maintained library with good performance characteristics.
	* Cons: Requires including the Lodash.js library, which may add extra overhead.

**Object Search Methods**

1. **Vanilla `contains` function**: Similar to the array search method, but for objects.
	* Pros: Easy to implement, no additional dependencies required.
	* Cons: Can be slow due to the object property lookup algorithm.
2. **Underscore.js `some` method**: Again, using the same optimized implementation as before.
	* Pros: Fast and optimized, part of a well-maintained library with good performance characteristics.
	* Cons: Requires including the Underscore.js library, which may add extra overhead.

**Key Takeaways**

For array search methods, both the vanilla `contains` function and the `some` method from Underscore.js or Lodash.js provide good performance. Between these two, Underscore.js might have a slight edge due to its optimized implementation. However, this difference is likely to be negligible in practice.

For object search methods, the vanilla `contains` function should be avoided due to its slow performance. The `some` method from Underscore.js or Lodash.js is still a good choice, but again, Underscore.js might have a slight edge.

**Other Considerations**

* If you need to perform this type of search frequently in your application, it's worth considering using a more specialized data structure, such as a trie or a map.
* Make sure to consider the trade-offs between code simplicity and performance. While simple implementations like vanilla `contains` can be easy to understand and implement, they might not be the best choice for performance-critical parts of your application.

**Alternative Approaches**

If you're looking for alternative approaches, here are a few options:

1. **Use a library that provides optimized search methods**: Libraries like FastJS or jsSearch provide optimized search methods that can outperform vanilla implementations.
2. **Implement your own search method using a more efficient algorithm**: For example, you could use a binary search algorithm to find elements in an array.
3. **Use a caching mechanism to store results of previous searches**: This can help improve performance by reducing the number of times you need to perform a search.

Ultimately, the best approach will depend on your specific use case and requirements. Be sure to carefully evaluate different options and choose the one that best fits your needs.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36

Browser/OS: Chrome 68 on Mac OS X 10.13.5

View result in a separate tab

Test name	Executions per second
testArrayContains	2071636.6 Ops/sec
testObjectContains	3708594.2 Ops/sec
testUnderscoreContains	956350.6 Ops/sec
testLodashContains	796952.7 Ops/sec

Related benchmarks:

Promo Contains (version: 1)

Comparing performance of: testArrayContains vs testObjectContains vs testUnderscoreContains vs testLodashContains

Created: 8 years ago by: Registered User

Jump to the latest result

testArrayContains

testObjectContains

testUnderscoreContains

testLodashContains

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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