Benchmark: Fuzzy search with fuzzysearch | Vanilla - Ramda - Lodash

HTML Preparation code:

<script src="//unpkg.com/ramda@0.26.1/dist/ramda.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/lodash@4.17.15/lodash.min.js"></script>

Script Preparation code:

function fuzzysearch (needle, haystack) {
  var hlen = haystack.length;
  var nlen = needle.length;
  if (nlen > hlen) {
    return false;
  }
  if (nlen === hlen) {
    return needle === haystack;
  }
  outer: for (var i = 0, j = 0; i < nlen; i++) {
    var nch = needle.charCodeAt(i);
    while (j < hlen) {
      if (haystack.charCodeAt(j++) === nch) {
        continue outer;
      }
    }
    return false;
  }
  return true;
}

var letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

var getPositions = l => {
    let positions = []
    
    for (let i = 0; i < l; i++) {
        let position = Math.floor(Math.random() * 26 + 1)
        positions.push(position)
    }

    return positions
}

var wordLength = () => Math.floor(Math.random() * 15 + 5)

var createWord = ps => ps.map(p => letters[p]).join('')

var getWords = l => {
    let words = []

    for (let i = 0; i < l; i++) {
        let positions = getPositions(wordLength())
        let word = createWord(positions)
        words.push(word)
    }

    return words
}

var reducer = (a, c) => {
  if (fuzzysearch(term, c)) {
  	a.push(c)
  }
  
  return a
}

var filtering = w => fuzzysearch(term, w)

var words = getWords(100000)
var term = 'omg'

Tests:

Vanilla filter
words.filter(filtering)
Vanilla reduce
words.reduce(reducer, [])
Ramda filter
R.filter(filtering, words)
Ramda reduce
R.reduce(reducer, [], words)
Lodash filter
_.filter(words, filtering)
Lodash reduce
_.reduce(words, reducer, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Vanilla filter
Vanilla reduce
Ramda filter
Ramda reduce
Lodash filter
Lodash reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 122 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Vanilla filter	63.5 Ops/sec
Vanilla reduce	65.4 Ops/sec
Ramda filter	67.6 Ops/sec
Ramda reduce	65.4 Ops/sec
Lodash filter	65.1 Ops/sec
Lodash reduce	68.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of different JavaScript libraries and approaches can be fascinating.

**Benchmark Overview**

The provided benchmark tests four approaches to search for words in an array: filtering, reducing, Ramda's `filter` and `reduce`, and Lodash's `filter` and `reduce`. The benchmark uses a custom `fuzzysearch` function to determine if a word is similar to the target term "omg".

**Approaches Compared**

1. **Filtering**: Using the `Array.prototype.filter()` method, which returns a new array with all elements that pass the test implemented by the provided function.
2. **Reducing**: Using the `Array.prototype.reduce()` method, which applies a function to each element of the array and reduces it to a single value (in this case, an array of matching words).
3. **Ramda Filter** (`R.filter()`): Ramda's implementation of the filtering function.
4. **Lodash Filter** (`_.filter()`): Lodash's implementation of the filtering function.

**Pros and Cons**

*   **Filtering**:
    *   Pros: Simple, easy to understand, and implemented in every JavaScript engine.
    *   Cons: Creates a new array, which can be memory-intensive for large datasets.
*   **Reducing**:
    *   Pros: Can be more efficient than filtering, as it only iterates over the array once.
    *   Cons: Returns an array of results, which may require additional processing.
*   **Ramda Filter** (`R.filter()`):
    *   Pros: Optimized for performance and concise implementation.
    *   Cons: Requires importing Ramda library, which may not be necessary for simple use cases.
*   **Lodash Filter** (`_.filter()`):
    *   Pros: Built-in in Lodash, so no additional imports are required.
    *   Cons: May have slightly slower performance compared to Ramda's implementation.

**Test Results**

The provided test results show that:

*   Lodash's `reduce` approach has the highest execution rate (around 67-68 executions per second).
*   Ramda's `filter` and `reduce` approaches are close in performance, with slight variations between them.
*   Vanilla JavaScript's `filter` and `reduce` approaches have lower execution rates (around 63-65 executions per second).

Keep in mind that these results may vary depending on the specific use case and environment.

**Conclusion**

In summary, this benchmark highlights the importance of choosing an efficient algorithm for your specific use case. If you need to process large datasets, Ramda's `filter` and `reduce` approaches might be a good choice due to their optimized performance. However, if memory is a concern and simplicity is key, vanilla JavaScript's filtering approach might still be a viable option.

Related benchmarks:

Fuzzy search with fuzzysearch | Vanilla - Ramda - Lodash (version: 2)

Fuzzy search with fuzzysearch (https://github.com/bevacqua/fuzzysearch) using filter and reduce with Vanilla, Ramda, and Lodash.

Comparing performance of: Vanilla filter vs Vanilla reduce vs Ramda filter vs Ramda reduce vs Lodash filter vs Lodash reduce

Created: 6 years ago by: Registered User

Jump to the latest result

Vanilla filter

Vanilla reduce

Ramda filter

Ramda reduce

Lodash filter

Lodash reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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