prototype.js

用来在地图上做操作GIS,在地图上做标记

 * @param {Function} [iterator]	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Array} Returns an array of the elements with a match to the RegExp. If you specify an iterator, returns the result of calling the iterator on the match.
 */
  grep: function(pattern, iterator) {
    var results = [];
    this.each(function(value, index) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((iterator || Prototype.K)(value, index));
    })
    return results;
  },

 /**
 * Searches the list of elements for the specified object.
 * @alias Enumerable.include
 * @param {Object} object	Object to search for.
 * @return {Boolean} Returns true if the list of elements contains the object.
 */
  include: function(object) {
    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  },

  /**
   * Groups items in fixed-size chunks, using a specific value to fill up the last chunk if necessary.
   * @alias Enumerable.inGroupsOf
   * @param {Number} number	Number in each group
   * @param {Object} fillWith	Value to fill with
   * @return {Object} Returns formatted data.
   */
  inGroupsOf: function(number, fillWith) {
    fillWith = fillWith === undefined ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  },

 /**
 * Calls an iterator function on the elements in a list and accumulates their values into a single value.
 * @alias Enumerable.inject
 * @param {Object} memo	Initial value for the iterator.
 * @param {Function} iterator	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Object} Returns the final accumulated result.
 */
  inject: function(memo, iterator) {
    this.each(function(value, index) {
      memo = iterator(memo, value, index);
    });
    return memo;
  },

 /**
 * Calls the specified method on each element in a list and returns an array of the results.
 * @alias Enumerable.invoke
 * @param {Function} method	Method to call.
 * @return {Array} Returns an array of the results.
 */
  invoke: function(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  },

 /**
 * Returns the element in the list with the greatest value. If you specify an iterator, calls the iterator function and returns the result with the greatest value.
 * @alias Enumerable.max
 * @param {Function} [iterator]	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Object} Returns the element in the list with the greatest value. If you specify an iterator, calls the iterator function and returns the result with the greatest value.
 */
  max: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value >= result)
        result = value;
    });
    return result;
  },

 /**
 * Returns the element in the list with the smallest value. If you specify an iterator, calls the iterator function and returns the result with the smallest value.
 * @alias Enumerable.min
 * @param {Function} [iterator]	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Object} Returns the element in the list with the smallest value. If you specify an iterator, calls the iterator function and returns the result with the smallest value.
 */
  min: function(iterator) {
    var result;
    this.each(function(value, index) {
      value = (iterator || Prototype.K)(value, index);
      if (result == undefined || value < result)
        result = value;
    });
    return result;
  },

 /**
 * Partitions a list of elements into true elements or values and not-true elements or values.
 * @alias Enumerable.partition
 * @param {Object} [iterator]	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Array} Returns an array of two elements--both of which are arrays. The first array contains all true elements or values (if you specify an iterator) and the second array contains not-true elements or values.
 */
  partition: function(iterator) {
    var trues = [], falses = [];
    this.each(function(value, index) {
      ((iterator || Prototype.K)(value, index) ?
        trues : falses).push(value);
    });
    return [trues, falses];
  },

 /**
 * Retrieves the value for the specified property for each element in an array.
 * @alias Enumerable.pluck
 * @param {String} property	Name of the property to get.
 * @return {Array} Returns an array of the property values.
 */
  pluck: function(property) {
    var results = [];
    this.each(function(value, index) {
      results.push(value[property]);
    });
    return results;
  },

 /**
 * Calls an iterator function on the elements in a list and returns all of the elements that cause the iterator to return false.
 * @alias Enumerable.reject
 * @param {Function} iterator	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Array} Returns the elements that the cause the iterator to return false.
 */
  reject: function(iterator) {
    var results = [];
    this.each(function(value, index) {
      if (!iterator(value, index))
        results.push(value);
    });
    return results;
  },

 /**
 * Sorts the elements in a list by their iterator results.
 * @alias Enumerable.sortBy
 * @param {Object} iterator	Iterator function to call. Takes the arguments elementValue, and elementIndex, respectively.
 * @return {Array} Returns an array of elements sorted by their iterator results.
 */
  sortBy: function(iterator) {
    return this.map(function(value, index) {
      return {value: value, criteria: iterator(value, index)};
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  },

 /**
 * Creates an array of the elements in a list.
 * @alias Enumerable.toArray
 * @return {Array} Returns an Array of elements in the list.
 */
  toArray: function() {
    return this.map();
  },

 /**
 * Merges elements from one or more lists into a single list.
 * @alias Enumerable.zip()
 * @param {Array} ... One or more lists of elements to merge.
 * @return {Array} Returns a single array.
 */
  zip: function() {
    var iterator = Prototype.K, args = $A(arguments);
    if (typeof args.last() == 'function')
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  },

  /**
   * Returns the size of the enumeration.
   * @alias Enumerable.size
   * @return {Number} Returns the size of the enumeration.
   */
  size: function() {
    return this.toArray().length;
  },

 /**
 * Returns a human-readable string version of the list of elements.
 * @alias Enumerable.inspect
 * @return {String} Returns a human-readable string version of the list of elements.
 */
  inspect: function() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }
}

