实践

  1. // 用new建立一个简单的对象
  2. /*
  3. var t = new Object();
  4. t.a = "test";
  5. t.b = function (){
  6.     alert(t.a);
  7. }
  8. t.b();
  10. // 用new和this关键字改进
  11. var t = new Object();
  12. t.a = "test";
  13. t.b = function(){
  14.     alert(this.a);
  15. }
  16. t.b();
  19. // 改进
  20. function test(){
  21.     this.a = "test";
  22.     this.b = function(){
  23.         alert(this.a);
  24.     }
  25.     return 1;
  26. }
  27. var t = test(); 
  28. alert(a);
  29. b();
  30. alert(t);
  31. alert(t.a);
  32. t.b;
  33. // 直接调用函数时，t只是函数的返回值，并不是需要的对象。
  34. //   由于test是window对象调用的，this指代了window对象，把a和b赋给了window对象。
  38. function test(){
  39.     this.a = "tetst";
  40.     this.b = function(){
  41.         alert(this.a);
  42.     }
  43.     return 1;
  44. }
  45. var t = new test();
  46. alert(t); 
  47. alert(t.a);
  48. t.b();
  49. alert(a);
  50. b();
  51. // 用new运算符时，调用test函数的对象被赋给了t，
  52. // this指代t对象，函数返回值被忽略。a和b()在window上未定义。
  56. function test(){
  57.     var t = new Object();
  58.     t.a = "test";
  59.     t.b = function(){
  60.         alert(this.a);
  61.     }
  62.     return t;
  63. }
  65. var t1 = test();
  66. alert(t1);
  67. alert(t1.a);
  68. t1.b();
  70. var t2 = test();
  71. t2.a = "test2";
  72. t2.b;
  73. alert(Object.a);
  74. Object.b();
  76. // 在函数内部new操作符新建了基本对象并返回，
  77. // 两个test实例不互相影响，也不影响Object对象。
  81. var test_b = function (){
  82.     alert(this.a)
  83. };
  84. function test(){
  85.     var t = new Object;
  86.     t.a = "test";
  87.     t.b = test_b;
  88.     return t;
  89. }
  91. var t1 = test();
  92. t1.b();
  93. var t2 = test();
  94. t2.a = "test2";
  95. t2.b(); 
  97. // 上面两个例子的弊端是，b方法其实是只是一个函数指针，
  98. // 两个指针所指向的函数在调用构造函数时即时创建，并非
  99. // 同一个程序实例，造成存储空间浪费。
  100. // 本段代码为改进程序，这样两个实例的b属性为同一个test_b指针，都指向同一个函数。
  104. function test(){
  105.     this.a = "test";
  106. }
  107. test.prototype.b = function(){
  108.     alert(this.a);
  109. }
  110. test.prototype.c = new Array();
  111. test.prototype.d = 5;
  112. var t1 = new test();
  113. t1.b();
  114. var t2 = new test();
  115. t2.a = "test2";
  116. t2.b();
  117. ///////
  118. t1.c = [1,2];
  119. alert(t1.c);
  120. t2.c[1] = 4;
  121. alert(t2.c);
  122. alert(t1.c);
  123. ///////
  124. t2.d =6;
  125. alert(t2.d);
  126. alert(t1.d);
  127. // 当prototype的属性为对象的引用时，它为指向对象的指针，和普通变量一样被每个实例继承。
  128. // 另外，prototype属性在对象被实例化前创建。也不可以放在函数内，因为那样每次实例化对象时，
  129. // 都会为prototype的属性重新赋值，那样仍然没达到目的。
  133. // 继承
  134. function test(){
  135.     this.a = "test";
  136.     this.b = function(){
  137.         alert(this.a);
  138.     }
  139. }
  141. function subTest(){
  142.     this.peraP = test;
  143.     this.peraP();
  144.     this.subName = "subTest";
  145. }
  146. var t1 = new test();
  147. t1.b();
  148. var t2 = new subTest();
  149. t2.b();
  150. alert(t2.subName);
  152. // 在子类的构造函数内，用this调用父类构造函数，实现了继承。
  154. */
  156. function test(){
  157.     this.a = "test";
  158. }
  159. test.prototype.b = function(){
  160.     alert(this.a);
  161. }
  162. function subTest(){
  163.     this.subName = "subTest";
  164. }
  165. subTest.prototype = new test;
  166. subTest.prototype.showName = function(){
  167.     alert(this.subName);
  168. }
  170. var t1 = new test();
  171. t1.b();
  172. var t2 = new subTest();
  173. t2.b();
  174. t2.showName();
  176. // 当父类的构造函数不需要传递参数时，可以用
  177. // subClass.prototype = new ParentClass;的方式覆盖子类的prototype原型，
  178. // 子类的新原型属性放在后面添加。
  180. //-----------------
  181. // prototype 属性
  182. // 返回对象类型原型的引用
  183. // objectName.prototype
  184. // objectName 参数是对象的名称。
  186. // 用prototype属性提供对象的类的一组基本功能。
  187. // 对象的新实例“继承”赋予该对象原型的操作。
  188. // 所有的js内部对象都有prototype属性。