Benchmark: Ramda's `where` vs. my `whereAll` - Part 1 - Single Property Tests

HTML Preparation code:

<script src="https://unpkg.com/ramda@0.23.0/dist/ramda.js"></script>

Script Preparation code:

// Sort of like a recursive version of Ramda's `where` (http://ramdajs.com/docs/#where).
var whereAll = R.curry((spec, obj) => {
  if (typeof obj === "undefined") {
    if (spec === null || typeof spec === "boolean") {
      return !spec
    }
    return false
  } else if (spec === false) {
    return false
  }
  var output = true
  R.forEachObjIndexed((v, k) => {
    if (v === null || typeof v === "boolean" || R.keys(v).length) {
      if (!whereAll(v, obj[k])) {
        output = false
      }
    } else if (!v(obj[k])) {
      output = false
    }
  }, spec)
  return output
})

// -----------------------------------------------------------------------------

var data = [
  '{ Z: 1 }',
  "{ q: undefined }",
  "{ q: null }",
  "{ q: false }",
  "{ q: true }",
  "{ q: Infinity }",
  "{ q: 1 }",
  "{ q: 0 }",
  "{ q: NaN }",
  '{ q: "" }',
]

var specs = [
  "{ q: null }",
  "{ q: true }",
  "{ q: false }",
  "{ q: R.identity }",
  "{ q: R.equals(true) }",
  "{ q: R.equals(false) }",
  "{ q: R.equals(null) }",
  "{ q: R.equals(undefined) }",
  "{ q: R.identical(true) }",
  "{ q: R.identical(false) }",
  "{ q: R.identical(null) }",
  "{ q: R.identical(undefined) }",
  "{ q: R.always(true) }",
  "{ q: R.always(false) }",
  "{ q: R.always(null) }",
  "{ q: R.always(undefined) }",
  "{ q: Infinity }",
  "{ q: 1 }",
  "{ q: 0 }",
  "{ q: NaN }",
  '{ q: "" }',
  "{ q: [] }",
  "{ q: {} }",
  "{ q: undefined }",
]

// In the truth table that gets generated, `false` is omitted and errors
// are shown as `⊥` for sake of readability.
function generateTruthTable(f) {
  var table = {}
  for (var i in specs) {
    var row = {}
    var spec = eval("(" + specs[i] + ")")
    for (var j in data) {
      var r
      try {
        r = f(spec, eval("(" + data[j] + ")"))
      } catch (_) {
        r = "⊥"
      }
      if (r) row[data[j]] = r
    }
    table[specs[i]] = row
  }
  return table
}

Tests:

Using `R.where`
generateTruthTable(R.where)
Using `whereAll`
generateTruthTable(whereAll)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using `R.where`
Using `whereAll`

Fastest: N/A

Slowest: N/A

ⓘ Get performance results from real users on your website with Request Metrics.

Website Performance Monitoring by Request Metrics

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36

Browser/OS: Chrome 76 on Windows

View result in a separate tab

Test name	Executions per second
Using `R.where`	338.4 Ops/sec
Using `whereAll`	406.6 Ops/sec

Ramda's `where` vs. my `whereAll` - Part 1 - Single Property Tests (version: 53)

Comparing performance of: Using `R.where` vs Using `whereAll`

Created: 7 years ago by: Registered User

Jump to the latest result

Using `R.where`

Using `whereAll`

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A