From 16fc1157644fa20c59c333ff4cc3e112d244244f Mon Sep 17 00:00:00 2001
From: 332383124 <332383124@qq.com>
Date: Thu, 24 May 2018 16:14:43 +0800
Subject: [PATCH 1/4] make it works with array

---
 index.js |  26 ++-
 test.js  | 619 +++++++++++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 556 insertions(+), 89 deletions(-)

diff --git a/index.js b/index.js
index c5dc494..5b39a99 100644
--- a/index.js
+++ b/index.js
@@ -13,7 +13,8 @@ var typeOf = require('kind-of');
 
 function assign(target/*, objects*/) {
   target = target || {};
-  var len = arguments.length, i = 0;
+  var len = arguments.length,
+    i = 0;
   if (len === 1) {
     return target;
   }
@@ -44,6 +45,18 @@ function extend(target, obj) {
           target[key] = val;
         }
         target[key] = assign(target[key] || {}, val);
+      } else if (isArray(val)) {
+        let array = [];
+        for (let i = 0; i < val.length; i++) {
+          if (isPrimitive(val[i])) {
+            array.push(val[i]);
+          } else {
+            array.push(assign({}, val[i]));
+          }
+        
+        }
+        target[key] = array;
+
       } else {
         target[key] = val;
       }
