我思故我强

prototype学习资料(一)


prototype学习资料(一)

关键字:   prototype学习资料    
js 代码
  1. prototype 1.3.1 版本和之前的 1.2.0 版本有了不少改进,并增加了新的功能:    
  2. 1. 增加了事件注册管理    
  3. 2. 增加了空间定位的常用函数    
  4. 3. 改善了 xmlhttp 的封装    
  5. 4. 移除了 Effect.js,交给 Rico 或者 script.aculo.us 这些扩展库类实现。    
  6. 5. bug 修复    
  7. 代码:    
  8. /**   
  9. * 定义一个全局对象, 属性 Version 在发布的时候会替换为当前版本号   
  10. */     
  11. var  Prototype = {    
  12. Version: '1.3.1',    
  13. // 一个空方法,其后的代码常会用到,先前的版本该方法被定义于 Ajax 类中。    
  14. emptyFunction:  function () {}    
  15. }    
  16. /**   
  17. * 创建一种类型,注意其属性 create 是一个方法,返回一个构造函数。   
  18. * 一般使用如下   
  19. * var X = Class.create(); 返回一个类型,类似于 java 的一个Class实例。   
  20. * 要使用 X 类型,需继续用 new X()来获取一个实例,如同 java 的 Class.newInstance()方法。   
  21.  
  22. * 返回的构造函数会执行名为 initialize 的方法, initialize 是 Ruby 对象的构造器方法名字。   
  23. * 此时initialize方法还没有定义,其后的代码中创建新类型时会建立相应的同名方法。   
  24.  
  25. */     
  26. var  Class = {    
  27. create:  function () {    
  28. return   function () {    
  29. this .initialize.apply( this , arguments);    
  30. }    
  31. }    
  32. }    
  33. /**   
  34. * 创建一个对象,从变量名来思考,本意也许是定义一个抽象类,以后创建新对象都 extend 它。   
  35. * 但从其后代码的应用来看, Abstract 更多是为了保持命名空间清晰的考虑。   
  36. * 也就是说,我们可以给 Abstract 这个对象实例添加新的对象定义。   
  37. */     
  38. var  Abstract =  new  Object();    
  39. Object.extend =  function (destination, source) {    
  40. for  (property  in  source) {    
  41. destination[property] = source[property];    
  42. }    
  43. return  destination;    
  44. }    
  45. /**   
  46. * 获取参数对象的所有属性和方法,有点象多重继承。但是这种继承是动态获得的。   
  47. * 如:   
  48. * var a = new ObjectA(), b = new ObjectB();   
  49. * var c = a.extend(b);   
  50. * 此时 c 对象同时拥有 a 和 b 对象的属性和方法。但是与多重继承不同的是,c instanceof ObjectB 将返回false。   
  51.  
  52. * 旧版本的该方法定义如下:   
  53. * Object.prototype.extend = function(object) {   
  54. * for (property in object) {   
  55. * this[property] = object[property];   
  56. * }   
  57. * return this;   
  58. * }   
  59.  
  60. * 新的形式新定义了一个静态方法 Object.extend,这样做的目的大概是为了使代码更为清晰   
  61. */     
  62. Object.prototype.extend =  function (object) {    
  63. return  Object.extend.apply( this , [ this , object]);    
  64. }    
  65. /**   
  66. * 这个方法很有趣,它封装一个javascript函数对象,返回一个新函数对象,新函数对象的主体和原对象相同,但是bind()方法参数将被用作当前对象的对象。   
  67. * 也就是说新函数中的 this 引用被改变为参数提供的对象。   
  68. * 比如:   
  69.    
  70.    
  71. * .................   
  72. * <script>   
  73. * var aaa = document.getElementById("aaa");   
  74. * var bbb = document.getElementById("bbb");   
  75. * aaa.showValue = function() {alert(this.value);}   
  76. * aaa.showValue2 = aaa.showValue.bind(bbb);   
  77. * </script>   
  78. * 那么,调用aaa.showValue 将返回"aaa", 但调用aaa.showValue2 将返回"bbb"。   
  79.  
  80. * apply 是ie5.5后才出现的新方法(Netscape好像很早就支持了)。   
  81. * 该方法更多的资料参考MSDN http://msdn.microsoft.com/library/e...6jsmthApply.asp   
  82. * 阅读其后的代码就会发现,bind 被应用的很广泛,该方法和 Object.prototype.extend 一样是 Prototype 的核心。   
  83. * 还有一个 call 方法,应用起来和 apply 类似。可以一起研究下。   
  84. */     
  85. Function.prototype.bind =  function (object) {    
  86. var  __method =  this ;    
  87. return   function () {    
  88. __method.apply(object, arguments);    
  89. }    
  90. }    
  91. /**   
  92. * 和bind一样,不过这个方法一般用做html控件对象的事件处理。所以要传递event对象   
  93. * 注意这时候,用到了 Function.call。它与 Function.apply 的不同好像仅仅是对参数形式的定义。   
  94. */     
  95. Function.prototype.bindAsEventListener =  function (object) {    
  96. var  __method =  this ;    
  97. return   function (event) {    
  98. __method.call(object, event || window.event);    
  99. }    
  100. }    
  101. /**   
  102. * 将整数形式RGB颜色值转换为HEX形式   
  103. */     
  104. Number.prototype.toColorPart =  function () {    
  105. var  digits =  this .toString(16);    
  106. if  ( this  < 16)  return  '0' + digits;    
  107. return  digits;    
  108. }    
  109. /**   
  110. * 典型 Ruby 风格的函数,将参数中的方法逐个调用,返回第一个成功执行的方法的返回值   
  111. */     
  112. var  Try = {    
  113. these:  function () {    
  114. var  returnValue;    
  115. for  ( var  i = 0; i < arguments.length; i++) {    
  116. var  lambda = arguments;    
  117. try  {    
  118. returnValue = lambda();    
  119. break ;    
  120. catch  (e) {}    
  121. }    
  122. return  returnValue;    
  123. }    
  124. }    
  125. /*--------------------------------------------------------------------------*/     
  126. /**   
  127. * 一个设计精巧的定时执行器   
  128. * 首先由 Class.create() 创建一个 PeriodicalExecuter 类型,   
  129. * 然后用对象直接量的语法形式设置原型。   
  130.  
  131. * 需要特别说明的是 rgisterCallback 方法,它调用上面定义的函数原型方法bind, 并传递自己为参数。   
  132. * 之所以这样做,是因为 setTimeout 默认总以 window 对象为当前对象,也就是说,如果 registerCallback 方法定义如下的话:   
  133. * registerCallback: function() {   
  134. * setTimeout(this.onTimerEvent, this.frequency * 1000);   
  135. * }   
  136. * 那么,this.onTimeoutEvent 方法执行失败,因为它无法访问 this.currentlyExecuting 属性。   
  137. * 而使用了bind以后,该方法才能正确的找到this,也就是PeriodicalExecuter的当前实例。   
  138. */     
  139. var  PeriodicalExecuter = Class.create();    
  140. PeriodicalExecuter.prototype = {    
  141. initialize:  function (callback, frequency) {    
  142. this .callback = callback;    
  143. this .frequency = frequency;    
  144. this .currentlyExecuting =  false ;    
  145. this .registerCallback();    
  146. },    
  147. registerCallback:  function () {    
  148. setInterval( this .onTimerEvent.bind( this ),  this .frequency * 1000);    
  149. },    
  150. onTimerEvent:  function () {    
  151. if  (! this .currentlyExecuting) {    
  152. try  {    
  153. this .currentlyExecuting =  true ;    
  154. this .callback();    
  155. finally  {    
  156. this .currentlyExecuting =  false ;    
  157. }    
  158. }    
  159. }    
  160. }    
  161. /*--------------------------------------------------------------------------*/     
  162. /**   
  163. * 这个函数就 Ruby 了。我觉得它的作用主要有两个   
  164. * 1. 大概是 document.getElementById(id) 的最简化调用。   
  165. * 比如:$("aaa") 将返回 aaa 对象   
  166. * 2. 得到对象数组   
  167. * 比如: $("aaa","bbb") 返回一个包括id为"aaa"和"bbb"两个input控件对象的数组。   
  168. */     
  169. function  $() {    
  170. var  elements =  new  Array();    
  171. for  ( var  i = 0; i < arguments.length; i++) {    
  172. var  element = arguments;    
  173. if  ( typeof  element == 'string')    
  174. element = document.getElementById(element);    
  175. if  (arguments.length == 1)    
  176. return  element;    
  177. elements.push(element);    
  178. }    
  179. return  elements;    
  180. }    
  181. /**   
  182. * 为兼容旧版本的浏览器增加 Array 的 push 方法。   
  183. */     
  184. if  (!Array.prototype.push) {    
  185. Array.prototype.push =  function () {    
  186. var  startLength =  this .length;    
  187. for  ( var  i = 0; i < arguments.length; i++)    
  188. this [startLength + i] = arguments;    
  189. return   this .length;    
  190. }    
  191. }    
  192. /**   
  193. * 为兼容旧版本的浏览器增加 Function 的 apply 方法。   
  194. */     
  195. if  (!Function.prototype.apply) {    
  196. // Based on code from http://www.youngpup.net/    
  197. Function.prototype.apply =  function (object, parameters) {    
  198. var  parameterStrings =  new  Array();    
  199. if  (!object) object = window;    
  200. if  (!parameters) parameters =  new  Array();    
  201.   
  202. for  ( var  i = 0; i < parameters.length; i++)    
  203. parameterStrings = 'parameters[' + i + ']';    
  204.   
  205. object.__apply__ =  this ;    
  206. var  result = eval('object.__apply__(' +    
  207. parameterStrings.join(', ') + ')');    
  208. object.__apply__ =  null ;    
  209.   
  210. return  result;    
  211. }    
  212. }    
  213. /**   
  214. * 扩展 javascript 内置的 String 对象   
  215. */     
  216. String.prototype.extend({    
  217. /**   
  218. * 去掉字符串中的标签   
  219. */     
  220. stripTags:  function () {    
  221. return   this .replace(/</?[^>]+>/gi,  '' );    
  222. },    
  223. /**   
  224. * 这个方法很常见,通常的实现都是用正则表达式替换特殊字符为html规范定义的命名实体或者十进制编码,比如:   
  225. * string.replace(/&/g, "&").replace(//g, ">");   
  226. * 而这里的实现借用浏览器自身的内部替换,确实巧妙。   
  227. */     
  228. escapeHTML:  function () {    
  229. var  div = document.createElement('div');    
  230. var  text = document.createTextNode( this );    
  231. div.appendChild(text);    
  232. return  div.innerHTML;    
  233. },    
  234. /**   
  235. * 同上   
  236. */     
  237. unescapeHTML:  function () {    
  238. var  div = document.createElement('div');    
  239. div.innerHTML =  this .stripTags();    
  240. return  div.childNodes[0].nodeValue;    
  241. }    
  242. });    
  243. /**   
  244. * 定义 Ajax 对象, 静态方法 getTransport 方法返回一个 XMLHttp 对象   
  245. */     
  246. var  Ajax = {    
  247. getTransport:  function () {    
  248. return  Try.these(    
  249. function () { return   new  ActiveXObject('Msxml2.XMLHTTP')},    
  250. function () { return   new  ActiveXObject('Microsoft.XMLHTTP')},    
  251. function () { return   new  XMLHttpRequest()}    
  252. ) ||  false ;    
  253. }    
  254. }    
  255. /**   
  256. * 我以为此时的Ajax对象起到命名空间的作用。   
  257. * Ajax.Base 声明为一个基础对象类型   
  258. * 注意 Ajax.Base 并没有使用 Class.create() 的方式来创建,我想是因为作者并不希望 Ajax.Base 被库使用者实例化。   
  259. * 作者在其他对象类型的声明中,将会继承于它。   
  260. * 就好像 java 中的私有抽象类   
  261. */     
  262. Ajax.Base =  function () {};    
  263. Ajax.Base.prototype = {    
  264. /**   
  265. * extend (见上) 的用法真是让人耳目一新   
  266. * options 首先设置默认属性,然后再 extend 参数对象,那么参数对象中也有同名的属性,那么就覆盖默认属性值。   
  267. * 想想如果我写这样的实现,应该类似如下:   
  268. setOptions: function(options) {   
  269. this.options.methed = options.methed? options.methed : 'post';   
  270. ..........   
  271.  
  272. 我想很多时候,java 限制了 js 的创意。   
  273. */     
  274. setOptions:  function (options) {    
  275. this .options = {    
  276. method: 'post',    
  277. asynchronous:  true ,    
  278. parameters:  ''     
  279. }.extend(options || {});    
  280. },    
  281. /**   
  282. * 如果 xmlhttp 调用返回正确的HTTP状态值,函数返回ture, 反之false。   
  283. * xmlhttp 的 readyState 属性不足以准确判断 xmlhttp 远程调用成功,该方法是readyState判断的一个前提条件   
  284. */     
  285. responseIsSuccess:  function () {    
  286. return   this .transport.status == undefined    
  287. ||  this .transport.status == 0    
  288. || ( this .transport.status >= 200 &&  this .transport.status < 300);    
  289. },    
  290. /**   
  291. * 如果 xmlhttp 调用返回错误的HTTP状态值,函数返回ture, 反之false。   
  292. */     
  293. responseIsFailure:  function () {    
  294. return  ! this .responseIsSuccess();    
  295. }    
  296. }    
  297. /**   
  298. * Ajax.Request 封装 XmlHttp   
  299. */     
  300. Ajax.Request = Class.create();    
  301. /**   
  302. * 定义四种事件(状态), 参考http://msdn.microsoft.com/workshop/...eadystate_1.asp   
  303. */     
  304. Ajax.Request.Events =    
  305. ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];    
  306. /**   
  307. * 相比先前的版本,对于 xmlhttp 的调用和返回值处理分离得更为清晰   
  308. */     
  309. Ajax.Request.prototype = ( new  Ajax.Base()).extend({    
  310. initialize:  function (url, options) {    
  311. this .transport = Ajax.getTransport();    
  312. this .setOptions(options);    
  313. this .request(url);    
  314. },    
  315.   /**   
  316. * 新增加 request 方法封装 xmlhttp 的调用过程。   
  317. */     
  318. request:  function (url) {    
  319. var  parameters =  this .options.parameters ||  '' ;    
  320. if  (parameters.length > 0) parameters += '&_=';    
  321. try  {    
  322. if  ( this .options.method == 'get')    
  323. url += '?' + parameters;    
  324. this .transport.open( this .options.method, url,    
  325. this .options.asynchronous);    
  326. if  ( this .options.asynchronous) {    
  327. this .transport.onreadystatechange =  this .onStateChange.bind( this );    
  328. setTimeout(( function () { this .respondToReadyState(1)}).bind( this ), 10);    
  329. }    
  330. this .setRequestHeaders();    
  331. var  body =  this .options.postBody ?  this .options.postBody : parameters;    
  332. this .transport.send( this .options.method == 'post' ? body :  null );    
  333. catch  (e) {    
  334. }    
  335. },    
  336. /**   
  337. * 新增加的 setRequestHeaders 方法允许添加自定义的http header   
  338. */     
  339. setRequestHeaders:  function () {    
  340. var  requestHeaders =    
  341. ['X-Requested-With', 'XMLHttpRequest',    
  342. 'X-Prototype-Version', Prototype.Version];    
  343. if  ( this .options.method == 'post') {    
  344. requestHeaders.push('Content-type',    
  345. 'application/x-www-form-urlencoded');    
  346. /* Force "Connection: close" for Mozilla browsers to work around   
  347. * a bug where XMLHttpReqeuest sends an incorrect Content-length   
  348. * header. See Mozilla Bugzilla #246651.   
  349. */     
  350. if  ( this .transport.overrideMimeType)    
  351. requestHeaders.push('Connection', 'close');    
  352. }    
  353. /**   
  354. * 其后的 apply 方法的调用有些奇技淫巧的意味   
  355. * 从上下文中我们可以分析出 this.options.requestHeaders 是调用者自定义的http header数组。   
  356. * requestHeaders 也是一个数组,将一个数组中的元素逐个添加到另一个元素中,直接调用   
  357. * requestHeaders.push(this.options.requestHeaders)   
  358. * 是不行的,因为该调用导致 this.options.requestHeaders 整个数组作为一个元素添加到 requestHeaders中。   
  359. * javascript的Array对象还提供一个concat 的方法表面上满足要求,但是concat实际上是创建一个新数组,将两个数组的元素添加到新数组中。   
  360. * 所以,下面的代码也可以替换为   
  361. * requestHeaders = requestHeaders.concat(this.options.requestHeaders);   
  362. * 很显然,作者不喜欢这样的代码方式   
  363. * 而 apply 方法的语法 apply([thisObj[,argArray]]) 本身就要求第二个参数是一个数组或者arguments对象。   
  364. * 所以巧妙的实现了 concat 函数的作用。   
  365. * 令人拍案叫绝啊!   
  366. */     
  367. if  ( this .options.requestHeaders)    
  368. requestHeaders.push.apply(requestHeaders,  this .options.requestHeaders);    
  369. for  ( var  i = 0; i < requestHeaders.length; i += 2)    
  370. this .transport.setRequestHeader(requestHeaders, requestHeaders[i+1]);    
  371. },    
  372. onStateChange:  function () {    
  373. var  readyState =  this .transport.readyState;    
  374. /**   
  375. * 如果不是 Loading 状态,就调用回调函数   
  376. */     
  377. if  (readyState != 1)    
  378. this .respondToReadyState( this .transport.readyState);    
  379. },    
  380. /**   
  381. * 回调函数定义在 this.options 属性中,比如:   
  382. var option = {   
  383. onLoaded : function(req) {...};   
  384. ......   
  385.  
  386. new Ajax.Request(url, option);   
  387. */     
  388. respondToReadyState:  function (readyState) {    
  389. var  event = Ajax.Request.Events[readyState];    
  390. /**   
  391. * 新增的回调函数处理,调用者还可以在options中定义 on200, onSuccess 这样的回调函数   
  392. * 在 readyState 为完成状态的时候调用   
  393. */     
  394. if  (event == 'Complete')    
  395. ( this .options['on' +  this .transport.status]    
  396. ||  this .options['on' + ( this .responseIsSuccess() ? 'Success' : 'Failure')]    
  397. || Prototype.emptyFunction)( this .transport);    
  398. ( this .options['on' + event] || Prototype.emptyFunction)( this .transport);    
  399. /* Avoid memory leak in MSIE: clean up the oncomplete event handler */     
  400. if  (event == 'Complete')    
  401. this .transport.onreadystatechange = Prototype.emptyFunction;    
  402. }    
  403. });    
  404. /**   
  405. * Ajax.Updater 用于绑定一个html元素与 XmlHttp调用的返回值。类似与 buffalo 的 bind。   
  406. * 如果 options 中有 insertion(见后) 对象的话, insertion 能提供更多的插入控制。   
  407. */     
  408. Ajax.Updater = Class.create();    
  409. Ajax.Updater.ScriptFragment = '(?:<script>)((n|.)*?)(?:</script>)';    
  410. Ajax.Updater.prototype.extend(Ajax.Request.prototype).extend({    
  411. initialize:  function (container, url, options) {    
  412. /**   
  413. * containers 就是被绑定的 html 对象,xmlhttp的返回值被赋给该对象的 innerHTML 属性。   
  414. * 相比新版本,containers 根据container参数定义 success 和 failure 引用,如果它们被定义的话,根据xmlhttp调用是否成功来选择   
  415. * 更新对象,假想调用可能如下:   
  416. * var c = {success: $("successDiv"), failure: $("failureDiv")};   
  417. * new Ajax.Updater(c, url, options);   
  418. * 那么调用成功则 successDiv 显示成功信息或者数据,反之 failureDiv 显示错误信息   
  419. */     
  420. this .containers = {    
  421. success: container.success ? $(container.success) : $(container),    
  422. failure: container.failure ? $(container.failure) :    
  423. (container.success ?  null  : $(container))    
  424. }    
  425. this .transport = Ajax.getTransport();    
  426. this .setOptions(options);    
  427. var  onComplete =  this .options.onComplete || Prototype.emptyFunction;    
  428. this .options.onComplete = ( function () {    
  429. this .updateContent();    
  430. onComplete( this .transport);    
  431. }).bind( this );    
  432. this .request(url);    
  433. },    
  434. updateContent:  function () {    
  435. var  receiver =  this .responseIsSuccess() ?    
  436. this .containers.success :  this .containers.failure;    
  437. var  match =  new  RegExp(Ajax.Updater.ScriptFragment, 'img');    
  438. var  response =  this .transport.responseText.replace(match,  '' );    
  439. var  scripts =  this .transport.responseText.match(match);    
  440. if  (receiver) {    
  441. if  ( this .options.insertion) {    
  442. new   this .options.insertion(receiver, response);    
  443. else  {    
  444. receiver.innerHTML = response;    
  445. }    
  446. }    
  447. if  ( this .responseIsSuccess()) {    
  448. if  ( this .onComplete)    
  449. setTimeout(( function () { this .onComplete(    
  450. this .transport)}).bind( this ), 10);    
  451. }   

posted on 2007-09-20 19:36 李云泽 阅读(330) 评论(0)  编辑  收藏 所属分类: Prototype(Ajax)


只有注册用户登录后才能发表评论。


网站导航: