[Circular] and more methods

Author: imnull

diff.js

@@ -1,11 +1,16 @@
 const ostr = Object.prototype.toString;
 const tname = v => ostr.call(v).slice(8, -1);
-const isEmptyObj = v => {
-    for(let p in v){
-        return false;
-    }
-    return true;
-}
+const object_keys = (...objs) => objs
+    .reduce((a, b) => a.concat(Object.keys(b)), [])
+    .filter((k, i, kk) => kk.indexOf(k) === i)
+    ;
+
+// const for_up_loop = (len, fn, i, up = 1) => {
+//     up = Math.max(1, up);
+//     for(; i < len; i += up){
+//         fn(i, len);
+//     }
+// }
 
 const TYPE = (a, b) => {
     let n = tname(a);
@@ -41,22 +46,23 @@ const contains = (a, b, trap = []) => {
     if(t === '*' || !(t in CONTAINS)){
         return a === b;
     } else {
+        trap.push(b);
         return CONTAINS[t](a, b, trap)
     }
 };
 
 const CLONE = {
     'Array': (v, trap) => {
         if(trap.indexOf(v) > -1){
-            return [ ...v ];
+            return v;
         } else {
             trap.push(v);
             return v.map(vv => clone(vv, trap));
         }
     },
     'Object': (v, trap) => {
         if(trap.indexOf(v) > -1){
-            return { ...v };
+            return v;
         } else {
             trap.push(v);
             let o = {};
@@ -68,34 +74,41 @@ const CLONE = {
 const clone = (v, trap = []) => {
     let t = tname(v);
     if(t in CLONE){
+        trap.push(v);
         return CLONE[t](v, trap);
     }
     return v;
 };
 
-const DIFF_NONE = Symbol('-diff-none-');
+// const DIFF_NONE = Symbol('-diff-none-');
+const DIFF_NONE = undefined;
 const DIFF = {
     'Array': (a, b, trap) => {
         if(trap.indexOf(b) > -1){
             return DIFF_NONE;
         }
         trap.push(b);
-        let i = 0, len = Math.max(a.length, b.length), o = [], none = true;
+        let i = 0, len = Math.max(a.length, b.length), o = Array(len), none = true;
         for(; i < len; i++){
-            o.push(diff(a[i], b[i], trap))
+            let r = diff(a[i], b[i], trap);
+            if(r !== DIFF_NONE){
+                none = false;
+                o[i] = r;
+            }
+            // o.push(r)
         };
-        while(o[o.length - 1] === DIFF_NONE){
-            o.pop();   
-        }
-        return o.length > 0 ? o : DIFF_NONE;
+        // while(o[o.length - 1] === DIFF_NONE){
+        //     o.pop();   
+        // }
+        return none ? DIFF_NONE : o;
     },
     'Object': (a, b, trap) => {
         if(trap.indexOf(b) > -1){
             return DIFF_NONE;
         }
         trap.push(b);
         let o = {}, none = true;
-        let keys = [...Object.keys(a), ...Object.keys(b)].filter((k, i, kk) => kk.indexOf(k) === i);
+        let keys = object_keys(a, b);
         keys.forEach(i => {
             if(!contains(a[i], b[i])){
                 let r = diff(a[i], b[i], trap);
@@ -127,6 +140,88 @@ const diff = (a, b, trap = []) => {
     return r;
 }
 
+const INTERSECT = {
+    'Array': (a, b, trap) => {
+        if(trap.indexOf(b) > -1){
+            return b;
+        }
+        trap.push(b);
+        let _a = clone(a);
+        b.forEach((v, i) => intersect(_a[i], v, trap));
+        return _a;
+    },
+    'Object': (a, b, trap) => {
+        if(trap.indexOf(b) > -1){
+            return b;
+        }
+        trap.push(b);
+        let o = {};
+        for(let i in b){
+            o[i] = intersect(a[i], b[i], trap);
+        }
+        return o;
+    }
+};
+
+const intersect = (a, b, trap = []) => {
+
+    let _b = diff(a, b);
+    if(_b === DIFF_NONE){
+        return DIFF_NONE;
+    }
+    let t = TYPE(a, _b);
+    if(t === '*' || !(t in INTERSECT)){
+        return _b;
+    } else {
+        return INTERSECT[t](a, _b, trap)
+    }
+}
+
+const ASSIGN = {
+    'Array': (a, b, trap) => {
+        if(trap.indexOf(b) > -1){
+            return b;
+        }
+        trap.push(b);
+        for(let i = 0, len = Math.max(a.length, b.length); i < len; i++){
+            a[i] = assign2(a[i], b[i], trap);
+        }
+        return a;
+    },
+    'Object': (a, b, trap) => {
+        if(trap.indexOf(b) > -1){
+            return b;
+        }
+        trap.push(b);
+        object_keys(a, b).forEach(i => a[i] = assign2(a[i], b[i], trap));
+        return a;
+    }
+};
+
+const assign2 = (a, b, trap = []) => {
+    if(b === DIFF_NONE || typeof(b) === 'undefined'){
+        return a;
+    }
+    let t = TYPE(a, b);
+    if(t === '*' || !(t in ASSIGN)){
+        return clone(b);
+    } else {
+        trap.push(b);
+        return ASSIGN[t](a, b, trap)
+    }
+};
+
+const assign = (a, ...args) => {
+    if(args.length < 1){
+        return a;
+    } else {
+        let trap = [];
+        return args.reduce((A, B) => {
+            return assign2(A, B, trap)
+        }, a);
+    }
+}
+
 module.exports = {
-    contains, clone, diff
+    contains, clone, diff, intersect, assign
 };

test.js

@@ -1,20 +1,33 @@
-const { diff, clone } = require('./diff');
+const { diff, clone, intersect, assign } = require('./diff');
 
-const obj = [1,2, {'a': [{bbb:3}, [1,{aaa:2},2,3,]]}];
-const _obj = clone(obj);
-// obj.push(3)
-obj.push(4)
-_obj.push(3)
-// console.log(obj === _obj, contains(obj, _obj), JSON.stringify(_obj), JSON.stringify(obj))
-
-let a = { a: 1, b: 2, c: { a: 1, b: [1,2,3] } };
+let a = { a: 1, b: 2 };
 a.z = a;
-let b = { a: 1, b: 2, c: { a: 1, b: [1,2,4] } };
-let c = { a: 1, b: 2, c: { a: 1, b: [1,2,3] } };
-c.z = b;
+let b = { a: 1, b: 3 };
 b.z = b;
-// console.log(clone(a))
-console.log(diff([1,2,3], [1,3,3]))
-console.log(diff({ a: [1,2,3] }, { a: [1,2,3] }))
-console.log(diff(a, b))
-console.log(diff(obj, _obj))
+console.log('clone', clone(a));
+console.log('clone', clone(b));
+
+console.log('diff', diff(a, b));
+console.log('diff', diff([1,2,3], [1,3,3,7]));
+console.log('diff', diff({a:1,b:2}, {a:1,b:3}));
+console.log('diff', diff({a:1,b:2, c: [1,2,3, { a: 111, b: 222 },4]}, {a:1,b:3, c: [2,2,3, { a: 111, c: 333 },4,5]}));
+
+console.log('intersect', intersect(a, b));
+console.log('intersect', intersect([1,2,3], [1,3,3,7]));
+console.log('intersect', intersect({a:1,b:2}, {a:1,b:3}));
+console.log('intersect', intersect({a:1,b:2, c: [1,2,3, { a: 111, b: 222 },4]}, {a:1,b:3, c: [2,2,3, { a: 111, c: 333 },4,5]}));
+
+console.log('assign', assign([1,2,3], [1,3,3,7]));
+console.log('assign', assign({a:1,b:2}, {a:1,b:3}));
+console.log('assign', assign({a:1,b:2, c: [1,2,3, { a: 111, b: 222 },4]}, {a:1,b:3, c: [2,2,3, { a: 111, c: 333 },4,5]}));
+console.log('assign', assign(a, b, a, b));
+
+
+// let aa = { a: 1 };
+// aa.z = aa;
+// let bb = assign(aa, { b: 2, d: [1,2,3] }, { b: 3, c: 4, d: [-11,12] });
+
+// console.log(bb);
+// console.log(aa)
+// console.log(aa === bb);
+