@@ -59,13 +72,22 @@ function extend(target, obj) {
 function isObject(obj) {
   return typeOf(obj) === 'object' || typeOf(obj) === 'function';
 }
+/**
+ * Returns true if the object is an array.
+ */
+function isArray(obj) {
+  return typeOf(obj) === 'array';
+}
 
 /**
  * Returns true if the given `key` is an own property of `obj`.
  */
 
 function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+  return Object
+    .prototype
+    .hasOwnProperty
+    .call(obj, key);
 }
 
 /**
diff --git a/test.js b/test.js
index 9f6a72c..ef3b726 100644
--- a/test.js
+++ b/test.js
@@ -5,27 +5,87 @@ var assert = require('assert');
 var assign = require('./');
 
 describe('assign', function() {
+
   it('should deeply assign properties of objects to the first object:', function() {
-    var one = {b: {c: {d: 'e'}}};
-    var two = {b: {c: {f: 'g', j: 'i'}}};
-    assert.deepEqual(assign(one, two), {b: {c: {d: 'e', f: 'g', j: 'i'}}});
+    var one = {
+      b: {
+        c: {
+          d: 'e'
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          f: 'g',
+          j: 'i'
+        }
+      }
+    };
+    assert.deepEqual(assign(one, two), {
+      b: {
+        c: {
+          d: 'e',
+          f: 'g',
+          j: 'i'
+        }
+      }
+    });
   });
 
   it('should extend properties onto a function:', function() {
     function target() {}
-    var one = {b: {c: {d: 'e'}}};
-    var two = {b: {c: {f: 'g', j: 'i'}}};
+    var one = {
+      b: {
+        c: {
+          d: 'e'
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          f: 'g',
+          j: 'i'
+        }
+      }
+    };
     assign(target, one, two);
-    assert.deepEqual(target.b, {c: {d: 'e', f: 'g', j: 'i'}});
+    assert.deepEqual(target.b, {
+      c: {
+        d: 'e',
+        f: 'g',
+        j: 'i'
+      }
+    });
   });
 
   it('should extend deeply nested functions:', function() {
     var fn = function() {};
     var target = {};
-    var one = {b: {c: {d: fn}}};
-    var two = {b: {c: {f: 'g', j: 'i'}}};
+    var one = {
+      b: {
+        c: {
+          d: fn
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          f: 'g',
+          j: 'i'
+        }
+      }
+    };
     assign(target, one, two);
-    assert.deepEqual(target.b, {c: {d: fn, f: 'g', j: 'i'}});
+    assert.deepEqual(target.b, {
+      c: {
+        d: fn,
+        f: 'g',
+        j: 'i'
+      }
+    });
   });
 
   it('should extend deeply nested functions with properties:', function() {
@@ -34,91 +94,255 @@ describe('assign', function() {
     fn.bar = 'bar';
 
     var target = {};
-    var one = {b: {c: {d: fn}}};
-    var two = {b: {c: {f: 'g', j: 'i'}}};
+    var one = {
+      b: {
+        c: {
+          d: fn
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          f: 'g',
+          j: 'i'
+        }
+      }
+    };
     assign(target, one, two);
-    assert.deepEqual(target.b, {c: {d: fn, f: 'g', j: 'i'}});
+    assert.deepEqual(target.b, {
+      c: {
+        d: fn,
+        f: 'g',
+        j: 'i'
+      }
+    });
   });
 
   it('should extend deeply nested functions with nested properties:', function() {
     var fnOne = function() {};
-    fnOne.foo = {y: 'y'};
-    fnOne.bar = {z: 'z'};
+    fnOne.foo = {
+      y: 'y'
+    };
+    fnOne.bar = {
+      z: 'z'
+    };
 
     var fnTwo = function() {};
-    fnTwo.foo = {w: 'w'};
-    fnTwo.bar = {x: 'x'};
+    fnTwo.foo = {
+      w: 'w'
+    };
+    fnTwo.bar = {
+      x: 'x'
+    };
 
     var target = {};
-    var one = {a: {fn: fnOne}};
-    var two = {a: {fn: fnTwo}};
+    var one = {
+      a: {
+        fn: fnOne
+      }
+    };
+    var two = {
+      a: {
+        fn: fnTwo
+      }
+    };
 
     var actual = assign(target, one, two).a.fn;
-    assert.deepEqual(actual.foo, {y: 'y', w: 'w' });
-    assert.deepEqual(actual.bar, { z: 'z', x: 'x' });
+    assert.deepEqual(actual.foo, {
+      y: 'y',
+      w: 'w'
+    });
+    assert.deepEqual(actual.bar, {
+      z: 'z',
+      x: 'x'
+    });
   });
 
   it('should extend properties from functions to functions:', function() {
     function target() {}
     function one() {}
     function two() {}
-    one.b = {c: {d: 'e'}};
-    two.b = {c: {f: 'g', j: 'i'}};
+    one.b = {
+      c: {
+        d: 'e'
+      }
+    };
+    two.b = {
+      c: {
+        f: 'g',
+        j: 'i'
+      }
+    };
     assign(target, one, two);
-    assert.deepEqual(target.b, {c: {d: 'e', f: 'g', j: 'i'}});
+    assert.deepEqual(target.b, {
+      c: {
+        d: 'e',
+        f: 'g',
+        j: 'i'
+      }
+    });
   });
 
   it('should update a value when a duplicate is assigned:', function() {
-    var one = {b: {c: {d: 'e'}}};
-    var two = {b: {c: {d: 'f'}}};
-    assert.deepEqual(assign(one, two), {b: {c: {d: 'f'}}});
+    var one = {
+      b: {
+        c: {
+          d: 'e'
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          d: 'f'
+        }
+      }
+    };
+    assert.deepEqual(assign(one, two), {
+      b: {
+        c: {
+          d: 'f'
+        }
+      }
+    });
   });
 
   it('should not loop over arrays:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
-    var two = {b: {c: {d: 'f', g: ['a']}}};
-    assert.deepEqual(assign(one, two), {b: {c: {d: 'f', g: ['a']}}});
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
+    var two = {
+      b: {
+        c: {
+          d: 'f',
+          g: ['a']
+        }
+      }
+    };
+    assert.deepEqual(assign(one, two), {
+      b: {
+        c: {
+          d: 'f',
+          g: ['a']
+        }
+      }
+    });
   });
 
   it('should deeply assign values from multiple objects:', function() {
     var foo = {};
-    var bar = {a: 'b'};
-    var baz = {c: 'd', g: {h: 'i'}};
-    var quux = {e: 'f', g: {j: 'k'}};
+    var bar = {
+      a: 'b'
+    };
+    var baz = {
+      c: 'd',
+      g: {
+        h: 'i'
+      }
+    };
+    var quux = {
+      e: 'f',
+      g: {
+        j: 'k'
+      }
+    };
 
     assign(foo, bar, baz, quux);
-    assert.deepEqual(foo, {a: 'b', c: 'd', e: 'f', g: {h: 'i', j: 'k'}});
+    assert.deepEqual(foo, {
+      a: 'b',
+      c: 'd',
+      e: 'f',
+      g: {
+        h: 'i',
+        j: 'k'
+      }
+    });
   });
 
   it('should not assign primitive arguments:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
     var two = 5;
     assert.deepEqual(assign(one, two), one);
   });
 
   it('should assign primitive values:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
-    var two = {b: 5};
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
+    var two = {
+      b: 5
+    };
     assert.deepEqual(assign(one, two), {b: 5});
   });
 
   it('should assign over primitive values:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
-    var two = {b: 5};
-    var three = {b: function() {}};
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
+    var two = {
+      b: 5
+    };
+    var three = {
+      b: function() {}
+    };
     three.b.foo = 'bar';
     assert.deepEqual(assign(one, two, three), three);
   });
 
   it('should assign null values:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
-    var two = {b: null, c: null};
-    assert.deepEqual(assign(one, two), {b: null, c: null});
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
+    var two = {
+      b: null,
+      c: null
+    };
+    assert.deepEqual(assign(one, two), {
+      b: null,
+      c: null
+    });
   });
 
   it('should assign undefined values:', function() {
-    var one = {b: {c: {d: 'e', g: ['b']}}};
-    var two = {b: undefined};
+    var one = {
+      b: {
+        c: {
+          d: 'e',
+          g: ['b']
+        }
+      }
+    };
+    var two = {
+      b: undefined
+    };
     assert.deepEqual(assign(one, two), {b: undefined});
   });
 
@@ -127,10 +351,13 @@ describe('assign', function() {
     one.a = 'b';
     one.c = 'd';
 
-    var two = {e: 'f', g: ['h']};
+    var two = {
+      e: 'f',
+      g: ['h']
+    };
     assign(one, two);
-    assert.deepEqual(one.g, ['h']);
-    assert.equal(one.g, two.g);
+    assert.deepEqual(one.g[0], 'h');
+    assert.deepEqual(one.g, two.g);
     assert.equal(typeof one, 'function');
   });
 
@@ -139,7 +366,10 @@ describe('assign', function() {
     one.a = 'b';
     one.c = 'd';
 
-    var two = {e: 'f', g: ['h']};
+    var two = {
+      e: 'f',
+      g: ['h']
+    };
     assign(two, one);
     assert.deepEqual(two.g, ['h']);
     assert.equal(two.g, two.g);
@@ -147,19 +377,83 @@ describe('assign', function() {
   });
 
   it('should deeply mix the properties of object into the first object.', function() {
-    var a = assign({a: {aa: 'aa'} }, {a: {bb: 'bb'} }, {a: {cc: 'cc'} });
-    assert.deepEqual(a, {a: {aa: 'aa', bb: 'bb', cc: 'cc'} });
+    var a = assign({
+      a: {
+        aa: 'aa'
+      }
+    }, {
+      a: {
+        bb: 'bb'
+      }
+    }, {
+      a: {
+        cc: 'cc'
+      }
+    });
+    assert.deepEqual(a, {
+      a: {
+        aa: 'aa',
+        bb: 'bb',
+        cc: 'cc'
+      }
+    });
 
-    var b = assign({a: {aa: 'aa', dd: {ee: 'ff'} } }, {a: {bb: 'bb', dd: {gg: 'hh'} } }, {a: {cc: 'cc', dd: {ii: 'jj'} } });
-    assert.deepEqual(b, {a: {aa: 'aa', dd: {ee: 'ff', gg: 'hh', ii: 'jj'}, bb: 'bb', cc: 'cc'} });
+    var b = assign({
+      a: {
+        aa: 'aa',
+        dd: {
+          ee: 'ff'
+        }
+      }
+    }, {
+      a: {
+        bb: 'bb',
+        dd: {
+          gg: 'hh'
+        }
+      }
+    }, {
+      a: {
+        cc: 'cc',
+        dd: {
+          ii: 'jj'
+        }
+      }
+    });
+    assert.deepEqual(b, {
+      a: {
+        aa: 'aa',
+        dd: {
+          ee: 'ff',
+          gg: 'hh',
+          ii: 'jj'
+        },
+        bb: 'bb',
+        cc: 'cc'
+      }
+    });
   });
 
   it('should merge object properties without affecting any object', function() {
-    var obj1 = {a: 0, b: 1};
-    var obj2 = {c: 2, d: 3};
-    var obj3 = {a: 4, d: 5};
-
-    var actual = {a: 4, b: 1, c: 2, d: 5 };
+    var obj1 = {
+      a: 0,
+      b: 1
+    };
+    var obj2 = {
+      c: 2,
+      d: 3
+    };
+    var obj3 = {
+      a: 4,
+      d: 5
+    };
+
+    var actual = {
+      a: 4,
+      b: 1,
+      c: 2,
+      d: 5
+    };
 
     assert.deepEqual(assign({}, obj1, obj2, obj3), actual);
     assert.notDeepEqual(actual, obj1);
@@ -168,73 +462,192 @@ describe('assign', function() {
   });
 
   it('should do a deep merge', function() {
-    var obj1 = {a: {b: 1, c: 1, d: {e: 1, f: 1}}};
-    var obj2 = {a: {b: 2, d: {f: 'f'}}};
-
-    assert.deepEqual(assign(obj1, obj2), {a: {b: 2, c: 1, d: {e: 1, f: 'f'} }});
+    var obj1 = {
+      a: {
+        b: 1,
+        c: 1,
+        d: {
+          e: 1,
+          f: 1
+        }
+      }
+    };
+    var obj2 = {
+      a: {
+        b: 2,
+        d: {
+          f: 'f'
+        }
+      }
+    };
+
+    assert.deepEqual(assign(obj1, obj2), {
+      a: {
+        b: 2,
+        c: 1,
+        d: {
+          e: 1,
+          f: 'f'
+        }
+      }
+    });
   });
 
   it('should use the last value defined', function() {
-    var obj1 = {a: 'b'};
-    var obj2 = {a: 'c'};
+    var obj1 = {
+      a: 'b'
+    };
+    var obj2 = {
+      a: 'c'
+    };
 
     assert.deepEqual(assign(obj1, obj2), {a: 'c'});
   });
 
   it('should use the last value defined on nested object', function() {
-    var obj1 = {a: 'b', c: {d: 'e'}};
-    var obj2 = {a: 'c', c: {d: 'f'}};
-
-    assert.deepEqual(assign(obj1, obj2), {a: 'c', c: {d: 'f'}});
+    var obj1 = {
+      a: 'b',
+      c: {
+        d: 'e'
+      }
+    };
+    var obj2 = {
+      a: 'c',
+      c: {
+        d: 'f'
+      }
+    };
+
+    assert.deepEqual(assign(obj1, obj2), {
+      a: 'c',
+      c: {
+        d: 'f'
+      }
+    });
   });
 
   it('should shallow clone when an empty object is passed', function() {
-    var obj1 = {a: 'b', c: {d: 'e'}};
-    var obj2 = {a: 'c', c: {d: 'f'}};
+    var obj1 = {
+      a: 'b',
+      c: {
+        d: 'e'
+      }
+    };
+    var obj2 = {
+      a: 'c',
+      c: {
+        d: 'f'
+      }
+    };
 
     var res = assign({}, obj1, obj2);
-    assert.deepEqual(res, {a: 'c', c: {d: 'f'}});
+    assert.deepEqual(res, {
+      a: 'c',
+      c: {
+        d: 'f'
+      }
+    });
   });
 
   it('should merge additional objects into the first:', function() {
-    var obj1 = {a: {b: 1, c: 1, d: {e: 1, f: 1}}};
-    var obj2 = {a: {b: 2, d: {f: 'f'} }};
+    var obj1 = {
+      a: {
+        b: 1,
+        c: 1,
+        d: {
+          e: 1,
+          f: 1
+        }
+      }
+    };
+    var obj2 = {
+      a: {
+        b: 2,
+        d: {
+          f: 'f'
+        }
+      }
+    };
 
     assign(obj1, obj2);
-    assert.deepEqual(obj1, {a: {b: 2, c: 1, d: {e: 1, f: 'f'} }});
+    assert.deepEqual(obj1, {
+      a: {
+        b: 2,
+        c: 1,
+        d: {
+          e: 1,
+          f: 'f'
+        }
+      }
+    });
   });
 
   it('should clone objects during merge', function() {
-    var obj1 = {a: {b: 1}};
-    var obj2 = {a: {c: 2}};
+    var obj1 = {
+      a: {
+        b: 1
+      }
+    };
+    var obj2 = {
+      a: {
+        c: 2
+      }
+    };
 
     var target = assign({}, obj1, obj2);
-    assert.deepEqual(target, {a: {b: 1, c: 2}});
-    assert.deepEqual(target.a, {b: 1, c: 2});
+    assert.deepEqual(target, {
+      a: {
+        b: 1,
+        c: 2
+      }
+    });
+    assert.deepEqual(target.a, {
+      b: 1,
+      c: 2
+    });
   });
 
   it('should deep clone arrays during merge', function() {
-    var obj1 = {a: [1, 2, [3, 4]]};
-    var obj2 = {b: [5, 6]};
+    var obj1 = {
+      a: [
+        1,
+        2,
+        [3, 4]
+      ]
+    };
+    var obj2 = {
+      b: [5, 6]
+    };
 
     var actual = assign(obj1, obj2);
-    assert.deepEqual(actual.a, [1, 2, [3, 4]]);
+    assert.deepEqual(actual.a, [
+      1,
+      2,
+      [3, 4]
+    ]);
     assert.deepEqual(actual.a[2], [3, 4]);
     assert.deepEqual(actual.b, obj2.b);
   });
 
   it('should copy source properties', function() {
-    assert(assign({ test: true }).test, true);
+    assert(assign({test: true}).test, true);
   });
 
   it('should not deep clone arrays', function() {
     assert.deepEqual(assign([1, 2, 3]), [1, 2, 3]);
-    assert.deepEqual(assign([1, 2, 3], {}), [1, 2, 3]);
+    assert.deepEqual(assign([
+      1, 2, 3
+    ], {}), [1, 2, 3]);
   });
 
   it('should work with sparse objects:', function() {
-    var actual = assign({}, undefined, {a: 'b'}, undefined, {c: 'd'});
-    assert.deepEqual(actual, {a: 'b', c: 'd'});
+    var actual = assign({}, undefined, {
+      a: 'b'
+    }, undefined, {c: 'd'});
+    assert.deepEqual(actual, {
+      a: 'b',
+      c: 'd'
+    });
   });
 
   it('should clone RegExps', function() {
@@ -250,7 +663,7 @@ describe('assign', function() {
   });
 
   it('should not clone objects created with custom constructor', function() {
-    function TestType() { }
+    function TestType() {}
     var fixture = new TestType();
     var actual = assign(fixture);
     assert.deepEqual(actual, fixture);
@@ -273,8 +686,20 @@ describe('symbols', function() {
     });
 
     it('should deeply assign symbol properties', function() {
-      var a = {c: {e: {f: {}}}};
-      var b = {c: {e: {g: {}}}};
+      var a = {
+        c: {
+          e: {
+            f: {}
+          }
+        }
+      };
+      var b = {
+        c: {
+          e: {
+            g: {}
+          }
+        }
+      };
       var foo = Symbol('foo');
       var bar = Symbol('bar');
       a.c.e.f[foo] = 'xyz';
@@ -322,5 +747,25 @@ describe('symbols', function() {
       var res = assign(a, b);
       assert.equal(res[key], 'xyz');
     });
+
+    it('should deeply assign properties in an array:', function() {
+      var template = {
+        b: [
+          {
+            a: {}
+          }
+        ]
+      };
+      var one = assign({}, template);
+      var two = assign({}, template);
+      one.b[0].a = {
+        b: 0
+      };
+      two.b[0].a = {
+        c: 0
+      };
+  
+      assert.deepEqual(one.b[0].a, {b: 0});
+    });
   }
 });

From 2c7bfebe2ffdc18d2e6d067c3bf1d33106e0f94d Mon Sep 17 00:00:00 2001
From: 332383124 <332383124@qq.com>
Date: Thu, 24 May 2018 16:30:29 +0800
Subject: [PATCH 2/4] deal with format

---
 index.js |   9 +-
 test.js  | 602 +++++++++----------------------------------------------
 2 files changed, 93 insertions(+), 518 deletions(-)

diff --git a/index.js b/index.js
index 5b39a99..d0b754e 100644
--- a/index.js
+++ b/index.js
@@ -13,8 +13,7 @@ var typeOf = require('kind-of');
 
 function assign(target/*, objects*/) {
   target = target || {};
-  var len = arguments.length,
-    i = 0;
+  var len = arguments.length, i = 0;
   if (len === 1) {
     return target;
   }
@@ -72,6 +71,7 @@ function extend(target, obj) {
 function isObject(obj) {
   return typeOf(obj) === 'object' || typeOf(obj) === 'function';
 }
+
 /**
  * Returns true if the object is an array.
  */
@@ -84,10 +84,7 @@ function isArray(obj) {
  */
 
 function hasOwn(obj, key) {
-  return Object
-    .prototype
-    .hasOwnProperty
-    .call(obj, key);
+  return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
 /**
diff --git a/test.js b/test.js
index ef3b726..a10b44a 100644
--- a/test.js
+++ b/test.js
@@ -5,87 +5,27 @@ var assert = require('assert');
 var assign = require('./');
 
 describe('assign', function() {
-
   it('should deeply assign properties of objects to the first object:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e'
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          f: 'g',
-          j: 'i'
-        }
-      }
-    };
-    assert.deepEqual(assign(one, two), {
-      b: {
-        c: {
-          d: 'e',
-          f: 'g',
-          j: 'i'
-        }
-      }
-    });
+    var one = {b: {c: {d: 'e'}}};
+    var two = {b: {c: {f: 'g', j: 'i'}}};
+    assert.deepEqual(assign(one, two), {b: {c: {d: 'e', f: 'g', j: 'i'}}});
   });
 
   it('should extend properties onto a function:', function() {
     function target() {}
-    var one = {
-      b: {
-        c: {
-          d: 'e'
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          f: 'g',
-          j: 'i'
-        }
-      }
-    };
+    var one = {b: {c: {d: 'e'}}};
+    var two = {b: {c: {f: 'g', j: 'i'}}};
     assign(target, one, two);
-    assert.deepEqual(target.b, {
-      c: {
-        d: 'e',
-        f: 'g',
-        j: 'i'
-      }
-    });
+    assert.deepEqual(target.b, {c: {d: 'e', f: 'g', j: 'i'}});
   });
 
   it('should extend deeply nested functions:', function() {
     var fn = function() {};
     var target = {};
-    var one = {
-      b: {
-        c: {
-          d: fn
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          f: 'g',
-          j: 'i'
-        }
-      }
-    };
+    var one = {b: {c: {d: fn}}};
+    var two = {b: {c: {f: 'g', j: 'i'}}};
     assign(target, one, two);
-    assert.deepEqual(target.b, {
-      c: {
-        d: fn,
-        f: 'g',
-        j: 'i'
-      }
-    });
+    assert.deepEqual(target.b, {c: {d: fn, f: 'g', j: 'i'}});
   });
 
   it('should extend deeply nested functions with properties:', function() {
@@ -94,255 +34,91 @@ describe('assign', function() {
     fn.bar = 'bar';
 
     var target = {};
-    var one = {
-      b: {
-        c: {
-          d: fn
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          f: 'g',
-          j: 'i'
-        }
-      }
-    };
+    var one = {b: {c: {d: fn}}};
+    var two = {b: {c: {f: 'g', j: 'i'}}};
     assign(target, one, two);
-    assert.deepEqual(target.b, {
-      c: {
-        d: fn,
-        f: 'g',
-        j: 'i'
-      }
-    });
+    assert.deepEqual(target.b, {c: {d: fn, f: 'g', j: 'i'}});
   });
 
   it('should extend deeply nested functions with nested properties:', function() {
     var fnOne = function() {};
-    fnOne.foo = {
-      y: 'y'
-    };
-    fnOne.bar = {
-      z: 'z'
-    };
+    fnOne.foo = {y: 'y'};
+    fnOne.bar = {z: 'z'};
 
     var fnTwo = function() {};
-    fnTwo.foo = {
-      w: 'w'
-    };
-    fnTwo.bar = {
-      x: 'x'
-    };
+    fnTwo.foo = {w: 'w'};
+    fnTwo.bar = {x: 'x'};
 
     var target = {};
-    var one = {
-      a: {
-        fn: fnOne
-      }
-    };
-    var two = {
-      a: {
-        fn: fnTwo
-      }
-    };
+    var one = {a: {fn: fnOne}};
+    var two = {a: {fn: fnTwo}};
 
     var actual = assign(target, one, two).a.fn;
-    assert.deepEqual(actual.foo, {
-      y: 'y',
-      w: 'w'
-    });
-    assert.deepEqual(actual.bar, {
-      z: 'z',
-      x: 'x'
-    });
+    assert.deepEqual(actual.foo, {y: 'y', w: 'w' });
+    assert.deepEqual(actual.bar, { z: 'z', x: 'x' });
   });
 
   it('should extend properties from functions to functions:', function() {
     function target() {}
     function one() {}
     function two() {}
-    one.b = {
-      c: {
-        d: 'e'
-      }
-    };
-    two.b = {
-      c: {
-        f: 'g',
-        j: 'i'
-      }
-    };
+    one.b = {c: {d: 'e'}};
+    two.b = {c: {f: 'g', j: 'i'}};
     assign(target, one, two);
-    assert.deepEqual(target.b, {
-      c: {
-        d: 'e',
-        f: 'g',
-        j: 'i'
-      }
-    });
+    assert.deepEqual(target.b, {c: {d: 'e', f: 'g', j: 'i'}});
   });
 
   it('should update a value when a duplicate is assigned:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e'
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          d: 'f'
-        }
-      }
-    };
-    assert.deepEqual(assign(one, two), {
-      b: {
-        c: {
-          d: 'f'
-        }
-      }
-    });
+    var one = {b: {c: {d: 'e'}}};
+    var two = {b: {c: {d: 'f'}}};
+    assert.deepEqual(assign(one, two), {b: {c: {d: 'f'}}});
   });
 
   it('should not loop over arrays:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
-    var two = {
-      b: {
-        c: {
-          d: 'f',
-          g: ['a']
-        }
-      }
-    };
-    assert.deepEqual(assign(one, two), {
-      b: {
-        c: {
-          d: 'f',
-          g: ['a']
-        }
-      }
-    });
+    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var two = {b: {c: {d: 'f', g: ['a']}}};
+    assert.deepEqual(assign(one, two), {b: {c: {d: 'f', g: ['a']}}});
   });
 
   it('should deeply assign values from multiple objects:', function() {
     var foo = {};
-    var bar = {
-      a: 'b'
-    };
-    var baz = {
-      c: 'd',
-      g: {
-        h: 'i'
-      }
-    };
-    var quux = {
-      e: 'f',
-      g: {
-        j: 'k'
-      }
-    };
+    var bar = {a: 'b'};
+    var baz = {c: 'd', g: {h: 'i'}};
+    var quux = {e: 'f', g: {j: 'k'}};
 
     assign(foo, bar, baz, quux);
-    assert.deepEqual(foo, {
-      a: 'b',
-      c: 'd',
-      e: 'f',
-      g: {
-        h: 'i',
-        j: 'k'
-      }
-    });
+    assert.deepEqual(foo, {a: 'b', c: 'd', e: 'f', g: {h: 'i', j: 'k'}});
   });
 
   it('should not assign primitive arguments:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
+    var one = {b: {c: {d: 'e', g: ['b']}}};
     var two = 5;
     assert.deepEqual(assign(one, two), one);
   });
 
   it('should assign primitive values:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
-    var two = {
-      b: 5
-    };
+    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var two = {b: 5};
     assert.deepEqual(assign(one, two), {b: 5});
   });
 
   it('should assign over primitive values:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
-    var two = {
-      b: 5
-    };
-    var three = {
-      b: function() {}
-    };
+    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var two = {b: 5};
+    var three = {b: function() {}};
     three.b.foo = 'bar';
     assert.deepEqual(assign(one, two, three), three);
   });
 
   it('should assign null values:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
-    var two = {
-      b: null,
-      c: null
-    };
-    assert.deepEqual(assign(one, two), {
-      b: null,
-      c: null
-    });
+    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var two = {b: null, c: null};
+    assert.deepEqual(assign(one, two), {b: null, c: null});
   });
 
   it('should assign undefined values:', function() {
-    var one = {
-      b: {
-        c: {
-          d: 'e',
-          g: ['b']
-        }
-      }
-    };
-    var two = {
-      b: undefined
-    };
+    var one = {b: {c: {d: 'e', g: ['b']}}};
+    var two = {b: undefined};
     assert.deepEqual(assign(one, two), {b: undefined});
   });
 
@@ -351,12 +127,9 @@ describe('assign', function() {
     one.a = 'b';
     one.c = 'd';
 
-    var two = {
-      e: 'f',
-      g: ['h']
-    };
+    var two = {e: 'f', g: ['h']};
     assign(one, two);
-    assert.deepEqual(one.g[0], 'h');
+    assert.deepEqual(one.g, ['h']);
     assert.deepEqual(one.g, two.g);
     assert.equal(typeof one, 'function');
   });
@@ -366,10 +139,7 @@ describe('assign', function() {
     one.a = 'b';
     one.c = 'd';
 
-    var two = {
-      e: 'f',
-      g: ['h']
-    };
+    var two = {e: 'f', g: ['h']};
     assign(two, one);
     assert.deepEqual(two.g, ['h']);
     assert.equal(two.g, two.g);
@@ -377,83 +147,19 @@ describe('assign', function() {
   });
 
   it('should deeply mix the properties of object into the first object.', function() {
-    var a = assign({
-      a: {
-        aa: 'aa'
-      }
-    }, {
-      a: {
-        bb: 'bb'
-      }
-    }, {
-      a: {
-        cc: 'cc'
-      }
-    });
-    assert.deepEqual(a, {
-      a: {
-        aa: 'aa',
-        bb: 'bb',
-        cc: 'cc'
-      }
-    });
+    var a = assign({a: {aa: 'aa'} }, {a: {bb: 'bb'} }, {a: {cc: 'cc'} });
+    assert.deepEqual(a, {a: {aa: 'aa', bb: 'bb', cc: 'cc'} });
 
-    var b = assign({
-      a: {
-        aa: 'aa',
-        dd: {
-          ee: 'ff'
-        }
-      }
-    }, {
-      a: {
-        bb: 'bb',
-        dd: {
-          gg: 'hh'
-        }
-      }
-    }, {
-      a: {
-        cc: 'cc',
-        dd: {
-          ii: 'jj'
-        }
-      }
-    });
-    assert.deepEqual(b, {
-      a: {
-        aa: 'aa',
-        dd: {
-          ee: 'ff',
-          gg: 'hh',
-          ii: 'jj'
-        },
-        bb: 'bb',
-        cc: 'cc'
-      }
-    });
+    var b = assign({a: {aa: 'aa', dd: {ee: 'ff'} } }, {a: {bb: 'bb', dd: {gg: 'hh'} } }, {a: {cc: 'cc', dd: {ii: 'jj'} } });
+    assert.deepEqual(b, {a: {aa: 'aa', dd: {ee: 'ff', gg: 'hh', ii: 'jj'}, bb: 'bb', cc: 'cc'} });
   });
 
   it('should merge object properties without affecting any object', function() {
-    var obj1 = {
-      a: 0,
-      b: 1
-    };
-    var obj2 = {
-      c: 2,
-      d: 3
-    };
-    var obj3 = {
-      a: 4,
-      d: 5
-    };
-
-    var actual = {
-      a: 4,
-      b: 1,
-      c: 2,
-      d: 5
-    };
+    var obj1 = {a: 0, b: 1};
+    var obj2 = {c: 2, d: 3};
+    var obj3 = {a: 4, d: 5};
+
+    var actual = {a: 4, b: 1, c: 2, d: 5 };
 
     assert.deepEqual(assign({}, obj1, obj2, obj3), actual);
     assert.notDeepEqual(actual, obj1);
@@ -462,192 +168,73 @@ describe('assign', function() {
   });
 
   it('should do a deep merge', function() {
-    var obj1 = {
-      a: {
-        b: 1,
-        c: 1,
-        d: {
-          e: 1,
-          f: 1
-        }
-      }
-    };
-    var obj2 = {
-      a: {
-        b: 2,
-        d: {
-          f: 'f'
-        }
-      }
-    };
-
-    assert.deepEqual(assign(obj1, obj2), {
-      a: {
-        b: 2,
-        c: 1,
-        d: {
-          e: 1,
-          f: 'f'
-        }
-      }
-    });
+    var obj1 = {a: {b: 1, c: 1, d: {e: 1, f: 1}}};
+    var obj2 = {a: {b: 2, d: {f: 'f'}}};
+
+    assert.deepEqual(assign(obj1, obj2), {a: {b: 2, c: 1, d: {e: 1, f: 'f'} }});
   });
 
   it('should use the last value defined', function() {
-    var obj1 = {
-      a: 'b'
-    };
-    var obj2 = {
-      a: 'c'
-    };
+    var obj1 = {a: 'b'};
+    var obj2 = {a: 'c'};
 
     assert.deepEqual(assign(obj1, obj2), {a: 'c'});
   });
 
   it('should use the last value defined on nested object', function() {
-    var obj1 = {
-      a: 'b',
-      c: {
-        d: 'e'
-      }
-    };
-    var obj2 = {
-      a: 'c',
-      c: {
-        d: 'f'
-      }
-    };
-
-    assert.deepEqual(assign(obj1, obj2), {
-      a: 'c',
-      c: {
-        d: 'f'
-      }
-    });
+    var obj1 = {a: 'b', c: {d: 'e'}};
+    var obj2 = {a: 'c', c: {d: 'f'}};
+
+    assert.deepEqual(assign(obj1, obj2), {a: 'c', c: {d: 'f'}});
   });
 
   it('should shallow clone when an empty object is passed', function() {
-    var obj1 = {
-      a: 'b',
-      c: {
-        d: 'e'
-      }
-    };
-    var obj2 = {
-      a: 'c',
-      c: {
-        d: 'f'
-      }
-    };
+    var obj1 = {a: 'b', c: {d: 'e'}};
+    var obj2 = {a: 'c', c: {d: 'f'}};
 
     var res = assign({}, obj1, obj2);
-    assert.deepEqual(res, {
-      a: 'c',
-      c: {
-        d: 'f'
-      }
-    });
+    assert.deepEqual(res, {a: 'c', c: {d: 'f'}});
   });
 
   it('should merge additional objects into the first:', function() {
-    var obj1 = {
-      a: {
-        b: 1,
-        c: 1,
-        d: {
-          e: 1,
-          f: 1
-        }
-      }
-    };
-    var obj2 = {
-      a: {
-        b: 2,
-        d: {
-          f: 'f'
-        }
-      }
-    };
+    var obj1 = {a: {b: 1, c: 1, d: {e: 1, f: 1}}};
+    var obj2 = {a: {b: 2, d: {f: 'f'} }};
 
     assign(obj1, obj2);
-    assert.deepEqual(obj1, {
-      a: {
-        b: 2,
-        c: 1,
-        d: {
-          e: 1,
-          f: 'f'
-        }
-      }
-    });
+    assert.deepEqual(obj1, {a: {b: 2, c: 1, d: {e: 1, f: 'f'} }});
   });
 
   it('should clone objects during merge', function() {
-    var obj1 = {
-      a: {
-        b: 1
-      }
-    };
-    var obj2 = {
-      a: {
-        c: 2
-      }
-    };
+    var obj1 = {a: {b: 1}};
+    var obj2 = {a: {c: 2}};
 
     var target = assign({}, obj1, obj2);
-    assert.deepEqual(target, {
-      a: {
-        b: 1,
-        c: 2
-      }
-    });
-    assert.deepEqual(target.a, {
-      b: 1,
-      c: 2
-    });
+    assert.deepEqual(target, {a: {b: 1, c: 2}});
+    assert.deepEqual(target.a, {b: 1, c: 2});
   });
 
   it('should deep clone arrays during merge', function() {
-    var obj1 = {
-      a: [
-        1,
-        2,
-        [3, 4]
-      ]
-    };
-    var obj2 = {
-      b: [5, 6]
-    };
+    var obj1 = {a: [1, 2, [3, 4]]};
+    var obj2 = {b: [5, 6]};
 
     var actual = assign(obj1, obj2);
-    assert.deepEqual(actual.a, [
-      1,
-      2,
-      [3, 4]
-    ]);
+    assert.deepEqual(actual.a, [1, 2, [3, 4]]);
     assert.deepEqual(actual.a[2], [3, 4]);
     assert.deepEqual(actual.b, obj2.b);
   });
 
   it('should copy source properties', function() {
-    assert(assign({test: true}).test, true);
+    assert(assign({ test: true }).test, true);
   });
 
   it('should not deep clone arrays', function() {
     assert.deepEqual(assign([1, 2, 3]), [1, 2, 3]);
-    assert.deepEqual(assign([
-      1, 2, 3
-    ], {}), [1, 2, 3]);
+    assert.deepEqual(assign([1, 2, 3], {}), [1, 2, 3]);
   });
 
   it('should work with sparse objects:', function() {
-    var actual = assign({}, undefined, {
-      a: 'b'
-    }, undefined, {c: 'd'});
-    assert.deepEqual(actual, {
-      a: 'b',
-      c: 'd'
-    });
+    var actual = assign({}, undefined, {a: 'b'}, undefined, {c: 'd'});
+    assert.deepEqual(actual, {a: 'b', c: 'd'});
   });
 
   it('should clone RegExps', function() {
@@ -663,7 +250,7 @@ describe('assign', function() {
   });
 
   it('should not clone objects created with custom constructor', function() {
-    function TestType() {}
+    function TestType() { }
     var fixture = new TestType();
     var actual = assign(fixture);
     assert.deepEqual(actual, fixture);
@@ -686,20 +273,8 @@ describe('symbols', function() {
     });
 
     it('should deeply assign symbol properties', function() {
-      var a = {
-        c: {
-          e: {
-            f: {}
-          }
-        }
-      };
-      var b = {
-        c: {
-          e: {
-            g: {}
-          }
-        }
-      };
+      var a = {c: {e: {f: {}}}};
+      var b = {c: {e: {g: {}}}};
       var foo = Symbol('foo');
       var bar = Symbol('bar');
       a.c.e.f[foo] = 'xyz';
@@ -752,7 +327,10 @@ describe('symbols', function() {
       var template = {
         b: [
           {
-            a: {}
+  
+            a: {
+              a: 0
+            }
           }
         ]
       };

From 35a9ce59c01e4a7b39cb2196648b703afb3d186b Mon Sep 17 00:00:00 2001
From: 332383124 <332383124@qq.com>
Date: Fri, 25 May 2018 11:49:31 +0800
Subject: [PATCH 3/4] use strict test

---
 index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/index.js b/index.js
index d0b754e..6f205a2 100644
--- a/index.js
+++ b/index.js
@@ -45,7 +45,7 @@ function extend(target, obj) {
         }
         target[key] = assign(target[key] || {}, val);
       } else if (isArray(val)) {
-        let array = [];
+        var array = [];
         for (let i = 0; i < val.length; i++) {
           if (isPrimitive(val[i])) {
             array.push(val[i]);

From e9fb33213d8f33681c3f547805e1f6d1a76bfa9b Mon Sep 17 00:00:00 2001
From: 332383124 <332383124@qq.com>
Date: Fri, 25 May 2018 11:53:00 +0800
Subject: [PATCH 4/4] strict mode

---
 index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/index.js b/index.js
index 6f205a2..2cc37b9 100644
--- a/index.js
+++ b/index.js
@@ -46,7 +46,7 @@ function extend(target, obj) {
         target[key] = assign(target[key] || {}, val);
       } else if (isArray(val)) {
         var array = [];
-        for (let i = 0; i < val.length; i++) {
+        for (var i = 0; i < val.length; i++) {
           if (isPrimitive(val[i])) {
             array.push(val[i]);
           } else {