docs/source/Array2.html

   1 <!DOCTYPE html><html><head><title>Sencha Documentation Project</title><link rel="stylesheet" href="../reset.css" type="text/css"><link rel="stylesheet" href="../prettify.css" type="text/css"><link rel="stylesheet" href="../prettify_sa.css" type="text/css"><script type="text/javascript" src="../prettify.js"></script></head><body onload="prettyPrint()"><pre class="prettyprint"><pre><span id='Ext-Array'>/**
   2 </span> * @author Jacky Nguyen &lt;jacky@sencha.com&gt;
   3  * @docauthor Jacky Nguyen &lt;jacky@sencha.com&gt;
   4  * @class Ext.Array
   5  *
   6  * A set of useful static methods to deal with arrays; provide missing methods for older browsers.
   7
   8  * @singleton
   9  * @markdown
  10  */
  11 (function() {
  12
  13     var arrayPrototype = Array.prototype,
  14         slice = arrayPrototype.slice,
  15         supportsForEach = 'forEach' in arrayPrototype,
  16         supportsMap = 'map' in arrayPrototype,
  17         supportsIndexOf = 'indexOf' in arrayPrototype,
  18         supportsEvery = 'every' in arrayPrototype,
  19         supportsSome = 'some' in arrayPrototype,
  20         supportsFilter = 'filter' in arrayPrototype,
  21         supportsSort = function() {
  22             var a = [1,2,3,4,5].sort(function(){ return 0; });
  23             return a[0] === 1 &amp;&amp; a[1] === 2 &amp;&amp; a[2] === 3 &amp;&amp; a[3] === 4 &amp;&amp; a[4] === 5;
  24         }(),
  25         supportsSliceOnNodeList = true,
  26         ExtArray;
  27     try {
  28         // IE 6 - 8 will throw an error when using Array.prototype.slice on NodeList
  29         if (typeof document !== 'undefined') {
  30             slice.call(document.getElementsByTagName('body'));
  31         }
  32     } catch (e) {
  33         supportsSliceOnNodeList = false;
  34     }
  35
  36     ExtArray = Ext.Array = {
  37         /*
  38          * Iterates an array or an iterable value and invoke the given callback function for each item.
  39
  40     var countries = ['Vietnam', 'Singapore', 'United States', 'Russia'];
  41
  42     Ext.Array.each(countries, function(name, index, countriesItSelf) {
  43         console.log(name);
  44     });
  45
  46     var sum = function() {
  47         var sum = 0;
  48
  49         Ext.Array.each(arguments, function(value) {
  50             sum += value;
  51         });
  52
  53         return sum;
  54     };
  55
  56     sum(1, 2, 3); // returns 6
  57
  58          * The iteration can be stopped by returning false in the function callback.
  59
  60     Ext.Array.each(countries, function(name, index, countriesItSelf) {
  61         if (name === 'Singapore') {
  62             return false; // break here
  63         }
  64     });
  65
  66          * @param {Array/NodeList/Mixed} iterable The value to be iterated. If this
  67          * argument is not iterable, the callback function is called once.
  68          * @param {Function} fn The callback function. If it returns false, the iteration stops and this method returns
  69          * the current `index`. Arguments passed to this callback function are:
  70
  71 - `item`: {Mixed} The item at the current `index` in the passed `array`
  72 - `index`: {Number} The current `index` within the `array`
  73 - `allItems`: {Array/NodeList/Mixed} The `array` passed as the first argument to `Ext.Array.each`
  74
  75          * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
  76          * @param {Boolean} reverse (Optional) Reverse the iteration order (loop from the end to the beginning)
  77          * Defaults false
  78          * @return {Boolean} See description for the `fn` parameter.
  79          * @markdown
  80          */
  81         each: function(array, fn, scope, reverse) {
  82             array = ExtArray.from(array);
  83
  84             var i,
  85                 ln = array.length;
  86
  87             if (reverse !== true) {
  88                 for (i = 0; i &lt; ln; i++) {
  89                     if (fn.call(scope || array[i], array[i], i, array) === false) {
  90                         return i;
  91                     }
  92                 }
  93             }
  94             else {
  95                 for (i = ln - 1; i &gt; -1; i--) {
  96                     if (fn.call(scope || array[i], array[i], i, array) === false) {
  97                         return i;
  98                     }
  99                 }
 100             }
 101
 102             return true;
 103         },
 104
 105 <span id='Ext-Array-method-forEach'>        /**
 106 </span>         * Iterates an array and invoke the given callback function for each item. Note that this will simply
 107          * delegate to the native Array.prototype.forEach method if supported.
 108          * It doesn't support stopping the iteration by returning false in the callback function like
 109          * {@link Ext.Array#each}. However, performance could be much better in modern browsers comparing with
 110          * {@link Ext.Array#each}
 111          *
 112          * @param {Array} array The array to iterate
 113          * @param {Function} fn The function callback, to be invoked these arguments:
 114          *
 115 - `item`: {Mixed} The item at the current `index` in the passed `array`
 116 - `index`: {Number} The current `index` within the `array`
 117 - `allItems`: {Array} The `array` itself which was passed as the first argument
 118
 119          * @param {Object} scope (Optional) The execution scope (`this`) in which the specified function is executed.
 120          * @markdown
 121          */
 122         forEach: function(array, fn, scope) {
 123             if (supportsForEach) {
 124                 return array.forEach(fn, scope);
 125             }
 126
 127             var i = 0,
 128                 ln = array.length;
 129
 130             for (; i &lt; ln; i++) {
 131                 fn.call(scope, array[i], i, array);
 132             }
 133         },
 134
 135 <span id='Ext-Array-method-indexOf'>        /**
 136 </span>         * Get the index of the provided `item` in the given `array`, a supplement for the
 137          * missing arrayPrototype.indexOf in Internet Explorer.
 138          *
 139          * @param {Array} array The array to check
 140          * @param {Mixed} item The item to look for
 141          * @param {Number} from (Optional) The index at which to begin the search
 142          * @return {Number} The index of item in the array (or -1 if it is not found)
 143          * @markdown
 144          */
 145         indexOf: function(array, item, from) {
 146             if (supportsIndexOf) {
 147                 return array.indexOf(item, from);
 148             }
 149
 150             var i, length = array.length;
 151
 152             for (i = (from &lt; 0) ? Math.max(0, length + from) : from || 0; i &lt; length; i++) {
 153                 if (array[i] === item) {
 154                     return i;
 155                 }
 156             }
 157
 158             return -1;
 159         },
 160
 161 <span id='Ext-Array-method-contains'>        /**
 162 </span>         * Checks whether or not the given `array` contains the specified `item`
 163          *
 164          * @param {Array} array The array to check
 165          * @param {Mixed} item The item to look for
 166          * @return {Boolean} True if the array contains the item, false otherwise
 167          * @markdown
 168          */
 169         contains: function(array, item) {
 170             if (supportsIndexOf) {
 171                 return array.indexOf(item) !== -1;
 172             }
 173
 174             var i, ln;
 175
 176             for (i = 0, ln = array.length; i &lt; ln; i++) {
 177                 if (array[i] === item) {
 178                     return true;
 179                 }
 180             }
 181
 182             return false;
 183         },
 184
 185 <span id='Ext-Array-method-toArray'>        /**
 186 </span>         * Converts any iterable (numeric indices and a length property) into a true array.
 187
 188 function test() {
 189     var args = Ext.Array.toArray(arguments),
 190         fromSecondToLastArgs = Ext.Array.toArray(arguments, 1);
 191
 192     alert(args.join(' '));
 193     alert(fromSecondToLastArgs.join(' '));
 194 }
 195
 196 test('just', 'testing', 'here'); // alerts 'just testing here';
 197                                  // alerts 'testing here';
 198
 199 Ext.Array.toArray(document.getElementsByTagName('div')); // will convert the NodeList into an array
 200 Ext.Array.toArray('splitted'); // returns ['s', 'p', 'l', 'i', 't', 't', 'e', 'd']
 201 Ext.Array.toArray('splitted', 0, 3); // returns ['s', 'p', 'l', 'i']
 202
 203          * @param {Mixed} iterable the iterable object to be turned into a true Array.
 204          * @param {Number} start (Optional) a zero-based index that specifies the start of extraction. Defaults to 0
 205          * @param {Number} end (Optional) a zero-based index that specifies the end of extraction. Defaults to the last
 206          * index of the iterable value
 207          * @return {Array} array
 208          * @markdown
 209          */
 210         toArray: function(iterable, start, end){
 211             if (!iterable || !iterable.length) {
 212                 return [];
 213             }
 214
 215             if (typeof iterable === 'string') {
 216                 iterable = iterable.split('');
 217             }
 218
 219             if (supportsSliceOnNodeList) {
 220                 return slice.call(iterable, start || 0, end || iterable.length);
 221             }
 222
 223             var array = [],
 224                 i;
 225
 226             start = start || 0;
 227             end = end ? ((end &lt; 0) ? iterable.length + end : end) : iterable.length;
 228
 229             for (i = start; i &lt; end; i++) {
 230                 array.push(iterable[i]);
 231             }
 232
 233             return array;
 234         },
 235
 236 <span id='Ext-Array-method-pluck'>        /**
 237 </span>         * Plucks the value of a property from each item in the Array. Example:
 238          *
 239     Ext.Array.pluck(Ext.query(&quot;p&quot;), &quot;className&quot;); // [el1.className, el2.className, ..., elN.className]
 240
 241          * @param {Array|NodeList} array The Array of items to pluck the value from.
 242          * @param {String} propertyName The property name to pluck from each element.
 243          * @return {Array} The value from each item in the Array.
 244          */
 245         pluck: function(array, propertyName) {
 246             var ret = [],
 247                 i, ln, item;
 248
 249             for (i = 0, ln = array.length; i &lt; ln; i++) {
 250                 item = array[i];
 251
 252                 ret.push(item[propertyName]);
 253             }
 254
 255             return ret;
 256         },
 257
 258 <span id='Ext-Array-method-map'>        /**
 259 </span>         * Creates a new array with the results of calling a provided function on every element in this array.
 260          * @param {Array} array
 261          * @param {Function} fn Callback function for each item
 262          * @param {Object} scope Callback function scope
 263          * @return {Array} results
 264          */
 265         map: function(array, fn, scope) {
 266             if (supportsMap) {
 267                 return array.map(fn, scope);
 268             }
 269
 270             var results = [],
 271                 i = 0,
 272                 len = array.length;
 273
 274             for (; i &lt; len; i++) {
 275                 results[i] = fn.call(scope, array[i], i, array);
 276             }
 277
 278             return results;
 279         },
 280
 281 <span id='Ext-Array-method-every'>        /**
 282 </span>         * Executes the specified function for each array element until the function returns a falsy value.
 283          * If such an item is found, the function will return false immediately.
 284          * Otherwise, it will return true.
 285          *
 286          * @param {Array} array
 287          * @param {Function} fn Callback function for each item
 288          * @param {Object} scope Callback function scope
 289          * @return {Boolean} True if no false value is returned by the callback function.
 290          */
 291         every: function(array, fn, scope) {
 292             //&lt;debug&gt;
 293             if (!fn) {
 294                 Ext.Error.raise('Ext.Array.every must have a callback function passed as second argument.');
 295             }
 296             //&lt;/debug&gt;
 297             if (supportsEvery) {
 298                 return array.every(fn, scope);
 299             }
 300
 301             var i = 0,
 302                 ln = array.length;
 303
 304             for (; i &lt; ln; ++i) {
 305                 if (!fn.call(scope, array[i], i, array)) {
 306                     return false;
 307                 }
 308             }
 309
 310             return true;
 311         },
 312
 313 <span id='Ext-Array-method-some'>        /**
 314 </span>         * Executes the specified function for each array element until the function returns a truthy value.
 315          * If such an item is found, the function will return true immediately. Otherwise, it will return false.
 316          *
 317          * @param {Array} array
 318          * @param {Function} fn Callback function for each item
 319          * @param {Object} scope Callback function scope
 320          * @return {Boolean} True if the callback function returns a truthy value.
 321          */
 322         some: function(array, fn, scope) {
 323             //&lt;debug&gt;
 324             if (!fn) {
 325                 Ext.Error.raise('Ext.Array.some must have a callback function passed as second argument.');
 326             }
 327             //&lt;/debug&gt;
 328             if (supportsSome) {
 329                 return array.some(fn, scope);
 330             }
 331
 332             var i = 0,
 333                 ln = array.length;
 334
 335             for (; i &lt; ln; ++i) {
 336                 if (fn.call(scope, array[i], i, array)) {
 337                     return true;
 338                 }
 339             }
 340
 341             return false;
 342         },
 343
 344 <span id='Ext-Array-method-clean'>        /**
 345 </span>         * Filter through an array and remove empty item as defined in {@link Ext#isEmpty Ext.isEmpty}
 346          *
 347          * @see Ext.Array.filter
 348          * @param {Array} array
 349          * @return {Array} results
 350          */
 351         clean: function(array) {
 352             var results = [],
 353                 i = 0,
 354                 ln = array.length,
 355                 item;
 356
 357             for (; i &lt; ln; i++) {
 358                 item = array[i];
 359
 360                 if (!Ext.isEmpty(item)) {
 361                     results.push(item);
 362                 }
 363             }
 364
 365             return results;
 366         },
 367
 368 <span id='Ext-Array-method-unique'>        /**
 369 </span>         * Returns a new array with unique items
 370          *
 371          * @param {Array} array
 372          * @return {Array} results
 373          */
 374         unique: function(array) {
 375             var clone = [],
 376                 i = 0,
 377                 ln = array.length,
 378                 item;
 379
 380             for (; i &lt; ln; i++) {
 381                 item = array[i];
 382
 383                 if (ExtArray.indexOf(clone, item) === -1) {
 384                     clone.push(item);
 385                 }
 386             }
 387
 388             return clone;
 389         },
 390
 391 <span id='Ext-Array-method-filter'>        /**
 392 </span>         * Creates a new array with all of the elements of this array for which
 393          * the provided filtering function returns true.
 394          * @param {Array} array
 395          * @param {Function} fn Callback function for each item
 396          * @param {Object} scope Callback function scope
 397          * @return {Array} results
 398          */
 399         filter: function(array, fn, scope) {
 400             if (supportsFilter) {
 401                 return array.filter(fn, scope);
 402             }
 403
 404             var results = [],
 405                 i = 0,
 406                 ln = array.length;
 407
 408             for (; i &lt; ln; i++) {
 409                 if (fn.call(scope, array[i], i, array)) {
 410                     results.push(array[i]);
 411                 }
 412             }
 413
 414             return results;
 415         },
 416
 417 <span id='Ext-Array-method-from'>        /**
 418 </span>         * Converts a value to an array if it's not already an array; returns:
 419          *
 420          * - An empty array if given value is `undefined` or `null`
 421          * - Itself if given value is already an array
 422          * - An array copy if given value is {@link Ext#isIterable iterable} (arguments, NodeList and alike)
 423          * - An array with one item which is the given value, otherwise
 424          *
 425          * @param {Array/Mixed} value The value to convert to an array if it's not already is an array
 426          * @param {Boolean} (Optional) newReference True to clone the given array and return a new reference if necessary,
 427          * defaults to false
 428          * @return {Array} array
 429          * @markdown
 430          */
 431         from: function(value, newReference) {
 432             if (value === undefined || value === null) {
 433                 return [];
 434             }
 435
 436             if (Ext.isArray(value)) {
 437                 return (newReference) ? slice.call(value) : value;
 438             }
 439
 440             if (value &amp;&amp; value.length !== undefined &amp;&amp; typeof value !== 'string') {
 441                 return Ext.toArray(value);
 442             }
 443
 444             return [value];
 445         },
 446
 447 <span id='Ext-Array-method-remove'>        /**
 448 </span>         * Removes the specified item from the array if it exists
 449          *
 450          * @param {Array} array The array
 451          * @param {Mixed} item The item to remove
 452          * @return {Array} The passed array itself
 453          */
 454         remove: function(array, item) {
 455             var index = ExtArray.indexOf(array, item);
 456
 457             if (index !== -1) {
 458                 array.splice(index, 1);
 459             }
 460
 461             return array;
 462         },
 463
 464 <span id='Ext-Array-method-include'>        /**
 465 </span>         * Push an item into the array only if the array doesn't contain it yet
 466          *
 467          * @param {Array} array The array
 468          * @param {Mixed} item The item to include
 469          * @return {Array} The passed array itself
 470          */
 471         include: function(array, item) {
 472             if (!ExtArray.contains(array, item)) {
 473                 array.push(item);
 474             }
 475         },
 476
 477 <span id='Ext-Array-method-clone'>        /**
 478 </span>         * Clone a flat array without referencing the previous one. Note that this is different
 479          * from Ext.clone since it doesn't handle recursive cloning. It's simply a convenient, easy-to-remember method
 480          * for Array.prototype.slice.call(array)
 481          *
 482          * @param {Array} array The array
 483          * @return {Array} The clone array
 484          */
 485         clone: function(array) {
 486             return slice.call(array);
 487         },
 488
 489 <span id='Ext-Array-method-merge'>        /**
 490 </span>         * Merge multiple arrays into one with unique items. Alias to {@link Ext.Array#union}.
 491          *
 492          * @param {Array} array,...
 493          * @return {Array} merged
 494          */
 495         merge: function() {
 496             var args = slice.call(arguments),
 497                 array = [],
 498                 i, ln;
 499
 500             for (i = 0, ln = args.length; i &lt; ln; i++) {
 501                 array = array.concat(args[i]);
 502             }
 503
 504             return ExtArray.unique(array);
 505         },
 506
 507 <span id='Ext-Array-method-intersect'>        /**
 508 </span>         * Merge multiple arrays into one with unique items that exist in all of the arrays.
 509          *
 510          * @param {Array} array,...
 511          * @return {Array} intersect
 512          */
 513         intersect: function() {
 514             var intersect = [],
 515                 arrays = slice.call(arguments),
 516                 i, j, k, minArray, array, x, y, ln, arraysLn, arrayLn;
 517
 518             if (!arrays.length) {
 519                 return intersect;
 520             }
 521
 522             // Find the smallest array
 523             for (i = x = 0,ln = arrays.length; i &lt; ln,array = arrays[i]; i++) {
 524                 if (!minArray || array.length &lt; minArray.length) {
 525                     minArray = array;
 526                     x = i;
 527                 }
 528             }
 529
 530             minArray = Ext.Array.unique(minArray);
 531             arrays.splice(x, 1);
 532
 533             // Use the smallest unique'd array as the anchor loop. If the other array(s) do contain
 534             // an item in the small array, we're likely to find it before reaching the end
 535             // of the inner loop and can terminate the search early.
 536             for (i = 0,ln = minArray.length; i &lt; ln,x = minArray[i]; i++) {
 537                 var count = 0;
 538
 539                 for (j = 0,arraysLn = arrays.length; j &lt; arraysLn,array = arrays[j]; j++) {
 540                     for (k = 0,arrayLn = array.length; k &lt; arrayLn,y = array[k]; k++) {
 541                         if (x === y) {
 542                             count++;
 543                             break;
 544                         }
 545                     }
 546                 }
 547
 548                 if (count === arraysLn) {
 549                     intersect.push(x);
 550                 }
 551             }
 552
 553             return intersect;
 554         },
 555
 556 <span id='Ext-Array-method-difference'>        /**
 557 </span>         * Perform a set difference A-B by subtracting all items in array B from array A.
 558          *
 559          * @param {Array} array A
 560          * @param {Array} array B
 561          * @return {Array} difference
 562          */
 563         difference: function(arrayA, arrayB) {
 564             var clone = slice.call(arrayA),
 565                 ln = clone.length,
 566                 i, j, lnB;
 567
 568             for (i = 0,lnB = arrayB.length; i &lt; lnB; i++) {
 569                 for (j = 0; j &lt; ln; j++) {
 570                     if (clone[j] === arrayB[i]) {
 571                         clone.splice(j, 1);
 572                         j--;
 573                         ln--;
 574                     }
 575                 }
 576             }
 577
 578             return clone;
 579         },
 580
 581 <span id='Ext-Array-method-sort'>        /**
 582 </span>         * Sorts the elements of an Array.
 583          * By default, this method sorts the elements alphabetically and ascending.
 584          *
 585          * @param {Array} array The array to sort.
 586          * @param {Function} sortFn (optional) The comparison function.
 587          * @return {Array} The sorted array.
 588          */
 589         sort: function(array, sortFn) {
 590             if (supportsSort) {
 591                 if (sortFn) {
 592                     return array.sort(sortFn);
 593                 } else {
 594                     return array.sort();
 595                 }
 596             }
 597
 598             var length = array.length,
 599                 i = 0,
 600                 comparison,
 601                 j, min, tmp;
 602
 603             for (; i &lt; length; i++) {
 604                 min = i;
 605                 for (j = i + 1; j &lt; length; j++) {
 606                     if (sortFn) {
 607                         comparison = sortFn(array[j], array[min]);
 608                         if (comparison &lt; 0) {
 609                             min = j;
 610                         }
 611                     } else if (array[j] &lt; array[min]) {
 612                         min = j;
 613                     }
 614                 }
 615                 if (min !== i) {
 616                     tmp = array[i];
 617                     array[i] = array[min];
 618                     array[min] = tmp;
 619                 }
 620             }
 621
 622             return array;
 623         },
 624
 625 <span id='Ext-Array-method-flatten'>        /**
 626 </span>         * Recursively flattens into 1-d Array. Injects Arrays inline.
 627          * @param {Array} array The array to flatten
 628          * @return {Array} The new, flattened array.
 629          */
 630         flatten: function(array) {
 631             var worker = [];
 632
 633             function rFlatten(a) {
 634                 var i, ln, v;
 635
 636                 for (i = 0, ln = a.length; i &lt; ln; i++) {
 637                     v = a[i];
 638
 639                     if (Ext.isArray(v)) {
 640                         rFlatten(v);
 641                     } else {
 642                         worker.push(v);
 643                     }
 644                 }
 645
 646                 return worker;
 647             }
 648
 649             return rFlatten(array);
 650         },
 651
 652 <span id='Ext-Array-method-min'>        /**
 653 </span>         * Returns the minimum value in the Array.
 654          * @param {Array|NodeList} array The Array from which to select the minimum value.
 655          * @param {Function} comparisonFn (optional) a function to perform the comparision which determines minimization.
 656          *                   If omitted the &quot;&lt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
 657          * @return {Mixed} minValue The minimum value
 658          */
 659         min: function(array, comparisonFn) {
 660             var min = array[0],
 661                 i, ln, item;
 662
 663             for (i = 0, ln = array.length; i &lt; ln; i++) {
 664                 item = array[i];
 665
 666                 if (comparisonFn) {
 667                     if (comparisonFn(min, item) === 1) {
 668                         min = item;
 669                     }
 670                 }
 671                 else {
 672                     if (item &lt; min) {
 673                         min = item;
 674                     }
 675                 }
 676             }
 677
 678             return min;
 679         },
 680
 681 <span id='Ext-Array-method-max'>        /**
 682 </span>         * Returns the maximum value in the Array
 683          * @param {Array|NodeList} array The Array from which to select the maximum value.
 684          * @param {Function} comparisonFn (optional) a function to perform the comparision which determines maximization.
 685          *                   If omitted the &quot;&gt;&quot; operator will be used. Note: gt = 1; eq = 0; lt = -1
 686          * @return {Mixed} maxValue The maximum value
 687          */
 688         max: function(array, comparisonFn) {
 689             var max = array[0],
 690                 i, ln, item;
 691
 692             for (i = 0, ln = array.length; i &lt; ln; i++) {
 693                 item = array[i];
 694
 695                 if (comparisonFn) {
 696                     if (comparisonFn(max, item) === -1) {
 697                         max = item;
 698                     }
 699                 }
 700                 else {
 701                     if (item &gt; max) {
 702                         max = item;
 703                     }
 704                 }
 705             }
 706
 707             return max;
 708         },
 709
 710 <span id='Ext-Array-method-mean'>        /**
 711 </span>         * Calculates the mean of all items in the array
 712          * @param {Array} array The Array to calculate the mean value of.
 713          * @return {Number} The mean.
 714          */
 715         mean: function(array) {
 716             return array.length &gt; 0 ? ExtArray.sum(array) / array.length : undefined;
 717         },
 718
 719 <span id='Ext-Array-method-sum'>        /**
 720 </span>         * Calculates the sum of all items in the given array
 721          * @param {Array} array The Array to calculate the sum value of.
 722          * @return {Number} The sum.
 723          */
 724         sum: function(array) {
 725             var sum = 0,
 726                 i, ln, item;
 727
 728             for (i = 0,ln = array.length; i &lt; ln; i++) {
 729                 item = array[i];
 730
 731                 sum += item;
 732             }
 733
 734             return sum;
 735         }
 736
 737     };
 738
 739 <span id='Ext-method-each'>    /**
 740 </span>     * Convenient alias to {@link Ext.Array#each}
 741      * @member Ext
 742      * @method each
 743      */
 744     Ext.each = Ext.Array.each;
 745
 746 <span id='Ext-Array-method-union'>    /**
 747 </span>     * Alias to {@link Ext.Array#merge}.
 748      * @member Ext.Array
 749      * @method union
 750      */
 751     Ext.Array.union = Ext.Array.merge;
 752
 753 <span id='Ext-method-min'>    /**
 754 </span>     * Old alias to {@link Ext.Array#min}
 755      * @deprecated 4.0.0 Use {@link Ext.Array#min} instead
 756      * @member Ext
 757      * @method min
 758      */
 759     Ext.min = Ext.Array.min;
 760
 761 <span id='Ext-method-max'>    /**
 762 </span>     * Old alias to {@link Ext.Array#max}
 763      * @deprecated 4.0.0 Use {@link Ext.Array#max} instead
 764      * @member Ext
 765      * @method max
 766      */
 767     Ext.max = Ext.Array.max;
 768
 769 <span id='Ext-method-sum'>    /**
 770 </span>     * Old alias to {@link Ext.Array#sum}
 771      * @deprecated 4.0.0 Use {@link Ext.Array#sum} instead
 772      * @member Ext
 773      * @method sum
 774      */
 775     Ext.sum = Ext.Array.sum;
 776
 777 <span id='Ext-method-mean'>    /**
 778 </span>     * Old alias to {@link Ext.Array#mean}
 779      * @deprecated 4.0.0 Use {@link Ext.Array#mean} instead
 780      * @member Ext
 781      * @method mean
 782      */
 783     Ext.mean = Ext.Array.mean;
 784
 785 <span id='Ext-method-flatten'>    /**
 786 </span>     * Old alias to {@link Ext.Array#flatten}
 787      * @deprecated 4.0.0 Use {@link Ext.Array#flatten} instead
 788      * @member Ext
 789      * @method flatten
 790      */
 791     Ext.flatten = Ext.Array.flatten;
 792
 793 <span id='Ext-method-clean'>    /**
 794 </span>     * Old alias to {@link Ext.Array#clean Ext.Array.clean}
 795      * @deprecated 4.0.0 Use {@link Ext.Array.clean} instead
 796      * @member Ext
 797      * @method clean
 798      */
 799     Ext.clean = Ext.Array.clean;
 800
 801 <span id='Ext-method-unique'>    /**
 802 </span>     * Old alias to {@link Ext.Array#unique Ext.Array.unique}
 803      * @deprecated 4.0.0 Use {@link Ext.Array.unique} instead
 804      * @member Ext
 805      * @method unique
 806      */
 807     Ext.unique = Ext.Array.unique;
 808
 809 <span id='Ext-method-pluck'>    /**
 810 </span>     * Old alias to {@link Ext.Array#pluck Ext.Array.pluck}
 811      * @deprecated 4.0.0 Use {@link Ext.Array#pluck Ext.Array.pluck} instead
 812      * @member Ext
 813      * @method pluck
 814      */
 815     Ext.pluck = Ext.Array.pluck;
 816
 817 <span id='Ext-method-toArray'>    /**
 818 </span>     * Convenient alias to {@link Ext.Array#toArray Ext.Array.toArray}
 819      * @param {Iterable} the iterable object to be turned into a true Array.
 820      * @member Ext
 821      * @method toArray
 822      * @return {Array} array
 823      */
 824     Ext.toArray = function() {
 825         return ExtArray.toArray.apply(ExtArray, arguments);
 826     }
 827 })();
 828 </pre></pre></body></html>