Added benchmark

Author: BadIdeaException

README.md

@@ -22,6 +22,8 @@ you can simply write
 
 [API](#api)
 
+[Performance considerations](#performance-considerations)
+
 [Security considerations](#security-considerations)
 
 ## Usage
@@ -139,7 +141,7 @@ Operator | Condition looks like | Meaning
 ### compile
 
 Compiles the given `selector`. The compiled selector can be passed to `apply`, `get`, and `set` instead of the original string.
-If you intend to re-use a given selector for multiple operations, pre-compiling it gives a performance boost.
+If you intend to re-use a given selector for multiple operations, pre-compiling it gives a significant performance boost.
 
 The returned compiled selector also has methods `apply`, `get`, and `set`, so instead of calling `get(compiledSelector, obj)` you can
 also do `compiledSelector.get(obj)`.
@@ -217,6 +219,24 @@ Otherwise, this function follows the same rules as [apply](#apply).
 Returns **any** The new values of the selected properties. Unless collating, the length of the result gives an indication of
 how many properties matched the selector.
 
+## Performance considerations
+
+There are a few other libraries that do the same thing, although none offer the features and expressive powers of this one. In particular, none allow using wildcards in selectors, conditions, or application of arbitrary functions - that's why I wrote this in the first place. That power comes at a price, though, and that price is speed. Below are benchmark results comparing `object-selectors` with some of the competitors.
+
+Library | ops/sec
+---|---:
+object-selectors (string selector) | 91,700 ops/sec ±10.38% (85 runs sampled)
+object-selectors (pre-compiled) | 1,041,568 ops/sec ±2.11% (90 runs sampled)
+[easy-object-selector](https://github.com/deltavi/easy-object-selector) | 4,080,250 ops/sec ±1.58% (93 runs sampled)
+[object-path](https://github.com/mariocasciaro/object-path) | 997,770 ops/sec ±6.47% (81 runs sampled)
+[dot-prop](https://github.com/sindresorhus/dot-prop) | 3,310,430 ops/sec ±8.16% (70 runs sampled)
+[pathval](https://github.com/chaijs/pathval) | 275,348 ops/sec ±4.44% (64 runs sampled)
+[getvalue](https://github.com/jonschlinkert/get-value) | 2,342,407 ops/sec ±3.62% (84 runs sampled)
+
+The key take aways:
+1. If you only need to access simple nested properties in objects and performance is a concern, you should probably go with a different library. 
+2. Pre-compiling a repeatedly-used selector gives a performance gain of about factor 100.
+
 ## Security considerations
 
 This package is based on a technique called *parsing expression grammar* (PEG) using [Peggy](https://peggyjs.org/) to parse and evaluate selectors. It does not use `eval`, and is therefore safe from the security concerns around code injection arising from it. This means it is safe to pass user content as selectors for read-only operations.

bench.js

@@ -0,0 +1,41 @@
+import Benchmark from 'benchmark';
+import { get, compile } from './applicators.js';
+import easyobjectselector from 'easy-object-selector';
+import objectpath from 'object-path';
+import * as dotprop from 'dot-prop';
+import * as pathval from 'pathval';
+import getvalue from 'get-value';
+
+const selector = 'a.b.c.d';
+const compiled = compile(selector);
+const obj = { a: { b: { c: { d: 2 } } } }
+
+new Benchmark.Suite('object-selectors vs. easy-object-selector')
+	.add('object-selectors (string)', function() {
+		get(selector, obj)
+	})
+	.add('object-selectors (pre-compiled)', function() {
+		get(compiled, obj)
+	})
+	.add('easy-object-selector', function() {
+		easyobjectselector.select(obj, selector);
+	})
+	.add('object-path', function() {
+		objectpath.get(obj, selector);
+	})
+	.add('dot-prop', function() {
+		dotprop.getProperty(obj, selector);
+	})
+	.add('pathval', function() {
+		pathval.getPathValue(obj, selector);
+	})
+	.add('getvalue', function() {
+		getvalue(obj, selector);
+	})
+	.on('cycle', function(event) {
+		console.log(String(event.target));
+	})
+	.on('complete', function() {
+		console.log('Fastest is ' + this.filter('fastest').map('name'));
+	})
+	.run();

package-lock.json

@@ -35,16 +35,22 @@
   "devDependencies": {
     "@peggyjs/eslint-parser": "^1.2.1",
     "@peggyjs/eslint-plugin": "^1.1.0",
+    "benchmark": "^2.1.4",
     "chai": "^4.3.8",
     "documentation": "^14.0.2",
+    "dot-prop": "^8.0.2",
+    "easy-object-selector": "^1.3.0",
     "eslint": "^8.48.0",
     "eslint-plugin-chai-expect": "^3.0.0",
     "eslint-plugin-mocha": "^10.1.0",
     "esmock": "^2.3.8",
+    "get-value": "^3.0.1",
     "gulp": "^4.0.2",
     "gulp-rename": "^2.0.0",
     "gulp-tap": "^2.0.0",
     "mocha": "^10.2.0",
+    "object-path": "^0.11.8",
+    "pathval": "^2.0.0",
     "peggy": "^3.0.2",
     "sinon": "^15.2.0",
     "sinon-chai": "^3.7.0"