사용자 도구

사이트 도구


javascript:objectoriented

차이

문서의 선택한 두 판 사이의 차이를 보여줍니다.

차이 보기로 링크

양쪽 이전 판 이전 판
javascript:objectoriented [2012/03/16 15:37]
kwon37xi
javascript:objectoriented [2012/03/16 15:38] (현재)
kwon37xi
줄 150: 줄 150:
 // Inspired by base2 and Prototype // Inspired by base2 and Prototype
 (function () { (function () {
- "use strict";​+    ​"use strict";​
  
- var initializing = false, fnTest = /​xyz/​.test(function () { +    ​var initializing = false, fnTest = /​xyz/​.test(function () { 
- xyz; +        xyz; 
- }) ? /​\b_super\b/​ : /.*/;+    }) ? /​\b_super\b/​ : /.*/;
  
- // The base Class implementation (does nothing) +    ​// The base Class implementation (does nothing) 
- window.Class = function () { // edited for use strict +    window.Class = function () { // edited for use strict 
- };+    };
  
- // Create a new Class that inherits from this class +    ​// Create a new Class that inherits from this class 
- Class.extend = function (prop) { +    Class.extend = function (prop) { 
- var _super = this.prototype;​ +        var _super = this.prototype;​ 
- // Instantiate a base class (but only create the instance, +        // Instantiate a base class (but only create the instance, 
- // don't run the init constructor) +        // don't run the init constructor) 
- initializing = true; +        initializing = true; 
- var prototype = new this(); +        var prototype = new this(); 
- initializing = false;+        initializing = false;
  
- var name;+        ​var name;
  
- // Copy the properties over onto the new prototype +        ​// Copy the properties over onto the new prototype 
- for (name in prop) { +        for (name in prop) { 
- // Check if we're overwriting an existing function +            // Check if we're overwriting an existing function 
- prototype[name] = typeof prop[name] === "​function"​ && typeof _super[name] === "​function"​ +            prototype[name] = typeof prop[name] === "​function"​ && typeof _super[name] === "​function"​ 
- && fnTest.test(prop[name]) ? (function (name, fn) { +                            && fnTest.test(prop[name]) ? (function (name, fn) { 
- return function () { +                    return function () { 
- var tmp = this._super;​+                        var tmp = this._super;​
  
- // Add a new ._super() method that is the same method +                        ​// Add a new ._super() method that is the same method 
- // but on the super-class +                        // but on the super-class 
- this._super = _super[name];​+                        this._super = _super[name];​
  
- // The method only need to be bound temporarily,​ so we +                        ​// The method only need to be bound temporarily,​ so we 
- // remove it when we're done executing +                        // remove it when we're done executing 
- var ret = fn.apply(this,​ arguments);​ +                        var ret = fn.apply(this,​ arguments);​ 
- this._super = tmp;+                        this._super = tmp;
  
- return ret; +                        ​return ret; 
- }; +                    }; 
- }(name, prop[name])) : prop[name];​ +            }(name, prop[name])) : prop[name];​ 
- }+        }
  
- // The dummy class constructor +        ​// The dummy class constructor 
- function Class() { +        function Class() { 
- // All construction is actually done in the init method +            // All construction is actually done in the init method 
- if (!initializing && this.init) +            if (!initializing && this.init) 
- this.init.apply(this,​ arguments);​ +                this.init.apply(this,​ arguments);​ 
- }+        }
  
- // Populate our constructed prototype object +        ​// Populate our constructed prototype object 
- Class.prototype = prototype;+        Class.prototype = prototype;
  
- // Enforce the constructor to be what we expect +        ​// Enforce the constructor to be what we expect 
- Class.prototype.constructor = Class;+        Class.prototype.constructor = Class;
  
- // And make this class extendable +        ​// And make this class extendable 
- Class.extend = window.Class.extend;​ // edited for use strict+        Class.extend = window.Class.extend;​ // edited for use strict
  
- return Class; +        ​return Class; 
- };+    };
 }()); }());
 </​code>​ </​code>​
javascript/objectoriented.txt · 마지막으로 수정됨: 2012/03/16 15:38 저자 kwon37xi