@qooxdoo/framework 7.0.0-beta.6 → 7.0.0

package/source/class/qx/lang/Array.js

@@ -53,10 +53,8 @@
  * @ignore(qx.Class.*)
  * @require(qx.lang.normalize.Date)
  */
-qx.Bootstrap.define("qx.lang.Array",
-{
-  statics :
-  {
+qx.Bootstrap.define("qx.lang.Array", {
+  statics: {
     /**
      * Converts an array like object to any other array like
      * object.
@@ -69,8 +67,7 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param offset {Integer?0} position to start from
      * @return {Array} the converted array
      */
-    cast : function(object, constructor, offset)
-    {
+    cast(object, constructor, offset) {
       if (object.constructor === constructor) {
         return object;
       }
@@ -81,17 +78,14 @@ qx.Bootstrap.define("qx.lang.Array",
         }
       }
 
-
       // Create from given constructor
-      var ret = new constructor;
+      var ret = new constructor();
 
       // Some collections in mshtml are not able to be sliced.
       // These lines are a special workaround for this client.
-      if ((qx.core.Environment.get("engine.name") == "mshtml"))
-      {
-        if (object.item)
-        {
-          for (var i=offset||0, l=object.length; i<l; i++) {
+      if (qx.core.Environment.get("engine.name") == "mshtml") {
+        if (object.item) {
+          for (var i = offset || 0, l = object.length; i < l; i++) {
             ret.push(object[i]);
           }
 
@@ -100,16 +94,18 @@ qx.Bootstrap.define("qx.lang.Array",
       }
 
       // Copy over items
-      if (Object.prototype.toString.call(object) === "[object Array]" && offset == null) {
+      if (
+        Object.prototype.toString.call(object) === "[object Array]" &&
+        offset == null
+      ) {
         ret.push.apply(ret, object);
       } else {
-        ret.push.apply(ret, Array.prototype.slice.call(object, offset||0));
+        ret.push.apply(ret, Array.prototype.slice.call(object, offset || 0));
       }
 
       return ret;
     },
 
-
     /**
      * Convert an arguments object into an array.
      *
@@ -117,27 +113,27 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param offset {Integer?0} position to start from
      * @return {Array} a newly created array (copy) with the content of the arguments object.
      */
-    fromArguments : function(args, offset) {
-      return Array.prototype.slice.call(args, offset||0);
+    fromArguments(args, offset) {
+      // Optimising for this use case can make a big difference (eg x100)
+      if (args.length === 0 && (offset === undefined || offset === 0)) {
+        return [];
+      }
+      return Array.prototype.slice.call(args, offset || 0);
     },
 
-
     /**
      * Convert a (node) collection into an array
      *
      * @param coll {var} node collection
      * @return {Array} a newly created array (copy) with the content of the node collection.
      */
-    fromCollection : function(coll)
-    {
+    fromCollection(coll) {
       // The native Array.slice cannot be used with some Array-like objects
       // including NodeLists in older IEs
-      if ((qx.core.Environment.get("engine.name") == "mshtml"))
-      {
-        if (coll.item)
-        {
+      if (qx.core.Environment.get("engine.name") == "mshtml") {
+        if (coll.item) {
           var arr = [];
-          for (var i=0, l=coll.length; i<l; i++) {
+          for (var i = 0, l = coll.length; i < l; i++) {
             arr[i] = coll[i];
           }
 
@@ -148,7 +144,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return Array.prototype.slice.call(coll, 0);
     },
 
-
     /**
      * Expand shorthand definition to a four element list.
      * This is an utility function for padding/margin and all other shorthand handling.
@@ -156,21 +151,19 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param input {Array} arr with one to four elements
      * @return {Array} an arr with four elements
      */
-    fromShortHand : function(input)
-    {
+    fromShortHand(input) {
       var len = input.length;
       var result = qx.lang.Array.clone(input);
 
       // Copy Values (according to the length)
-      switch(len)
-      {
+      switch (len) {
         case 1:
           result[1] = result[2] = result[3] = result[0];
           break;
 
         case 2:
           result[2] = result[0];
-          // no break here
+        // no break here
 
         case 3:
           result[3] = result[1];
@@ -180,18 +173,16 @@ qx.Bootstrap.define("qx.lang.Array",
       return result;
     },
 
-
     /**
      * Return a copy of the given array
      *
      * @param arr {Array} the array to copy
      * @return {Array} copy of the array
      */
-    clone : function(arr) {
+    clone(arr) {
       return arr.concat();
     },
 
-
     /**
      * Insert an element at a given position into the array
      *
@@ -200,14 +191,12 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param i {Integer} position where to insert the element into the array
      * @return {Array} the array
      */
-    insertAt : function(arr, obj, i)
-    {
+    insertAt(arr, obj, i) {
       arr.splice(i, 0, obj);
 
       return arr;
     },
 
-
     /**
      * Insert an element into the array before a given second element.
      *
@@ -216,8 +205,7 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param obj2 {var} insert obj1 before this object
      * @return {Array} the array
      */
-    insertBefore : function(arr, obj, obj2)
-    {
+    insertBefore(arr, obj, obj2) {
       var i = arr.indexOf(obj2);
 
       if (i == -1) {
@@ -229,7 +217,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return arr;
     },
 
-
     /**
      * Insert an element into the array after a given second element.
      *
@@ -238,11 +225,10 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param obj2 {var} insert obj1 after this object
      * @return {Array} the array
      */
-    insertAfter : function(arr, obj, obj2)
-    {
+    insertAfter(arr, obj, obj2) {
       var i = arr.indexOf(obj2);
 
-      if (i == -1 || i == (arr.length - 1)) {
+      if (i == -1 || i == arr.length - 1) {
         arr.push(obj);
       } else {
         arr.splice(i + 1, 0, obj);
@@ -251,7 +237,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return arr;
     },
 
-
     /**
      * Remove an element from the array at the given index
      *
@@ -259,24 +244,21 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param i {Integer} index of the element to be removed
      * @return {var} The removed element.
      */
-    removeAt : function(arr, i) {
+    removeAt(arr, i) {
       return arr.splice(i, 1)[0];
     },
 
-
     /**
      * Remove all elements from the array
      *
      * @param arr {Array} the array
      * @return {Array} empty array
      */
-    removeAll : function(arr)
-    {
+    removeAll(arr) {
       arr.length = 0;
       return this;
     },
 
-
     /**
      * Append the elements of an array to the array
      *
@@ -285,28 +267,34 @@ qx.Bootstrap.define("qx.lang.Array",
      * @return {Array} The modified array.
      * @throws {Error} if one of the arguments is not an array
      */
-    append : function(arr1, arr2)
-    {
+    append(arr1, arr2) {
       if (arr1 instanceof qx.data.Array) {
         return arr1.append(arr2);
       }
       if (arr2 instanceof qx.data.Array) {
         arr2 = arr2.toArray();
       }
-      
+
       // this check is important because opera throws an uncatchable error if apply is called without
       // an arr as second argument.
-      if (qx.core.Environment.get("qx.debug"))
-      {
-        qx.core.Assert && qx.core.Assert.assertArray(arr1, "The first parameter must be an array.");
-        qx.core.Assert && qx.core.Assert.assertArray(arr2, "The second parameter must be an array.");
+      if (qx.core.Environment.get("qx.debug")) {
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(
+            arr1,
+            "The first parameter must be an array."
+          );
+
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(
+            arr2,
+            "The second parameter must be an array."
+          );
       }
 
       Array.prototype.push.apply(arr1, arr2);
       return arr1;
     },
 
-
     /**
      * Modifies the first array as it removes all elements
      * which are listed in the second array as well.
@@ -316,21 +304,28 @@ qx.Bootstrap.define("qx.lang.Array",
      * @return {Array} The modified array.
      * @throws {Error} if one of the arguments is not an array
      */
-    exclude : function(arr1, arr2)
-    {
+    exclude(arr1, arr2) {
       if (arr1 instanceof qx.data.Array) {
         return arr1.exclude(arr2);
       }
-      
+
       // this check is important because opera throws an uncatchable error if apply is called without
       // an arr as second argument.
-      if (qx.core.Environment.get("qx.debug"))
-      {
-        qx.core.Assert && qx.core.Assert.assertArray(arr1, "The first parameter must be an array.");
-        qx.core.Assert && qx.core.Assert.assertArray(arr2, "The second parameter must be an array.");
+      if (qx.core.Environment.get("qx.debug")) {
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(
+            arr1,
+            "The first parameter must be an array."
+          );
+
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(
+            arr2,
+            "The second parameter must be an array."
+          );
       }
 
-      arr2.forEach(function(item) {
+      arr2.forEach(function (item) {
         var index = arr1.indexOf(item);
         if (index != -1) {
           arr1.splice(index, 1);
@@ -340,7 +335,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return arr1;
     },
 
-
     /**
      * Remove an element from the array.
      *
@@ -348,16 +342,14 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param obj {var} element to be removed from the array
      * @return {var} the removed element
      */
-    remove : function(arr, obj)
-    {
+    remove(arr, obj) {
       if (arr instanceof qx.data.Array) {
         return arr.remove(obj);
       }
-      
+
       var i = arr.indexOf(obj);
 
-      if (i != -1)
-      {
+      if (i != -1) {
         arr.splice(i, 1);
         return obj;
       }
@@ -372,7 +364,7 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param obj {var} object to look for
      * @return {Boolean} whether the arr contains the element
      */
-    contains : function(arr, obj) {
+    contains(arr, obj) {
       return arr.includes(obj);
     },
 
@@ -384,21 +376,19 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param arr2 {Array} second array
      * @return {Boolean} Whether the two arrays are equal
      */
-    equals : function(arr1, arr2)
-    {
+    equals(arr1, arr2) {
       if (arr1 instanceof qx.data.Array) {
         return arr1.equals(arr2);
       }
       arr2 = qx.lang.Array.toNativeArray(arr2);
-      
+
       var length = arr1.length;
 
       if (length !== arr2.length) {
         return false;
       }
 
-      for (var i=0; i<length; i++)
-      {
+      for (var i = 0; i < length; i++) {
         if (arr1[i] !== arr2[i]) {
           return false;
         }
@@ -407,7 +397,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return true;
     },
 
-
     /**
      * Returns the sum of all values in the given array. Supports
      * numeric values only.
@@ -415,10 +404,9 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param arr {Number[]} Array to process
      * @return {Number} The sum of all values.
      */
-    sum : function(arr)
-    {
+    sum(arr) {
       var result = 0;
-      for (var i=0, l=arr.length; i<l; i++) {
+      for (var i = 0, l = arr.length; i < l; i++) {
         if (arr[i] != undefined) {
           result += arr[i];
         }
@@ -427,7 +415,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return result;
     },
 
-
     /**
      * Returns the highest value in the given array. Supports
      * numeric values only.
@@ -435,16 +422,17 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param arr {Number[]} Array to process
      * @return {Number | null} The highest of all values or undefined if array is empty.
      */
-    max : function(arr)
-    {
+    max(arr) {
       if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert && qx.core.Assert.assertArray(arr, "Parameter must be an array.");
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(arr, "Parameter must be an array.");
       }
 
-      var i, len=arr.length, result = arr[0];
+      var i,
+        len = arr.length,
+        result = arr[0];
 
-      for (i = 1; i < len; i++)
-      {
+      for (i = 1; i < len; i++) {
         if (arr[i] > result) {
           result = arr[i];
         }
@@ -453,7 +441,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return result === undefined ? null : result;
     },
 
-
     /**
      * Returns the lowest value in the given array. Supports
      * numeric values only.
@@ -461,16 +448,17 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param arr {Number[]} Array to process
      * @return {Number | null} The lowest of all values or undefined if array is empty.
      */
-    min : function(arr)
-    {
+    min(arr) {
       if (qx.core.Environment.get("qx.debug")) {
-        qx.core.Assert && qx.core.Assert.assertArray(arr, "Parameter must be an array.");
+        qx.core.Assert &&
+          qx.core.Assert.assertArray(arr, "Parameter must be an array.");
       }
 
-      var i, len=arr.length, result = arr[0];
+      var i,
+        len = arr.length,
+        result = arr[0];
 
-      for (i = 1; i < len; i++)
-      {
+      for (i = 1; i < len; i++) {
         if (arr[i] < result) {
           result = arr[i];
         }
@@ -479,7 +467,6 @@ qx.Bootstrap.define("qx.lang.Array",
       return result === undefined ? null : result;
     },
 
-
     /**
      * Recreates an array which is free of all duplicate elements from the original.
      *
@@ -490,73 +477,58 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param arr {Array} Incoming array
      * @return {Array} Returns a copy with no duplicates
      */
-    unique: function(arr)
-    {
-      var ret=[], doneStrings={}, doneNumbers={}, doneObjects={};
-      var value, count=0;
+    unique(arr) {
+      var ret = [],
+        doneStrings = {},
+        doneNumbers = {},
+        doneObjects = {};
+      var value,
+        count = 0;
       var key = "qx" + Date.now();
-      var hasNull=false, hasFalse=false, hasTrue=false;
+      var hasNull = false,
+        hasFalse = false,
+        hasTrue = false;
 
       // Rebuild array and omit duplicates
-      for (var i=0, len=arr.length; i<len; i++)
-      {
+      for (var i = 0, len = arr.length; i < len; i++) {
         value = arr[i];
 
         // Differ between null, primitives and reference types
-        if (value === null)
-        {
-          if (!hasNull)
-          {
+        if (value === null) {
+          if (!hasNull) {
             hasNull = true;
             ret.push(value);
           }
-        }
-        else if (value === undefined)
-        {
+        } else if (value === undefined) {
           // pass
-        }
-        else if (value === false)
-        {
-          if (!hasFalse)
-          {
+        } else if (value === false) {
+          if (!hasFalse) {
             hasFalse = true;
             ret.push(value);
           }
-        }
-        else if (value === true)
-        {
-          if (!hasTrue)
-          {
+        } else if (value === true) {
+          if (!hasTrue) {
             hasTrue = true;
             ret.push(value);
           }
-        }
-        else if (typeof value === "string")
-        {
-          if (!doneStrings[value])
-          {
+        } else if (typeof value === "string") {
+          if (!doneStrings[value]) {
             doneStrings[value] = 1;
             ret.push(value);
           }
-        }
-        else if (typeof value === "number")
-        {
-          if (!doneNumbers[value])
-          {
+        } else if (typeof value === "number") {
+          if (!doneNumbers[value]) {
             doneNumbers[value] = 1;
             ret.push(value);
           }
-        }
-        else
-        {
+        } else {
           var hash = value[key];
 
           if (hash == null) {
             hash = value[key] = count++;
           }
 
-          if (!doneObjects[hash])
-          {
+          if (!doneObjects[hash]) {
             doneObjects[hash] = value;
             ret.push(value);
           }
@@ -564,21 +536,16 @@ qx.Bootstrap.define("qx.lang.Array",
       }
 
       // Clear object hashs
-      for (var hash in doneObjects)
-      {
-        try
-        {
+      for (var hash in doneObjects) {
+        try {
           delete doneObjects[hash][key];
-        }
-        catch(ex)
-        {
-          try
-          {
+        } catch (ex) {
+          try {
             doneObjects[hash][key] = null;
-          }
-          catch(ex1)
-          {
-            throw new Error("Cannot clean-up map entry doneObjects[" + hash + "][" + key + "]");
+          } catch (ex1) {
+            throw new Error(
+              "Cannot clean-up map entry doneObjects[" + hash + "][" + key + "]"
+            );
           }
         }
       }
@@ -594,8 +561,7 @@ qx.Bootstrap.define("qx.lang.Array",
      * @param step {Integer} increment / decrement - depends whether you use positive or negative values
      * @return {Array} Returns a new array with integers
      */
-    range : function(start, stop, step)
-    {
+    range(start, stop, step) {
       if (arguments.length <= 1) {
         stop = start || 0;
         start = 0;
@@ -613,20 +579,19 @@ qx.Bootstrap.define("qx.lang.Array",
 
       return range;
     },
-    
-    
+
     /**
      * Replaces the contents of the array `dest`
-     * 
+     *
      * @param dest {Array|qx.data.Array} the array to edit (if null then a new array is created)
      * @param src {Array|qx.data.Array} the array to copy from, or null
      * @return {Array} the edited array (or the new array, if dest is null)
      */
-    replace: function(dest, src) {
+    replace(dest, src) {
       if (dest instanceof qx.data.Array) {
         return dest.replace(src);
       }
-      
+
       if (src === null) {
         if (dest === null) {
           return null;
@@ -634,31 +599,30 @@ qx.Bootstrap.define("qx.lang.Array",
           return [];
         }
       }
-      
+
       src = qx.lang.Array.toNativeArray(src);
       if (dest === null) {
         dest = src.slice(0);
       } else {
-        var args = [ 0, dest.length ];
-        src.forEach(function(item) {
+        var args = [0, dest.length];
+        src.forEach(function (item) {
           args.push(item);
         });
         dest.splice.apply(dest, args);
       }
       return dest;
     },
-    
-    
+
     /**
      * Returns a native array from src where possible; qx.data.Array is converted to its native array,
-     * in which case unless `clone` parameter is set to true the rules of qx.data.Array.toArray should 
+     * in which case unless `clone` parameter is set to true the rules of qx.data.Array.toArray should
      * be followed, ie that the array should not be manipulated directly.
-     * 
+     *
      * @param src {qx.data.Array|Array} the object to return as an array
      * @param clone{Boolean?} whether to make the returned array a clone, ie editable by the calling code
      * @return {Array}
      */
-    toNativeArray: function(src, clone) {
+    toNativeArray(src, clone) {
       if (src === undefined || src === null) {
         return src;
       }
@@ -674,19 +638,18 @@ qx.Bootstrap.define("qx.lang.Array",
         }
         return src;
       }
-      return [ src ];
+      return [src];
     },
-    
-    
+
     /**
      * Returns a `qx.data.Array` array from src where possible; if `clone` is true then the result will
      * always be a new instance of `qx.data.Array` even if it is already a `qx.data.Array`
-     * 
+     *
      * @param src {qx.data.Array|Array} the object to return as `qx.data.Array`
      * @param clone{Boolean?} whether to make the returned array a clone, ie editable by the calling code
      * @return {Array}
      */
-    toDataArray: function(src, clone) {
+    toDataArray(src, clone) {
       if (src === undefined || src === null) {
         return src;
       }
@@ -699,7 +662,7 @@ qx.Bootstrap.define("qx.lang.Array",
       if (qx.lang.Type.isArray(src)) {
         return new qx.data.Array(src);
       }
-      return new qx.data.Array([ src ]);
+      return new qx.data.Array([src]);
     }
   }
 });