首页 > 代码库 > js面向原型话语言总结

js面向原型话语言总结

2024-10-29 04:12:02   210人阅读

一、数组的查找和删除

function WarrperArray(array){

    this.array = array;
 }
//返回下标
 WarrperArray.prototype.existValue = http://www.mamicode.com/function(val){
  for(var j = 0;j<this.array.length;j++){
   if(this.array[j]==val) return j;
  }
  return -1;

 }


//删除指定值得元素

 WarrperArray.prototype.removeValue = http://www.mamicode.com/function(val){
  var index = this.array.indexOf(val);
  if(index>-1){
   this.array.splice(index,1);
   return this.array;
  }
 }

 


二、原型构造函数的总结

 /**
 //js原型对象构造函数，浪费内存、将不变的属性和函数定义在原型上Prototype模式
 function Cat(name,color){
    this.name=name;
    this.color = color;
 }
 //将公用的方法和属性定义在原型上，节约内存的开销
 Cat.prototype.type="TYPE_CAT"
 Cat.prototype.eat = function(){
  alert("eat mouse");
 }
 */

 三、构造函数的继承

 function Animal(){
 this.species = "动物";
 }
 /**
 //构造函数
 function Cat(name,color){
 this.name = name;
 this.color = color;
 }*/
 
 //继承方法一构造函数绑定（子类拥有父类的属性和方法）构造函数是子类的
 function Cat(name,color){
 Animal.apply(this,arguments);
 this.name =name;
 this.color = color;
 }
 //继承方法二 prototype模式
 /**
 Cat.prototype = new Animal();//将父类赋值给子类原型
 Cat.prototype.constructor = Cat;//将构造方法设置为子类
 */
 
 /**利用空对象作为中介
 var F = function(){};
 F.prototype = Animal.prototype;//将父类的原型赋值为空对象
 Cat.prototype = new F();将中介实例赋值给子对象
 Cat.prototype.constructor = Cat;
 */

 

四、利用空对象继承封装成一个方法

 function extend(Child, Parent) {
　　　　var F = function(){};
　　　　F.prototype = Parent.prototype;
　　　　Child.prototype = new F();
　　　　Child.prototype.constructor = Child;
　　　　Child.uber = Parent.prototype;
　　}
/**使用如下
extend(Cat,Animal);

　　var cat1 = new Cat("大毛","黄色");

　　alert(cat1.species); // 动物
*/

/**五、构造函数 拷贝继承*/

function extend2(Child,parent){
var p = parent.prototype;
var c = Child.prototype;
for(var i in p){
c[i] = p[i];
}
c.uber = p;//留出父类的属性
}

/**六、非构造函数的继承*/

var Chinese ={nation:‘中国‘};
var Doctor = {carteer:‘医生‘};
//中国医生  把子对象的原型赋值给父对象让其连接在一起
function object(o){
    function　F(){};
    F.prototype = o;
    return new F();
}

/**
使用如下 在父对象基础上生成子对象

var Doctor = object(Chinese);
然后加上子对象本身的属性
Doctor.career = ‘医生‘;
这时子对象已经继承了父对象属性
alert(Doctor.nation);
*/

/**七、浅复制copy*/

function extendCopy(p){
var c = {};
for(var i in p ){
c[i] = p[i];
}
c.uber = p;
}

/**使用如下*/  
var Doctor = extendCopy(Chinese);
Doctor.career =‘医生‘;
alert(Doctor.nation);

//此复制为浅copy 若属性存在数组和引用，则修改子类的属性，父类的属性也发生变化;
//举例
Chinese.birthPlaces=[‘北京‘,‘上海‘,‘香港‘];
//通过extendCopy()函数Doctor继承Chinese
var Doctor = extendCopy(Chinese);
//然后为Doctor的出生地添加一个城市：
Doctor.birthPlaces.push("河南");
//查看父对象Chinese，发现出生地被修改
alert(Chinese.birthPlaces);//‘北京‘,‘上海‘,‘香港‘,河南
alert(Doctor.birthPlaces);//同上
//所以这种浅拷贝不适用与继承


//深拷贝
function deepCopy(p,c){
 var c = c||{};
 for(var i in p){
    if(typeof(i) ==‘object‘){
    c[i] =(p[i].constructor==Array)?[]:{};
    deepCopy(p[i],c[i]);//递归写法
    }else{
    c[i] = p[i];
    }
 }
}

//使用如下：
var Doctor = deepCopy(Chinese);
//给父对象加一个属性，出生地数组
Chinese.birthPlaces=[‘北京‘,‘上海‘,‘香港‘];
//然后在子对象上修改属性
Doctor.birthPlaces.push("河南");
//查看这两个对象的属性值
alert(Doctor.birthPlaces);//‘北京‘,‘上海‘,‘香港‘,河南
alert(Chinese.birthPlaces);//‘北京‘,‘上海‘,‘香港‘

//目前，jQuery库使用的就是这种继承方法。


//引用数据类型也可以用构造函数返回

//举例如下：
function  clone(obj){
 function F(){};
 F.prototype = obj;
 return new F();
}

var Chinese ={
    nation:‘中国‘,
    createBirthPlaces:function(){
        return [‘北京‘,‘上海‘,‘香港‘];
    }
}
var Doctor = clone(Chinese);
Doctor.career =‘医生‘;
Doctor.birthPlaces=Chinese.createBirthPlaces();
alert(Doctor.birthPlaces.length);//3
Doctor.birthPlaces.push("大连");
alert(Doctor.birthPlaces.length);//4
alert(Chinese.birthPlaces.length);//3

js面向原型话语言总结


联系
我们