java property.js与jquery兼容修改property.js源文件

一、jsp页面首先引用jquery，在引用修改后的property.js。prototype.js 1.4 和jquery 1.91。

二、可以同时使用property自带的ajax请求和jquery的ajax请求。

三、删除了property.js中$，代码中只能应用ajax请求。

  var params = Form.serialize('form1');

  var myAjax = new Ajax.Request(

  url,

  {

   method:'post',

   parameters:params,

   onComplete: listprocessResponse,

   asynchronous:true

  });

function listprocessResponse(request){

var txt= request.responseText;

}

四、主要应用比较老的系统架构应用ajax请求而需要引入jquery而做出的修改。

五、下面是prototype.js修改后的代码：

/*  Prototype JavaScript framework, version 1.4.0

 *  (c) 2005 Sam Stephenson <sam@conio.net>

 *

 *  Prototype is freely distributable under the terms of an MIT-style license.

 *  For details, see the Prototype web site: http://prototype.conio.net/
 *

/*--------------------------------------------------------------------------*/

var Prototype = {

  Version: '1.4.0',

  ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',

  emptyFunction: function() {},

  K: function(x) {return x}

}

var Class = {

  create: function() {

    return function() {

      this.initialize.apply(this, arguments);

    }

  }

}

Object.extend = function(destination, source) {

  for (property in source) {

    destination[property] = source[property];

  }

  return destination;

}

Function.prototype.bind = function() {

  var __method = this, args = $A(arguments), object = args.shift();

  return function() {

    return __method.apply(object, args.concat($A(arguments)));

  }

}

Function.prototype.bindAsEventListener = function(object) {

  var __method = this;

  return function(event) {

    return __method.call(object, event || window.event);

  }

}

 

var Try = {

  these: function() {

    var returnValue;

    for (var i = 0; i < arguments.length; i++) {

      var lambda = arguments[i];

      try {

        returnValue = lambda();

        break;

      } catch (e) {}

    }

    return returnValue;

  }

}

ObjectRange = Class.create();

Object.extend(ObjectRange.prototype, Enumerable);

Object.extend(ObjectRange.prototype, {

  initialize: function(start, end, exclusive) {

    this.start = start;

    this.end = end;

    this.exclusive = exclusive;

  },

  _each: function(iterator) {

    var value = this.start;

    do {

      iterator(value);

      value = value.succ();

    } while (this.include(value));

  },

  include: function(value) {

    if (value < this.start)

      return false;

    if (this.exclusive)

      return value < this.end;

    return value <= this.end;

  }

});

String.prototype.parseQuery = String.prototype.toQueryParams;

var $break    = new Object();

var $continue = new Object();

