Feature/set

index.html

@@ -392,6 +392,7 @@
           <li data-name="toPath">- <a href="#toPath">toPath</a></li>
           <li data-name="has">- <a href="#has">has</a></li>
           <li data-name="get">- <a href="#get">get</a></li>
+          <li data-name="set">- <a href="#set">set</a></li>
           <li data-name="property">- <a href="#property">property</a></li>
           <li data-name="propertyOf">- <a href="#propertyOf">propertyOf</a></li>
           <li data-name="matcher">- <a href="#matcher">matcher</a></li>
@@ -1951,6 +1952,20 @@ <h2 id="objects">Object Functions</h2>
 =&gt; 2
 _.get({a: 10}, 'b', 100);
 =&gt; 100
+</pre>
+
+      <p id="set">
+        <b class="header">set</b><code>_.set(object, path, value)</code><br>
+        Sets the value on <b>path</b> of <b>object</b>. <b>path</b> may be
+        specified as a simple key, or as an array of object keys or array
+        indexes. If the property does not exist, it will be created.
+        Returns mutated <b>object</b>.
+      </p>
+      <pre>
+_.set({a: 10}, 'a', 50);
+=&gt; {a: 50}
+_.set({a: 10}, ['b', 0, 'value'], 50);
+=&gt; {a: 10, b: [{value: 50}]}
 </pre>
 
       <p id="has">

modules/index.js

@@ -62,6 +62,7 @@ export { default as tap } from './tap.js';
 export { default as get } from './get.js';
 export { default as has } from './has.js';
 export { default as mapObject } from './mapObject.js';
+export { default as set } from './set.js';
 
 // Utility Functions
 // -----------------

modules/set.js

@@ -0,0 +1,37 @@
+import isObject from './isObject.js';
+import toPath from './_toPath.js';
+import contains from './contains.js';
+
+
+var arrayIndex = /^\d+$/;
+
+// Internal function of `set`.
+function deepSet(obj, path, value) {
+  var key = path[0];
+
+  if (path.length === 1) {
+    obj[key] = value;
+    return;
+  }
+
+  if (!isObject(obj[key])) {
+    var nextKey = path[1];
+    obj[key] = arrayIndex.test(nextKey) ? [] : {};
+  }
+
+  return deepSet(obj[key], path.slice(1), value);
+}
+
+// Set the value on `path` of `object`.
+// If any property in `path` does not exist it will be created.
+// Returns mutated object (`obj`).
+export default function set(obj, path, value) {
+  path = toPath(path);
+
+  if (!isObject(obj) || !path.length) return obj;
+  if (contains(path, '__proto__')) throw new Error('Prototype assignment attempted');
+
+  deepSet(obj, path, value);
+
+  return obj;
+}

test/objects.js

@@ -1255,4 +1255,39 @@
     assert.deepEqual(_.mapObject(protoObj, _.identity), {a: 1}, 'ignore inherited values from prototypes');
 
   });
+
+
+  QUnit.test('set', function(assert) {
+    // returns first argument if first argument is primitive type
+    assert.strictEqual(_.set(undefined, ['some', 'path'], 'some value'), undefined);
+    assert.strictEqual(_.set(null, ['some', 'path'], 'some value'), null);
+    assert.strictEqual(_.set(12, ['some', 'path'], 'some value'), 12);
+    assert.strictEqual(_.set('string', ['some', 'path'], 'some value'), 'string');
+    assert.strictEqual(_.set(true, ['some', 'path'], 'some value'), true);
+    if (typeof BigInt != 'undefined') {
+      assert.strictEqual(_.set(BigInt(1), ['some', 'path'], 'some value'), BigInt(1));
+    }
+
+    // returns the same object if `path` is empty
+    assert.deepEqual(_.set({random: {object: true}}, [], 'some value'), {random: {object: true}});
+
+    assert.throws(
+      function impossibleSetProto() {
+        return _.set({obj: {}}, ['my', '__proto__', 'path'], 'my prototype');
+      },
+      'throws an exception if we want to change `__proto__`'
+    );
+
+    assert.deepEqual(_.set({}, 'path', 'my value'), {path: 'my value'});
+    assert.deepEqual(_.set({}, 123, 'my value'), {123: 'my value'});
+    assert.deepEqual(_.set({x: {l: 10}}, ['x', 'l'], 'changed'), {x: {l: 'changed'}});
+    assert.deepEqual(_.set({x: 10}, ['my', 'path'], 'my value'), {x: 10, my: {path: 'my value'}});
+    assert.deepEqual(_.set({x: 10}, ['my', 0, 'path'], 'my value'), {x: 10, my: [{path: 'my value'}]});
+    assert.deepEqual(_.set({x: 10}, [0], 'my value'), {x: 10, '0': 'my value'});
+    assert.deepEqual(_.set({x: 10}, [0, 1], 'my value'), {x: 10, '0': [undefined, 'my value']});
+    assert.deepEqual(_.set({x: 10}, [0, 0], 'my value'), {x: 10, '0': ['my value']});
+    // #2961
+    assert.deepEqual(_.set({x: 10}, [0, '0'], 'my value'), {x: 10, '0': ['my value']});
+    assert.deepEqual(_.set({x: 10}, [0, 'my'], 'my value'), {x: 10, '0': {my: 'my value'}});
+  });
 }());