diff options
Diffstat (limited to 'framework/Web/Javascripts/extended/array.js')
-rw-r--r-- | framework/Web/Javascripts/extended/array.js | 465 |
1 files changed, 465 insertions, 0 deletions
diff --git a/framework/Web/Javascripts/extended/array.js b/framework/Web/Javascripts/extended/array.js new file mode 100644 index 00000000..2aeb9084 --- /dev/null +++ b/framework/Web/Javascripts/extended/array.js @@ -0,0 +1,465 @@ +/**
+ARRAY EXTENSIONS
+by Caio Chassot (http://v2studio.com/k/code/)
+*/
+
+//function v2studio_com_code()
+//{
+
+
+/**
+ * Searches Array for <b>value</b>.
+ * returns the index of the first item
+ * which matches <b>value</b>, or -1 if not found.
+ * searching starts at index 0, or at <b>start</b>, if specified.
+ *
+ * Here are the rules for an item to match <b>value</b>
+ * if strict is false or not specified (default):
+ * if <b>value</b> is a:
+ * # <b>function</b> -> <b>value(item)</b> must be true
+ * # <b>RegExp</b> -> <b>value.test(item)</b> must be true
+ * # anything else -> <b>item == value</b> must be true
+ * @param value the value (function, regexp) to search
+ * @param start where to start the search
+ * @param strict use strict comparison (===) for everything
+ */
+Array.prototype.indexOf = function(value, start, strict) {
+ start = start || 0;
+ for (var i=start; i<this.length; i++) {
+ var item = this[i];
+ if (strict ? item === value :
+ isRegexp(value) ? value.test(item) :
+ isFunction(value) ? value(item) :
+ item == value)
+ return i;
+ }
+ return -1;
+}
+
+/**
+ * searches Array for <b>value</b> returns the first matched item, or null if not found
+ * Parameters work the same as indexOf
+ * @see #indexOf
+ */
+Array.prototype.find = function(value, start, strict) {
+ var i = this.indexOf(value, start, strict);
+ if (i != -1) return this[i];
+ return null
+}
+
+
+
+/* A.contains(value [, strict])
+/**
+ * aliases: has, include
+ * returns true if <b>value</b> is found in Array, otherwise false;
+ * relies on indexOf, see its doc for details on <b>value</b> and <b>strict</b>
+ * @see #indexOf
+ */
+Array.prototype.contains = function(value,strict) {
+ return this.indexOf(value,0,strict) !== -1;
+}
+
+
+Array.prototype.has = Array.prototype.contains;
+
+Array.prototype.include = Array.prototype.contains;
+
+
+/**
+ * counts occurences of <b>value</b> in Array
+ * relies on indexOf, see its doc for details on <b>value</b> and <b>strict</b>
+ * @see #indexOf
+ */
+Array.prototype.count = function(value, strict) {
+ var pos, start = 0, count = 0;
+ while ((pos = this.indexOf(value, start, strict)) !== -1) {
+ start = pos + 1;
+ count++;
+ }
+ return count;
+}
+
+
+/**
+ * if <b>all</b> is false or not provied:
+ * removes first occurence of <b>value</b> from Array
+ * if <b>all</b> is provided and true:
+ * removes all occurences of <b>value</b> from Array
+ * returns the array
+ * relies on indexOf, see its doc for details on <b>value</b> and <b>strict</b>
+ * @see #indexOf
+ */
+Array.prototype.remove = function(value,all,strict) {
+ while (this.contains(value,strict)) {
+ this.splice(this.indexOf(value,0,strict),1);
+ if (!all) break
+ }
+ return this;
+}
+
+
+
+/* A.merge(a [, a]*)
+ Append the contents of provided arrays into the current
+ takes: one or more arrays
+ returns: current array (modified)
+*/
+Array.prototype.merge = function() {
+ var a = [];
+ for (var i=0; i<arguments.length; i++)
+ for (var j=0; j<arguments[i].length; j++)
+ a.push(arguments[i][j]);
+ for (var i=0; i<a.length; i++) this.push(a[i]);
+ return this
+}
+
+
+
+/* A.min()
+ returns the smallest item in array by comparing them with >
+*/
+Array.prototype.min = function() {
+ if (!this.length) return;
+ var n = this[0];
+ for (var i=1; i<this.length; i++) if (n>this[i]) n=this[i];
+ return n;
+}
+
+
+
+/* A.min()
+ returns the graetest item in array by comparing them with <
+*/
+Array.prototype.max = function() {
+ if (!this.length) return;
+ var n = this[0];
+ for (var i=1; i<this.length; i++) if (n<this[i]) n=this[i];
+ return n;
+}
+
+
+
+/* A.first()
+ returns first element of Array
+*/
+Array.prototype.first = function() { return this[0] }
+
+
+
+/* A.last()
+ returns last element of Array
+*/
+Array.prototype.last = function() { return this[this.length-1] }
+
+
+
+/* A.sjoin()
+ Shorthand for A.join(' ')
+*/
+Array.prototype.sjoin = function() { return this.join(' ') }
+
+
+
+/* A.njoin()
+ Shorthand for A.join('\n')
+*/
+Array.prototype.njoin = function() { return this.join('\n') }
+
+
+
+/* A.cjoin()
+ Shorthand for A.join(', ')
+*/
+Array.prototype.cjoin = function() { return this.join(', ') }
+
+
+
+/* A.equals(a [, strict])
+ true if all elements of array are equal to all elements of `a` in the same
+ order. if strict is specified and true, all elements must be equal and of
+ the same type.
+*/
+Array.prototype.equals = function(a, strict){
+ if (this==a) return true;
+ if (a.length != this.length) return false;
+ return this.map(function(item,idx){
+ return strict? item === a[idx] : item == a[idx]
+ }).all();
+}
+
+
+
+/* A.all([fn])
+ Returns true if fn returns true for all elements in array
+ if fn is not specified, returns true if all elements in array evaluate to
+ true
+*/
+Array.prototype.all = function(fn) {
+ return filter(this, fn).length == this.length;
+}
+
+
+
+/* A.any([fn])
+ Returns true if fn returns true for any elements in array
+ if fn is not specified, returns true if at least one element in array
+ evaluates to true
+*/
+Array.prototype.any = function(fn) {
+ return filter(this, fn).length > 0;
+}
+
+
+
+/* A.each(fn)
+ method form of each function
+*/
+Array.prototype.each = function(fn) { return each(this, fn) }
+
+
+
+/* A.map([fn])
+ method form of map function
+*/
+Array.prototype.map = function(fn) { return map(this, fn) }
+
+
+
+/* A.filter([fn])
+ method form of filter function
+*/
+Array.prototype.filter = function(fn) { return filter(this, fn) }
+
+
+Array.prototype.select = Array.prototype.filter
+
+
+/* A.reduce([initial,] fn)
+ method form of filter function
+*/
+Array.prototype.reduce = function() {
+ var args = map(arguments);
+ fn = args.pop();
+ d = args.pop();
+ return reduce(this, d, fn);
+}
+
+
+Array.prototype.inject = Array.prototype.reduce
+
+
+
+/* A.reject(fn)
+ deletes items in A *in place* for which fn(item) is true
+ returns a
+*/
+Array.prototype.reject = function(fn) {
+ if (typeof(fn)=='string') fn = __strfn('item,idx,list', fn);
+ var self = this;
+ var itemsToRemove = [];
+ fn = fn || function(v) {return v};
+ map(self, function(item,idx,list) { if (fn(item,idx,list)) itemsToRemove.push(idx) } );
+ itemsToRemove.reverse().each(function(idx) { self.splice(idx,1) });
+ return self;
+}
+
+
+
+/* __strfn(args, fn)
+ this is used internally by each, map, combine, filter and reduce to accept
+ strings as functions.
+
+ takes:
+ `args` -> a string of comma separated names of the function arguments
+ `fn` -> the function body
+
+ if `fn` does not contain a return statement, a return keyword will be added
+ before the last statement. the last statement is determined by removing the
+ trailing semicolon (';') (if it exists) and then searching for the last
+ semicolon, hence, caveats may apply (i.e. if the last statement has a
+ string or regex containing the ';' character things will go wrong)
+*/
+function __strfn(args, fn) {
+ function quote(s) { return '"' + s.replace(/"/g,'\\"') + '"' }
+ if (!/\breturn\b/.test(fn)) {
+ fn = fn.replace(/;\s*$/, '');
+ fn = fn.insert(fn.lastIndexOf(';')+1, ' return ');
+ }
+ return eval('new Function('
+ + map(args.split(/\s*,\s*/), quote).join()
+ + ','
+ + quote(fn)
+ + ')'
+ );
+}
+
+
+
+/* each(list, fn)
+ traverses `list`, applying `fn` to each item of `list`
+ takes:
+ `list` -> anything that can be indexed and has a `length` property.
+ usually an array.
+ `fn` -> either a function, or a string containing a function body,
+ in which case the name of the paremeters passed to it will be
+ 'item', 'idx' and 'list'.
+ se doc for `__strfn` for peculiarities about passing strings
+ for `fn`
+
+ `each` provides a safe way for traversing only an array's indexed items,
+ ignoring its other properties. (as opposed to how for-in works)
+*/
+function each(list, fn) {
+ if (typeof(fn)=='string') return each(list, __strfn('item,idx,list', fn));
+ for (var i=0; i < list.length; i++) fn(list[i], i, list);
+}
+
+
+/* map(list [, fn])
+ traverses `list`, applying `fn` to each item of `list`, returning an array
+ of values returned by `fn`
+
+ parameters work the same as for `each`, same `__strfn` caveats apply
+
+ if `fn` is not provided, the list item is returned itself. this is an easy
+ way to transform fake arrays (e.g. the arguments object of a function or
+ nodeList objects) into real javascript arrays.
+ e.g.: args = map(arguments)
+
+ If you don't care about map's return value, you should use `each`
+
+ this is a simplified version of python's map. parameter order is different,
+ only a single list (array) is accepted, and the parameters passed to [fn]
+ are different:
+ [fn] takes the current item, then, optionally, the current index and a
+ reference to the list (so that [fn] can modify list)
+ see `combine` if you want to pass multiple lists
+*/
+function map(list, fn) {
+ if (typeof(fn)=='string') return map(list, __strfn('item,idx,list', fn));
+
+ var result = [];
+ fn = fn || function(v) {return v};
+ for (var i=0; i < list.length; i++) result.push(fn(list[i], i, list));
+ return result;
+}
+
+
+/* combine(list [, list]* [, fn])
+
+ takes:
+ `list`s -> one or more lists (see `each` for definition of a list)
+ `fn` -> Similar s `each` or `map`, a function or a string containing
+ a function body.
+ if a string is used, the name of parameters passed to the
+ created function will be the lowercase alphabet letters, in
+ order: a,b,c...
+ same `__strfn` caveats apply
+
+ combine will traverse all lists concurrently, passing each row if items as
+ parameters to `fn`
+ if `fn` is not provided, a function that returns a list containing each
+ item in the row is used.
+ if a list is smaller than the other, `null` is used in place of its missing
+ items
+
+ returns:
+ an array of the values returned by calling `fn` for each row of items
+*/
+function combine() {
+ var args = map(arguments);
+ var lists = map(args.slice(0,-1),'map(item)');
+ var fn = args.last();
+ var toplen = map(lists, "item.length").max();
+ var vals = [];
+
+ if (!fn) fn = function(){return map(arguments)};
+ if (typeof fn == 'string') {
+ if (lists.length > 26) throw 'string functions can take at most 26 lists';
+ var a = 'a'.charCodeAt(0);
+ fn = __strfn(map(range(a, a+lists.length),'String.fromCharCode(item)').join(','), fn);
+ }
+
+ map(lists, function(li) {
+ while (li.length < toplen) li.push(null);
+ map(li, function(item,ix){
+ if (ix < vals.length) vals[ix].push(item);
+ else vals.push([item]);
+ });
+ });
+
+ return map(vals, function(val) { return fn.apply(fn, val) });
+}
+
+
+
+/* filter(list [, fn])
+ returns an array of items in `list` for which `fn(item)` is true
+
+ parameters work the same as for `each`, same `__strfn` caveats apply
+
+ if `fn` is not specified the items are evaluated themselves, that is,
+ filter will return an array of the items in `list` which evaluate to true
+
+ this is a similar to python's filter, but parameter order is inverted
+*/
+function filter(list, fn) {
+ if (typeof(fn)=='string') return filter(list, __strfn('item,idx,list', fn));
+
+ var result = [];
+ fn = fn || function(v) {return v};
+ map(list, function(item,idx,list) { if (fn(item,idx,list)) result.push(item) } );
+ return result;
+}
+
+
+
+/* reduce(list [, initial], fn)
+ similar to python's reduce. paremeter onder inverted...
+
+ TODO: document this properly
+
+ takes:
+ `list` -> see doc for `each` to learn more about it
+ `inirial -> TODO: doc`
+ `fn` -> similar to `each` too, but in the case where it's a string,
+ the name of the paremeters passed to it will be 'a' and 'b'
+ same `__strfn` caveats apply
+
+*/
+function reduce(list, initial, fn) {
+ if (undef(fn)) {
+ fn = initial;
+ initial = window.undefined; // explicit `window` object so browsers that do not have an `undefined` keyword will evaluate to the (hopefully) undefined parameter `undefined` of `window`
+ }
+ if (typeof(fn)=='string') return reduce(list, initial, __strfn('a,b', fn));
+ if (isdef(initial)) list.splice(0,0,initial);
+ if (list.length===0) return false;
+ if (list.length===1) return list[0];
+ var result = list[0];
+ var i = 1;
+ while(i<list.length) result = fn(result,list[i++]);
+ return result;
+}
+
+/* range(start, stop, step)
+ identical to python's range.
+ range(stop)
+ range(start,stop)
+ range(start,stop,step)
+
+ Return a list containing an arithmetic progression of integers.
+ range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
+ When step is given, it specifies the increment (or decrement).
+ For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!
+ [from python's range's docstring]
+*/
+function range(start,stop,step) {
+ if (isUndefined(stop)) return range(0,start,step);
+ if (isUndefined(step)) step = 1;
+ var ss = (step/Math.abs(step)); // step sign
+ var r = [];
+ for (i=start; i*ss<stop*ss; i=i+step) r.push(i);
+ return r;
+}
\ No newline at end of file |