docs/source/Array2.html

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