var Enumerable = {

  each: function(iterator) {

    var index = 0;

    try {

      this._each(function(value) {

        try {

          iterator(value, index++);

        } catch (e) {

          if (e != $continue) throw e;

        }

      });

    } catch (e) {

      if (e != $break) throw e;

    }

  },

  all: function(iterator) {

    var result = true;

    this.each(function(value, index) {

      result = result && !!(iterator || Prototype.K)(value, index);

      if (!result) throw $break;

    });

    return result;

  },

  any: function(iterator) {

    var result = true;

    this.each(function(value, index) {

      if (result = !!(iterator || Prototype.K)(value, index))

        throw $break;

    });

    return result;

  },

  collect: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      results.push(iterator(value, index));

    });

    return results;

  },

  detect: function (iterator) {

    var result;

    this.each(function(value, index) {

      if (iterator(value, index)) {

        result = value;

        throw $break;

      }

    });

    return result;

  },

  findAll: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      if (iterator(value, index))

        results.push(value);

    });

    return results;

  },

  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;

  },

  include: function(object) {

    var found = false;

    this.each(function(value) {

      if (value == object) {

        found = true;

        throw $break;

      }

    });

    return found;

  },

  inject: function(memo, iterator) {

    this.each(function(value, index) {

      memo = iterator(memo, value, index);

    });

    return memo;

  },

  invoke: function(method) {

    var args = $A(arguments).slice(1);

    return this.collect(function(value) {

      return value[method].apply(value, args);

    });

  },

  max: function(iterator) {

    var result;

    this.each(function(value, index) {

      value = (iterator || Prototype.K)(value, index);

      if (value >= (result || value))

        result = value;

    });

    return result;

  },

  min: function(iterator) {

    var result;

    this.each(function(value, index) {

      value = (iterator || Prototype.K)(value, index);

      if (value <= (result || value))

        result = value;

    });

    return result;

  },

  partition: function(iterator) {

    var trues = [], falses = [];

    this.each(function(value, index) {

      ((iterator || Prototype.K)(value, index) ?

        trues : falses).push(value);

    });

    return [trues, falses];

  },

  pluck: function(property) {

    var results = [];

    this.each(function(value, index) {

      results.push(value[property]);

    });

    return results;

  },

  reject: function(iterator) {

    var results = [];

    this.each(function(value, index) {

      if (!iterator(value, index))

        results.push(value);

    });

    return results;

  },

  sortBy: function(iterator) {

    return this.collect(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');

  },

  toArray: function() {

    return this.collect(Prototype.K);

  },

  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) {

      iterator(value = collections.pluck(index));

      return value;

    });

  },

  inspect: function() {

    return '#<Enumerable:' + this.toArray().inspect() + '>';

  }

}

Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {

  _each: function(iterator) {

    for (var i = 0; i < this.length; i++)

      iterator(this[i]);

  },

  clear: function() {

    this.length = 0;

    return this;

  },

  first: function() {

    return this[0];

  },

  last: function() {

    return this[this.length - 1];

  },

  compact: function() {

    return this.select(function(value) {

      return value != undefined || value != null;

    });

  },

  flatten: function() {

    return this.inject([], function(array, value) {

      return array.concat(value.constructor == Array ?

        value.flatten() : [value]);

    });

  },

  without: function() {

    var values = $A(arguments);

    return this.select(function(value) {

      return !values.include(value);

    });

  },

  indexOf: function(object) {

    for (var i = 0; i < this.length; i++)

      if (this[i] == object) return i;

    return -1;

  },

  reverse: function(inline) {

    return (inline !== false ? this : this.toArray())._reverse();

  },

  shift: function() {

    var result = this[0];

    for (var i = 0; i < this.length - 1; i++)

      this[i] = this[i + 1];

    this.length--;

    return result;

  },

  inspect: function() {

    return '[' + this.map(Object.inspect).join(', ') + ']';

  }

});

var Hash = {

  _each: function(iterator) {

    for (key in this) {

      var value = this[key];

      if (typeof value == 'function') continue;

      var pair = [key, value];

      pair.key = key;

      pair.value = value;

      iterator(pair);

    }

  },

  keys: function() {

    return this.pluck('key');

  },

  values: function() {

    return this.pluck('value');

  },

  merge: function(hash) {

    return $H(hash).inject($H(this), function(mergedHash, pair) {

      mergedHash[pair.key] = pair.value;

      return mergedHash;

    });

  },

  toQueryString: function() {

    return this.map(function(pair) {

      return pair.map(encodeURIComponent).join('=');

    }).join('&');

  },

  inspect: function() {

    return '#<Hash:{' + this.map(function(pair) {

      return pair.map(Object.inspect).join(': ');

    }).join(', ') + '}>';

  }

}

var Ajax = {

  getTransport: function() {

    return Try.these(

      function() {return new ActiveXObject('Msxml2.XMLHTTP')},

      function() {return new ActiveXObject('Microsoft.XMLHTTP')},

      function() {return new XMLHttpRequest()}

    ) || false;

  },

  activeRequestCount: 0

}

Ajax.Responders = {

  responders: [],

  _each: function(iterator) {

    this.responders._each(iterator);

  },

  register: function(responderToAdd) {

    if (!this.include(responderToAdd))

      this.responders.push(responderToAdd);

  },

  unregister: function(responderToRemove) {

    this.responders = this.responders.without(responderToRemove);

  },

  dispatch: function(callback, request, transport, json) {

    this.each(function(responder) {

      if (responder[callback] && typeof responder[callback] == 'function') {

        try {

          responder[callback].apply(responder, [request, transport, json]);

        } catch (e) {}

      }

    });

  }

};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({

  onCreate: function() {

    Ajax.activeRequestCount++;

  },

  onComplete: function() {

    Ajax.activeRequestCount--;

  }

});

Ajax.Base = function() {};

Ajax.Base.prototype = {

  setOptions: function(options) {

    this.options = {

      method:       'post',

      asynchronous: true,

      parameters:   ''

    }

    Object.extend(this.options, options || {});

  },

  responseIsSuccess: function() {

    return this.transport.status == undefined

        || this.transport.status == 0

        || (this.transport.status >= 200 && this.transport.status < 300);

  },

  responseIsFailure: function() {

    return !this.responseIsSuccess();

  }

}

Ajax.Request = Class.create();

Ajax.Request.Events =

  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {

  initialize: function(url, options) {

    this.transport = Ajax.getTransport();

    this.setOptions(options);

    this.request(url);

  },

  request: function(url) {

 

    var parameters = this.options.parameters || '';

    if (parameters.length > 0) parameters += '&_=';

    try {

      this.url = url;

      if (this.options.method == 'get' && parameters.length > 0)

        this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

      Ajax.Responders.dispatch('onCreate', this, this.transport);

     

      this.transport.open(this.options.method, this.url,

        this.options.asynchronous);

      if (this.options.asynchronous) {

     

        this.transport.onreadystatechange = this.onStateChange.bind(this);

        setTimeout((function() {this.respondToReadyState(1)}).bind(this), 10);

      }

      this.setRequestHeaders();

      var body = this.options.postBody ? this.options.postBody : parameters;

      this.transport.send(this.options.method == 'post' ? body : null);

    } catch (e) {

      this.dispatchException(e);

    }

  },

  setRequestHeaders: function() {

    var requestHeaders =

      ['X-Requested-With', 'XMLHttpRequest',

       'X-Prototype-Version', Prototype.Version];

    if (this.options.method == 'post') {

      requestHeaders.push('Content-type',

        'application/x-www-form-urlencoded');

      /* Force "Connection: close" for Mozilla browsers to work around

       * a bug where XMLHttpReqeuest sends an incorrect Content-length

       * header. See Mozilla Bugzilla #246651.

       */

      if (this.transport.overrideMimeType)

        requestHeaders.push('Connection', 'close');

    }

    if (this.options.requestHeaders)

      requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

    for (var i = 0; i < requestHeaders.length; i += 2)

      this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);

     

  },

  onStateChange: function() {

    var readyState = this.transport.readyState;

    if (readyState != 1)

      this.respondToReadyState(this.transport.readyState);

  },

  header: function(name) {

    try {

      return this.transport.getResponseHeader(name);

    } catch (e) {}

  },

  evalJSON: function() {

    try {

      return eval(this.header('X-JSON'));

    } catch (e) {}

  },

  evalResponse: function() {

    try {

      return eval(this.transport.responseText);

    } catch (e) {

      this.dispatchException(e);

    }

  },

  respondToReadyState: function(readyState) {

    var event = Ajax.Request.Events[readyState];

    var transport = this.transport, json = this.evalJSON();

    if (event == 'Complete') {

      try {

        (this.options['on' + this.transport.status]

         || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]

         || Prototype.emptyFunction)(transport, json);

      } catch (e) {

        this.dispatchException(e);

      }

      if ((this.header('Content-type') || '').match(/^text\/javascript/i))

        this.evalResponse();

    }

    try {

      (this.options['on' + event] || Prototype.emptyFunction)(transport, json);

      Ajax.Responders.dispatch('on' + event, this, transport, json);

    } catch (e) {

      this.dispatchException(e);

    }

    /* Avoid memory leak in MSIE: clean up the oncomplete event handler */

    if (event == 'Complete')

      this.transport.onreadystatechange = Prototype.emptyFunction;

  },

  dispatchException: function(exception) {

    (this.options.onException || Prototype.emptyFunction)(this, exception);

    Ajax.Responders.dispatch('onException', this, exception);

  }

});

Object.extend(Enumerable, {

  map:     Enumerable.collect,

  find:    Enumerable.detect,

  select:  Enumerable.findAll,

  member:  Enumerable.include,

  entries: Enumerable.toArray

});

var $A = Array.from = function(iterable) {

  if (!iterable) return [];

  if (iterable.toArray) {

    return iterable.toArray();

  } else {

    var results = [];

    for (var i = 0; i < iterable.length; i++)

      results.push(iterable[i]);

    return results;

  }

}

Object.extend(Array.prototype, Enumerable);

var Form = {

 serialize: function(form) {

  return $('#'+form).serialize();

 }

}