Add _.asArray method.

lodash.js

@@ -10432,6 +10432,41 @@
       return value <= other;
     }
 
+    /**
+     * Converts a `value` to an array.
+     *
+     * @static
+     * @memberOf _
+     * @category Lang
+     * @param {*} value The value to convert.
+     * @returns {Array} Returns the converted array.
+     * @example
+     *
+     * _.toArray({ 'a': 1, 'b': 2 });
+     * // => [{ 'a': 1, 'b': 2 }]
+     *
+     * _.toArray([1, 2, 3]);
+     * // => [1, 2, 3]
+     *
+     * _.toArray('abc');
+     * // => ['abc']
+     *
+     * _.toArray(1);
+     * // => [1]
+     *
+     * _.toArray(null);
+     * // => [null]
+     */
+    function asArray(value) {
+      if (isArray(value)) {
+        return copyArray(value);
+      }
+      if (iteratorSymbol && value && value[iteratorSymbol] && !isString(value)) {
+        return iteratorToArray(value[iteratorSymbol]());
+      }
+      return [value];
+    }
+
     /**
      * Converts `value` to an array.
      *
@@ -14206,6 +14241,7 @@
     // Add functions that return wrapped values when chaining.
     lodash.after = after;
     lodash.ary = ary;
+    lodash.asArray = asArray;
     lodash.assign = assign;
     lodash.assignIn = assignIn;
     lodash.assignInWith = assignInWith;

test/test.js

@@ -21185,6 +21185,47 @@
 
   /*--------------------------------------------------------------------------*/
 
+  QUnit.module('lodash.asArray');
+
+  (function() {
+    var wrapCases = [null, void 0, 1, '', 'ab', 0, {a: 1}, Object('xyz')];
+
+    QUnit.test('should wrap non array items in an array', function(assert) {
+      assert.expect(wrapCases.length * 2);
+
+      _.each(wrapCases, function(val) {
+        var result = _.asArray(val);
+        assert.deepEqual(result, [val], 'for value ' + val);
+        assert.strictEqual(result[0], val, 'should not copy the value');
+      });
+    });
+
+    QUnit.test('should an array copy if provided array', function(assert) {
+      assert.expect(2);
+
+      var arr = [1, 2, '3'];
+      assert.deepEqual(_.asArray(arr), arr);
+      assert.notStrictEqual(_.asArray(arr), arr);
+    });
+
+    QUnit.test('should convert iterables to arrays', function(assert) {
+      assert.expect(1);
+
+      if (!isNpm && Symbol && Symbol.iterator) {
+        var object = { '0': 'a', 'length': 1 };
+        object[Symbol.iterator] = arrayProto[Symbol.iterator];
+
+        assert.deepEqual(_.asArray(object), ['a']);
+      }
+      else {
+        skipAssert(assert);
+      }
+    });
+
+  }());
+
+  /*--------------------------------------------------------------------------*/
+
   QUnit.module('lodash.toLower');
 
   (function() {
@@ -24084,7 +24125,7 @@
     var acceptFalsey = lodashStable.difference(allMethods, rejectFalsey);
 
     QUnit.test('should accept falsey arguments', function(assert) {
-      assert.expect(296);
+      assert.expect(297);
 
       var emptyArrays = lodashStable.map(falsey, alwaysEmptyArray);