Ext原码学习之Ext.js

  1 // JavaScript Document
  2 //定义全局Ext变量
  3 var Ext = Ext ||{};
  4 Ext._startTime = new Date().getTime();
  5 (function(){
  6     var global = this,
  7          objectPrototype = Object.prototype,
  8          toString = objectPrototype.toString,
  9          //是否支持for循环可枚举
 10          enumerables = true,
 11          enumberablesTest = {toString:1},
 12          //定义空函数
 13          emptyFn = function(){},
 14          
 15          //调用被子类覆盖的父方法
 16          callOverrideParent = function(){
 17              //返回方法调用者
 18              var method = callOverrideParent.caller.caller;
 19              
 20              //调用父类方法
 21              return method.$owner.prototype[method.name].apply(this,arguments);
 22          },
 23          i,
 24          nonWhitespaceRe = /\S/,
 25          ExtApp,
 26          iterableRe = /\[object\s*(?:Array|Arguments|\w*Collection|\w*List|Html\s+document\.all\s+class)\]/;
 27         
 28     Function.prototype.$extIsFunciton = true,
 29      Ext.global = global;
 30     
 31     for(i in enumberablesTest)
 32     {
 33         enumberables = null;
 34     }
 35     
 36     if(enumberables)
 37     {
 38         enumberables = [‘hasOwnProperty‘,‘valueOf‘,‘isPrototypeOf‘,‘propertyIsEnumberable‘,‘toLocaleString‘,‘toString‘,‘constructor‘];
 39     }
 40     
 41     Ext.enumberables = enumberables;
 42     
 43     //Ext 潜拷贝
 44     Ext.apply = function(object,config,defaults)
 45     {
 46         if(defaults)
 47         {
 48            Ext.apply(object,defaults);    
 49         }
 50         
 51         if(object && config && typeof config === ‘object‘)
 52         {
 53             var i , j ,k;
 54             for(i in config)
 55             {
 56                 object[i] = config[i];
 57             }
 58             
 59             if(enumberables)
 60             {
 61                 for(j=enumerables.length;j--;)
 62                 {
 63                     k = enumberables[j];
 64                     if(config.hasOwnProperty(k))
 65                     {
 66                         object[k] = config[k];
 67                     }
 68                 }
 69             }
 70         }
 71         
 72         return object;
 73         
 74     }
 75     
 76     //设置css前缀
 77     Ext.buildSettings = Ext.apply({
 78         baseCSSPrefix : ‘x-‘
 79     },Ext.buildSettings ||{});
 80     
 81     //扩展Ext基本属性 name,emptyFn identifyFn,emptyString
 82     Ext.apply(Ext,{
 83         
 84         name:Ext.sandboxName || ‘Ext‘,
 85         
 86         emptyFn:emptyFn,
 87         
 88         identifyFn:function(o){
 89             return o;    
 90         },
 91         
 92         //空字符串
 93         emptyString:new String(),
 94         
 95         baseCssPrefix:Ext.buildSettings.baseCSSPrefix,
 96         
 97         //copy  若目标对象中没有此属性 则从原对象中复制属性
 98         applyIf:function(object,config){
 99             var property;
100             
101             if(object){
102                 for(property in config){
103                     if(object[property] === undefined)
104                     {
105                         object[property] = config[property];    
106                     }
107                 }    
108             }
109             
110             return object;
111         },
112         
113         //test Ext.applyOf
114         //var aaa = {a:123},bbb={a:1,b:12};
115         //console.log(Ext.apply(aaa,bbb));
116         //console.log(Ext.applyIf(aaa,bbb));
117         
118         //遍历 array or object
119         iterate:function(object,fn,scop)
120         {
121             if(Ext.isEmpty(object))
122             {
123                 return;
124             }
125             
126             if(scope === undefined)
127             {
128                 scope = object;
129             }
130             
131             //判断对象是否为Array
132             if(Ext.isIterator(object))
133             {
134                 Ext.Array.each.call(Ext.Array,object,fn,scope);
135             }
136             else
137             {
138                 Ext.Object.each.call(Ext.Object,object,fn,scope);
139             }
140             
141         }
142 
143     });
144     
145 
146     Ext.apply(Ext,{
147         
148         //此方法已被Ext.define 代替
149         extend:(function(){
150             var objectConstructor = objectPrototype.constructor,
151                 inlineOverrides = function(o){
152                     for(var m in o){
153                         if(o.hasOwnProperty(m))
154                         {
155                             this[m]=o[m];
156                         }
157                     } 
158                 };
159                 
160              return function(subclass,supperclass,overrides){
161                 if(Ext.isObject(supperclass))
162                 {
163                     overrides = supperclass;
164                     supperclass = subclass;
165                     subclass = overrides.constructor != objectConstructor ? overrides.constructor:function(){
166                         supperclass.apply(this,arguments);
167                        }
168                 }
169                 if(!supperclass){
170                     Ext.Error.raise({
171                         sourceClass:‘Ext‘,
172                         sourceMethod:‘extend‘,
173                         msg:‘页面未加载完成进行调用‘
174                     });    
175                 }
176                 
177                 var F = function(){},
178                     subclassProto,superclassProto = superclass.prototype;
179                 
180                 F.prototype = supperclassProto;
181                 subclassProto = subclass.prototype=new F();
182                 subclass.supperclass = supperclassProto;
183                 
184                 if(superclassProto.constructor === objectConstructor){
185                     supperclassProto.constructor = supperclass;    
186                 }
187                 
188                 subclass.override = function(overrides){
189                     Ext.override(subclass,overrides);    
190                 };
191                 
192                 
193                 subclassProto.override = inlineOverrides;
194                 
195                 subclassProto.proto = subclassProto;
196                 
197                 subclass.verride(overrides);
198                 
199                 subclass.extend = function(o)
200                 {
201                     return Ext.extend(subclass,o);    
202                 }
203                 
204                 return subclass;
205                 
206              }
207         })(),
208         
209         override:function(target,overrides)
210         {
211             if(target.$isClass)
212             {
213                 target.override(overrides);    
214             }
215             else if(typeof target == ‘function‘)
216             {
217                 Ext.apply(target.prototype,overrides);
218             }
219             else
220             {
221                 var owner = target.self,name,value;
222                 
223                 if(owner  && owner.$isClass)
224                 {
225                     for(name in overrides)
226                     {
227                         if(overrides.hasOwnProperty(name))
228                         {
229                             value = overrides[name];
230                             
231                             if(typeof value == ‘function‘)
232                             {
233                                 if(owner.$className){
234                                     value.displayName = owner.$className +"#"+name;
235                                 }
236                                 value.$name = name;
237                                 
238                                 value.$owner = owner;
239                                 
240                                 value.$previous = target.hasOwnProperty(name)?target[name] : callOverrideParent;
241                             }
242                             target[name] = value;
243                         }
244                     }
245                 }
246                 else
247                 {
248                     Ext.apply(target,overrides);
249                 }
250             }
251             
252             return target;
253         }
254     
255     });
256     
257     //添加静态方法
258     Ext.apply(Ext,{
259     
260         valueForm:function(value,defaultValue,allowBlank)
261         {
262             return Ext.isEmpay(value,allowBlank) ? defaultValue : value;
263         },
264         
265         typeOf:function(value)
266         {
267             var type,typeToString;
268             
269             if(value===null)
270             {
271                 return ‘null‘;
272             }
273             
274             type = typeof value;
275             
276             if(type === ‘undefined‘ || type === ‘string‘ || type === ‘number‘ || type === ‘boolean‘)
277             {
278                 return type;
279             }
280             
281             typeToString = toString.call(value);
282             
283             switch(typeToString)
284             {
285                 case ‘[object Array]‘:
286                     return ‘array‘;
287                 case ‘[object Date]‘:
288                     return ‘date‘;
289                 case ‘[object Bollean]‘:
290                     return ‘boolean‘;
291                 case ‘[object Number]‘:
292                     return ‘number‘;
293                 case ‘[object RegExp]‘:
294                     return ‘regexp‘;
295             }
296             
297             if(type === ‘function‘)
298             {
299                 return ‘function‘;
300             }
301             
302             if(type === ‘object‘)
303             {
304                 if(value.nodeType !== undefined)
305                 {
306                     if(value.nodeType === 3)
307                     {
308                         return (nonWhitespaceRe).test(value.nodeValue)?‘textnode‘:‘whitespace‘;
309                     }
310                     else
311                     {
312                         return ‘element‘;
313                     }
314                 }
315                 
316                 return ‘object‘;
317             }
318         },
319         coerce:function(from,to)
320         {
321             var fromType = Ext.typeOf(from),
322                 toType = Ext.typeOf(to),
323                 isString = typeof from === ‘string‘;
324                 
325             if(fromType !== toType)
326             {
327                 switch(toType)
328                 {
329                     case ‘string‘:
330                         return String(from);
331                     case ‘number‘:
332                         return Number(from);
333                     case ‘boolean‘:
334                         return isString && (!from || from===‘false‘) ? false :Boolean(from);
335                     case ‘null‘:
336                         return isString && (!form || from=== ‘null‘) ? null :from;
337                     case ‘undefined‘:
338                         return isString && (!from || from===‘undefinded‘)?‘undefined‘:from;
339                     case ‘date‘:
340                         return isString && isNaN(from) ? Ext.Date.parse(from,Ext.Date.defaultFormat):Date(Number(from));
341                 }
342             }
343             
344             return from;
345         },
346         //判断字符串是否为空，数组是否有数据
347         isEmpty:function(value,allowEmptyString)
348         {
349             return (value===null) || (value=== undefined) || (!allowEmptyString ? value===‘‘ :false)||(Ext.isArray(value) && value.length===0);
350         },
351         //判断数组
352         isArray:(‘isArray‘ in Array) ? Array.isArray:function(value)
353         {
354             return toString.call(value) === ‘[object Array]‘;
355         },
356         isDate:function(value)
357         {
358             return Ext.typeOf(value) === ‘date‘;
359         },
360         isObject:function(value)
361         {
362             return Ext.typeOf(value)==‘object‘;
363         },
364         isSimpleObject:function(value)
365         {
366             return value instanceof Object && value.constructor === Object;
367         },
368         //判断基本数据类型,
369         isPrimitive:function(value)
370         {
371             var type = typeof value;
372             return type === ‘string‘ || type===‘number‘ || type ===‘boolean‘;
373         },
374         isFunction:function(value)
375         {
376             return !!(value && value.$extIsFunction);
377         },
378         isNumber:function(value)
379         {
380             return typeof value ===‘number‘ && isFinite(value);
381         },
382         isNumberic:function(value)
383         {
384             return !isNaN(parseFlost(value)) && isFinite(value);
385         },
386         isString:function(value)
387         {
388             return Ext.typeOf(value) ===‘string‘;
389         },
390         isBoolean:function(value)
391         {
392             return Ext.typeOf(value) ===‘boolean‘;
393         },
394         isElement:function(value)
395         {
396             return Ext.typeOf(value) === ‘element‘;
397         },
398         isTextNode:function(value)
399         {
400             return Ext.typeOf(value) === ‘textnode‘ || Ext.typeOf(value)===‘whitespace‘
401         },
402         isDefined:function(value)
403         {
404             return Ext.typeOf(value) !== ‘undefined‘;
405         },
406         isIterable:function(value)
407         {
408             if(!value || typeof value.length !== ‘number‘ || typeof value===‘string‘ || value.$extIsFunction)
409             {
410                 return false;
411             }
412             
413             if(!value.propertyIsEnumberable)
414             {
415                 return !!value.item;
416             }
417             
418             if(value.hasOwnProperty(‘length‘) && !value.propertyIsEnumberable(‘length‘))
419             {
420                 return true;
421             }
422             
423             return iterableRe.test(toString.call(value));
424         }
425         
426          //console.log(Ext.isIterable(new Date()));    
427     });
428     
429     
430     Ext.apply(Ext,{
431         clone:function(item)
432         {
433             var type,i,j,k,clone,key;
434             if(item === null || item === undefined)
435             {
436                 return item;
437             }
438             
439             //clone document element
440             if(item.nodeType && item.cloneNode)
441             {
442                 return item.cloneNode(true);
443             }
444             
445             type = Ext.typeOf(item);
446             if(type===‘date‘)
447             {
448                 return new Date(item.getTime());
449             }
450             
451             if(type===‘array‘)
452             {
453                 i = item.length;
454                 clone = [];
455                 while(i--)
456                 {
457                     clone[i] = Ext.clone(item[i]);
458                 }
459                 
460             }
461             else if(type===‘object‘ && item.construcator === Object)
462             {
463                 clone = {};
464                 for(key in item)
465                 {
466                     clone[key] = Ext.clone(item[key]);
467                 }
468                 
469                 if(enumberables)
470                 {
471                     for(j=enumberables.length;j--;)
472                     {
473                         k = enumberables[j];
474                         if(item.hasOwnProperty(k))
475                         {
476                             clone[k]=item[k];
477                         }
478                     }
479                 }
480             }
481             return clone || item;
482             
483         },
484         //生成唯一的命名空间
485         getUniqueGlobalNamespace :function(){
486             var uniqueGlobalNamespace = this.uniqueGlobalNamespace,i;
487             if(uniqueGlobalNamespace === undefined)
488             {
489                 i = 0;
490                 
491                 do{
492                     uniqueGlobalNamespace = ‘ExtBox‘+(++i);
493                 }while(Ext.global[uniqueGlobalNamespace]!==undefined);
494                 
495                 Ext.global[uniqueGlobalNamespace]=Ext;
496                 
497                 this.uniqueGlobalNamespace = uniqueGlobalNamespace;
498             }
499             return uniqueGlobalNamespace;
500         },
501         functionFactoryCache:{},
502         cacheableFunctionFactory:function(){
503             var me = this,args = Array.prototype.slice.call(arguments),
504             cache = me.functionFactoryCache,idx,fn,ln;
505             
506             if(Ext.isSandboxed)
507             {
508                 ln - args.length;
509                 if(ln>0)
510                 {
511                     ln--;
512                     args[ln]=‘var Ext=window.‘+Ext.name+‘;‘+args[ln];
513                 }
514             }
515             idx = args.join(‘‘);
516             fn=cache[idx];
517             
518             if(!fn)
519             {
520                 fn = Function.prototype.constructor.apply(Function.prototype,args);
521                 cache[idx]=fn;
522             }
523             return fn;
524         },
525         functionFactory:function(){
526             var me = this,args = Array.prototype.slice.call(arguments),ln;
527             if(Ext.isSandboxed)
528             {
529                 ln = args.length;
530                 if(ln >0 )
531                 {
532                     ln--;
533                     args[ln] = ‘var Ext = window.‘+Ext.name +‘;‘+args[ln];
534                 }
535             }
536             
537             return Function.prototype.constructor.apply(Function.prototype,args);
538         },
539         Logger:{
540             varbose:emptyFn,
541             log:emptyFn,
542             info:emptyFn,
543             warn:emptyFn,
544             error:function(message)
545             {
546                 throw new Error(message);
547             },
548             deprecate:emptyFn
549             
550         }    
551     });
552     
553     Ext.type = Ext.typeOf;
554     
555     ExtApp = Ext.app;
556     if(!ExtApp)
557     {
558         ExtApp = Ext.app = {};
559     }
560     
561     Ext.apply(ExtApp,{
562         namespaces:{},
563         collectNamespaces:function(paths)
564         {
565             var namespaces = Ext.app.namespaces,path;
566             for(path in paths)
567             {
568                 if(paths.hasOwnProperty(path))
569                 {
570                     namespaces[path] = true;
571                 }
572             }
573         },
574         addNamespaces:function(ns)
575         {
576             var namespaces = Ext.app.namespaces,i,l;
577             if(!Ext.isArray(ns))
578             {
579                 ns = [ns];
580             }
581             
582             for(i =0,l = ns.length;i<l;i++)
583             {
584                 namespaces[ns[i]]=true;
585             }
586         },
587         clearNamespaces:function(){
588             Ext.app.namespaces = {};    
589         },
590         getNamespaces:function(className)
591         {
592             var namespaces = Ext.app.namespaces,deepestPrefix =‘‘,prefix;
593             
594             for(prefix in namespaces)
595             {
596                 if(namespaces.hasOwnProperty(prefix)&&prefix.length>deepestPrefix.length && (prefix+‘.‘ === className.substring(0,prefix.length +1)))
597                 {
598                     deepestPrefix = prefix;
599                 }
600             }
601             
602             return deepestPrefix === ‘‘ ?undefined : deepestPrefix;
603         }
604     });
605       
606 })()
607 
608 Ext.globalEval = Ext.global.execScript ? function(code){
609     execScript(code);    
610 }:function($$code)
611 {
612     (function(){
613         var Ext = this.Ext;
614         eval($$code);
615     })();
616 }
617 
618 //test typeof 
619 //var obj = {};
620 //console.log(typeof obj);
621 
622  
623 
624 
625 
626  
627