Object.extend(Enumerable, {
  map:     Enumerable.collect,
  find:    Enumerable.detect,
  select:  Enumerable.findAll,
  member:  Enumerable.include,
  entries: Enumerable.toArray
});

/**
 * Converts the argument "iterable" into an Array object.
 * @alias $A
 * @param {Object} iterable	Object to be converted to an Array.
 * @return {Array} Returns an Array.
 */
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) {
    return iterable.toArray();
  } else {
    var results = [];
    for (var i = 0, length = iterable.length; i < length; i++)
      results.push(iterable[i]);
    return results;
  }
}

if (Prototype.Browser.WebKit) {
  $A = Array.from = function(iterable) {
    if (!iterable) return [];
    if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
      iterable.toArray) {
      return iterable.toArray();
    } else {
      var results = [];
      for (var i = 0, length = iterable.length; i < length; i++)
        results.push(iterable[i]);
      return results;
    }
  }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
  Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: function(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  },

 /**
 * Clears an array of all content.
 * @alias Array.clear
 * @return {Array} Returns an empty array.
 * @extends {Array}
 */
  clear: function() {
    this.length = 0;
    return this;
  },

 /**
 * Returns the first element of an array.
 * @alias Array.first
 * @return {Object, String, Number} Returns the first element of an array.
 * @extends {Array}
 */
  first: function() {
    return this[0];
  },

 /**
 * Returns the last element of an array.
 * @alias Array.last
 * @return {Object, String, Number} Returns the last element of an array.
 * @extends {Array}
 */
  last: function() {
    return this[this.length - 1];
  },

  /**
   * Returns a new version of the array, without any null/undefined values.
   * @alias Array.compact
   * @return {Array}	Returns a new version of the array, without any null/undefined values.
   * @extends {Array}
   */
  compact: function() {
    return this.select(function(value) {
      return value != null;
    });
  },

 /**
 * Flattens an array containing elements that are arrays into a single array.
 * @alias Array.flatten
 * @return {Array} Returns a one-dimensional array.
 * @extends {Array}
 */
  flatten: function() {
    return this.inject([], function(array, value) {
      return array.concat(value && value.constructor == Array ?
        value.flatten() : [value]);
    });
  },

  /**
  * Returns an array without the specified elements.
  * @alias Array.without
  * @param {Array, String, Number} ... One or more elements to exclude from the array.
  * @return {Array} Returns an array without the specified elements.
  * @extends {Array}
  */
  without: function() {
    var values = $A(arguments);
    return this.select(function(value) {
      return !values.include(value);
    });
  },

  /**
  * Gets the zero-based index position of the specified element in an array.
  * @alias Array.indexOf
  * @param {Object} object	Element to get the index position of.
  * @return {Number} Returns the index position of the element.
  * @extends {Array}
  */
  indexOf: function(object) {
    for (var i = 0, length = this.length; i < length; i++)
      if (this[i] == object) return i;
    return -1;
  },

  /**
  * Reverses the order of elements in an array.
  * @alias Array.reverse
  * @param {Boolean} inline	If true, indicates that the array itself should be reversed, instead of just creating a copy. Default is true.
  * @return {Array} Returns an array with the order of its elements reversed.
  * @extends {Array}
  */
  reverse: function(inline) {
    return (inline !== false ? this : this.toArray())._reverse();
  },

  /**
   * Reduces arrays: one-element arrays are turned into their unique element, while multiple-element arrays are returned untouched.
   * @alias Array.reduce
   * @return {Array} Returns the reduced array.
   * @extends {Array}
   */
  reduce: function() {
    return this.length > 1 ? this : this[0];
  },

  /**
   * Produces a duplicate-free version of an array. If no duplicates are found, the original array is returned.
   * @alias Array.uniq
   * @param {Object} sorted
   * @return {Array} Produces a duplicate-free version of an array. If no duplicates are found, the original array is returned.
   * @extends {Array}
   */
  uniq: function(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  },

  /**
   * Returns a duplicate of the array, leaving the original array intact.
   * @alias Array.clone
   * @return {Array} Returns a duplicate of the array, leaving the original array intact.
   * @extends {Array}
   */
  clone: function() {
    return [].concat(this);
  },

  /**
   * Returns the size of the array.
   * @alias Array.size
   * @return {Array} Returns the size of the array.
   * @extends {Array}
   */
  size: function() {
    return this.length;
  },

  /**
  * Formats an array into a human-readable string.
  * @alias Array.inspect
  * @return {String} Returns a string version of the array.
  * @extends {Array}
  */
  inspect: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  },

  /**
   * Returns a JSON string.
   * @alias Array.toJSON
   * @return {Array}	Returns a JSON string.
   * @extends {Array}
   */
  toJSON: function() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (value !== undefined) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }