Merge pull request #60 from mattaylor/prefix_methods

Prefix methods

Author: mattaylor

README.md

@@ -4,10 +4,16 @@ Objix is a delightfully convienient, high performance, zero dependency and super
 
 The functions are all non enumerable and include copies of Object class methods and Array prototype methods applied to the values of the object as well others to delete keys, stringify, promisify, memoize, compare, split/join objects, check types, log messages and trapping/observing property assignments.
 
-This library is highly optimised with zero copy operations where possible. The source is only 3.5kb (2.6kb minified) which allows for fast loading and easy integration without additional compilation or tree shaking. There is however limited type checking to guard against unwanted side effects, and there may be some undiscovered edge case that do not behave as expected. Performance in most cases is significantly faster than `lodash` equivalents especially when working with small objects. For example `ob.map(fn)` is typically over 65% faster than `_.mapValues(ob, fn)` and some operations such as `pick` can be several thousand times quicker according to simple [benchmarks](docs/bench.md).
+This library is highly optimised with zero copy operations where possible. The source is only 3.8kb (2.8kb minified) which allows for fast loading and easy integration without additional compilation or tree shaking. Performance in most cases is significantly faster than `lodash` equivalents especially when working with small objects. For example `ob._map(fn)` is typically over 65% faster than `_.mapValues(ob, fn)` and some operations such as `pick` can be several thousand times quicker according to simple [benchmarks](docs/bench.md).
 
 Interactive docs and demos are availble on https://objix.dev/#/docs/api.
 
+## Upgrading from 1.0
+
+Objix 2.0 now prefixes all prototype methods with '_'. This avoids name clashes with built in methods and reduces unwanted side effects and compatibility issues inherent in the 1.x releases. 
+
+The `_size()` method is now renamied to `_len()`.
+
 ## Getting Started - Node
 
 - Install:
@@ -20,7 +26,7 @@ Interactive docs and demos are availble on https://objix.dev/#/docs/api.
 
   ```javascript
   require('objix')
-  var o = { a: 1 }.map(v => v + 1).log()
+  var o = { a: 1 }._map(v => v + 1).log()
   ```
 
 ## Getting Started - Browser
@@ -29,7 +35,7 @@ Interactive docs and demos are availble on https://objix.dev/#/docs/api.
 <script src="https://cdn.jsdelivr.net/gh/mattaylor/objix@main/objix.min.js"></script>
 
 <script>
-  var o = { a: 1 }.map(v => v + 1).log()
+  var o = { a: 1 }._map(v => v + 1)._log()
 </script>
 ```
 
@@ -65,7 +71,7 @@ The following methods are availble to all Objects via protoype inheritence, unle
 | [`split`](docs/api.md#split)           | Split `this` into multiple objects from array property values                               |
 | [`contains`](docs/api.md#contains)     | Check if `this` contains all entries from another object to a given depth.                  |
 | [`eq`](docs/api.md#eq)                 | Compare key and value identity between `this` and other objects to a given depth            |
-| [`size`](docs/api.md#size)             | Return number of entres in `this`.                                                          |
+| [`len`](docs/api.md#len)             | Return number of entres in `this`.                                                          |
 | [`keyBy`](docs/api.md#keyBy)           | Re-index values of this `this` using a given key path                                    |
 | [`memo`](docs/api.md#memo)             | Memoize `this` as a function with configurable result cache expiration                      |
 | [`bind`](docs/api.md#bind)             | Assign a function as a method of `this` with optional memoization                           |
@@ -83,10 +89,10 @@ Most of these function return objects including those modifying `this` and so ca
 
 ```javascript
 var o = { a: 0, b: 1, c: 2 }
-  .filter(v => v > 0)
-  .log('POSITIVE') // 2022-10-07T00:00 POSITIVE { b: 1, c: 2 }
-  .map(v => v + 1)
-  .log('INCREMENT') // 2022-10-07T00:00 INCREMENT { b: 2, c: 3 }
+  ._filter(v => v > 0)
+  ._log('POSITIVE') // 2022-10-07T00:00 POSITIVE { b: 1, c: 2 }
+  ._map(v => v + 1)
+  ._log('INCREMENT') // 2022-10-07T00:00 INCREMENT { b: 2, c: 3 }
 ```
 
 </div>
@@ -97,8 +103,8 @@ All functions documented below are also callable with a '\_' prefix to the funct
 This can help ensure that the function is callable when overwritten by other object property assignments.
 
 ```javascript
-var o = { a: 1 }.size() == { a: 1 }._size() //true
-var o = { a: 1 }.find(v => v) == { a: 1 }._find(v => v) //true
+var o = { a: 1 }._len() == { a: 1 }._len() //true
+var o = { a: 1 }._find(v => v) == { a: 1 }._find(v => v) //true
 ```
 
 ## Simple Classes

bench.js

@@ -15,8 +15,8 @@ Calculate run time for *heats* batches of *iters* executions of each function, w
 Each batch run also includes a 100 iteration warmup verifying the results of the function against objix
 */
 function compare(funcs) {
-  let hist = funcs.map(v => null), start
-  for (let r = 0; r < heats; r++) for (let [key,fun] of _.shuffle(funcs.entries())) if (fun) {
+  let hist = funcs._map(v => null), start
+  for (let r = 0; r < heats; r++) for (let [key,fun] of _.shuffle(funcs._entries())) if (fun) {
     for (let i = 0; i < 100; i++) assert.deepEqual(funcs.objix(), fun(), fun)
     if (!hist[key]) hist[key] = hdr.build()
     start = performance.now()
@@ -31,7 +31,7 @@ function compare(funcs) {
     [k + ' Inc', round((100*v.mean/hist.lodash.mean)-100)],
   ])
   */
-  let res = hist.map(v => v?.mean)
+  let res = hist._map(v => v?.mean)
   res['% Inc'] = round(100*(hist.objix.mean - hist.lodash.mean)/hist.lodash.mean)
   //res['% Err'] = round(100*(hist.objix.stddev + hist.lodash.stddev)/(hist.objix.mean + hist.lodash.mean))
   return res
@@ -41,12 +41,12 @@ function report(title, ob) {
   console.log(title)
   console.table({
     Map: {
-      objix : () => ob.map(v => v+1),
+      objix : () => ob._map(v => v+1),
       lodash: () => _.mapValues(ob, v => v+1),
       vanilla: () => Object.fromEntries(Object.entries(ob).map(([k,v]) => [k, v+1])),
     },
     Pick: {
-      objix:  () => ob.pick(v => v == 1),
+      objix:  () => ob._pick(v => v == 1),
       lodash: () => _.pickBy(ob, v => v == 1),
       vanilla: () => Object.fromEntries(Object.entries(ob).flatMap(([k,v]) => v == 1 ? [[k,v]] : [])),
     },
@@ -58,12 +58,12 @@ function report(title, ob) {
     },
     */
     Find: {
-      objix: () => ob.find(v => v == 1),
+      objix: () => ob._find(v => v == 1),
       lodash: () => _.findKey(ob, v => v == 1),
       vanilla: () => { for (let [k,v] of Object.entries(ob)) if (v == 1) return k },
     },
     FlatMap: {
-      objix: () => ob.flatMap((k,v) => [[k,v],[k+1, v+1]]),
+      objix: () => ob._flatMap((k,v) => [[k,v],[k+1, v+1]]),
       lodash: () => Object.fromEntries(_.flatMap(ob, (v,k) => [[k,v],[k+1, v+1]])),
       /*
       _lodash: () => {
@@ -75,45 +75,45 @@ function report(title, ob) {
       //vanilla: () => { for (let [k,v] of Object.entries(ob)) if (v == 1) return k },
     },
     Has: {
-      objix:  () => ob.has(3),
+      objix:  () => ob._has(3),
       lodash: () => _.includes(ob, 3),
       vanilla: () => Object.values(ob).includes(3)
     },
     KeyBy: {
-      objix:  () => [{a:1},{a:2},{a:3}].keyBy('a'),
+      objix:  () => [{a:1},{a:2},{a:3}]._keyBy('a'),
       lodash: () => _.keyBy([{a:1},{a:2},{a:3}], 'a'),
     },
     Equals: {
-      objix: () => ob.eq(ob.clone(), -1),
-      lodash: () => _.isEqual(ob, ob.clone()),
-      vanilla: () => { try { return assert.deepEqual(ob,ob.clone()) || true } catch { return false }},
+      objix: () => ob._eq(ob._clone(), -1),
+      lodash: () => _.isEqual(ob, ob._clone()),
+      vanilla: () => { try { return assert.deepEqual(ob,ob._clone()) || true } catch { return false }},
     },
     Clone: {
-      objix:  () => ob.clone(),
+      objix:  () => ob._clone(),
       lodash: () => _.clone(ob),
       vanilla: () => Object.assign({}, ob), //No Construcotrs!
     },
     Deep: {
-      objix:  () => ob.clone(-1),
+      objix:  () => ob._clone(-1),
       vanilla: typeof structuredClone !== 'undefined' ? () => structuredClone(ob) : null,
       lodash: () => _.cloneDeep(ob),
     },
     Extend: { 
-      objix: () => ob.extend({a: 1, b: 2, c: 3}),
+      objix: () => ob._extend({a: 1, b: 2, c: 3}),
       lodash: () => _.defaults(ob, {a: 1, b:2, c: 2}),
       vanilla: () => Object.assign({}, {a: 1, b: 2, c: 3}, ob)
     },
     Some: {
-      objix: () => ob.some(v => v == 'x'),
+      objix: () => ob._some(v => v == 'x'),
       vanilla: () => Object.values(ob).some(v => v == 'x'),
       lodash: () => _.some(_.values(ob), v => v == 'x'),
     },
     Every: {
-      objix: () => ob.every(v => v),
+      objix: () => ob._every(v => v), 
       lodash:  () => _.every(_.values(ob), v => v),
       vanilla: () => Object.values(ob).every(v => v),
     }
-  }.map(compare))
+  }._map(compare))
 }
 const d1 = new Date()
 const d2 = new Date()

bun-repl

@@ -0,0 +1 @@
+console.log('hello')