欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JavaScript面向对象二

程序员文章站 2022-06-15 18:37:48
...
一、理解篇:

1、每创建的一个函数都有一个prototype属性,该属性是一个对象,prototype默认有一个constructor属性,默认指向prototype对象所在函数的指针;
2、prototype对象中定义的属性和方法是实例化prototype所在函数对象所共享的,当prototype为字面量对象时,其constructor属性将指向Object构造函数;
3、在实例对象中默认有一个内部属性__proto__,该属性指向原型对象,即(构造函数中的prototype属性,实例对象的原型对象)
4、在一个函数被作为构造函数时,我们把在构造函数中定义的属性,方法称为实例属性和方法,把在prototype对象中定义的属性和方法,称为原型属性和方法;

二、属性篇:

isPrototypeOf:   检查某对象是否是另一对象的原型
hasOwnProperty: 检测一个属性是否存在于实例中
in:             只要属性能够被实例所访问,就返回true,无论属性是否存在原型还是实例中
for-in:         通过for循环,返回所有可以枚举的属性(在ie6中存在一个bug,即被打上[[DontEnum]]不可枚举的标签属性不会被返回,而其他浏览器则屏蔽了不可枚举的属性,即也会被返回)

三、模式篇:

1、工厂模式
function obj(arg1,arg2){
	var o = new Object();
	o.arg1 = arg1;
	o.arg2 = arg2;
	o.method = function(){
		console.log(arg1+arg2);
	}
	return o;
}
var obj1 = obj(10,20);
obj1.method();	//30
缺点:对象不识别类型


2、构造函数模式
function Obj(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
	this.method = function(){
		console.log(arg1+arg2);
	}
}
var obj1 = new Obj(10,20);
obj1.method();	//30
缺点:方法不能重用


3、原型模式
function Obj(){}
Obj.prototype = {
	constructor: Obj,
	arg3: ["a","b","c"],
	method: function(){
		console.log(this.arg3.toString());
	}
}
var obj1 = new Obj();
obj1.method();	//a,b,c
var obj2 = new Obj();
obj2.arg3.push("d");
obj1.method();	//a,b,c,d
缺点:原型对象存在引用类型属性时,此属性在实例对象上的修改会影响到另一个实例的共享属性


4、组合使用构造函数模式和原型模式
function Obj(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
	this.arg3 = ["a","b","c"];
}
Obj.prototype = {
	constructor: Obj,
	method: function(){
		console.log(this.arg1+this.arg2);
	}
}
var obj1 = new Obj(10,20);
obj1.method();  //30
var obj2 = new Obj();
obj2.arg3.push("d");
console.log(obj1.arg3.toString());	//a,b,c
优点:在不涉及继承时,此模式为最佳模式


5、动态原型模式
function Obj(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
	if(typeof this.method != "function"){
		Obj.prototype.method = function(){
			console.log(this.arg1+this.arg2);
		}
	}
}
var obj1 = new Obj(10,20);
obj1.method();  //30
缺点:在实例化对象后不能再重写原型,否则会切断现有原型与实例的关系


6、寄生构造函数模式
function Obj(arg1,arg2){
	var o = new Object();
	o.arg1 = arg1;
	o.arg2 = arg2;
	o.method = function(){
		console.log(this.arg1+this.arg2);
	}
	return o;
}
var obj1 = new Obj(10,20);
obj1.method();  //30
缺点:与工厂模式类似,不建议使用该模式


7、稳妥构造函数模式
function Obj(arg1){
	var o = new Object();
	o.method = function(){
		console.log(arg1);
	}
	return o;
}
var obj1 = Obj(10);
obj1.method();	//10
说明:此模式只能通过method方法才能访问arg1变量,即:目的是为了在安全环境中执行


8、原型链
function Super(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
	this.arg3 = ["a","b","c"];
}
Super.prototype = {
	constructor: Super,
	superMethod: function(){
		console.log(this.arg3.toString());
	}	
}
function Sub(){
	
}
Sub.prototype = new Super();
Sub.prototype.constructor = Sub;

var obj1 = new Sub();
obj1.superMethod();  //a,b,c
var obj2 = new Sub();
obj2.arg3.push("d");
obj1.superMethod();  //a,b,c,d
缺点:只要是原型对象中存在引用类型属性,那么就会出现单独使用原型模式遇到的问题


9、借用构造函数
function Super(){
	this.arg3 = ["a","b","c"];
}
function Sub(){
	Super.call(this);
}
var superObj = new Super();
superObj.arg3.push("d");
var obj1 = new Sub();
console.log(obj1.arg3.toString());	//a,b,c
说明:在一个构造函数中调用另一个构造函数,即:在一个作用域中执行另一个作用域中要执行的代码


10、组合继承
function Super(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
	this.arg3 = ["a","b","c"];
}
Super.prototype = {
	constructor: Super,
	superMethod: function(){
		console.log(this.arg3.toString());
	}	
}
function Sub(){
	Super.call(this,10,20);  //在实例化对象时,此句会调用超类构造函数
}
Sub.prototype = new Super();  //第一次调用超类构造函数
var obj1 = new Sub();
obj1.superMethod();	 //a,b,c
var obj2 = new Sub();  //第二次调用超类构造函数
obj2.arg3.push("d");
obj1.superMethod();	 //a,b,c
说明:此模式是继承原型链与借用构造函数模式中的优点,但也有缺点,即:在每次实例化子类对象时,都会调用两次超类构造函数


11、原型式继承
function object(o){
	function F(){}
	F.prototype = o;
	return new F();
}
var o = {
	arg1: 10,
	method: function(){
		console.log(this.arg1);	
	}
}
var obj1 = object(o);
obj1.method();
说明:注意object函数返回的是以对象o为原型对象的实例对象


12、寄生式继承
function object(o){
	function F(){}
	F.prototype = o;
	return new F();
}
var o = {
	arg1: 10,
	method: function(){
		console.log(this.arg1);	
	}
}
function createAnother(original){
	var clone = object(original);
	clone.sayHi = function(){
		alert("hi");	
	}
	return clone;
}
var obj1 = createAnother(o);
obj1.sayHi();	//hi
说明:与原型式继承模式类似,只不过在返回的实例对象上增加了行为


13、寄生组合式继承
function object(o){
	function F(){}
	F.prototype = o;
	return new F();
}
function inheritPrototype(subType,superType){
	var prototype = object(superType.prototype);	//获得以superType.prototype为原型对象的临时对象,因此临时对象拥有这个原型对象的所有属性和方法
	prototype.constructor = subType;				//为prototype这个临时对象初始化constructor属性值
	subType.prototype = prototype;					//将子类的prototype赋值为这个临时对象,因此子类的实例化对象共享这个临时对象(即:也共享超类构造函数中的prototype属性)中的所有属性和方法
}
function Super(arg1,arg2){
	this.arg1 = arg1;
	this.arg2 = arg2;
}
Super.prototype = {
	constructor: Super,
	superMethod: function(){
		console.log(this.arg1+this.arg2);
	}	
}
function Sub(arg1,arg2){
	Super.call(this,arg1,arg2);
}
inheritPrototype(Sub,Super);
var obj1 = new Sub(10,20);
obj1.superMethod();	 //30
console.log(obj1.constructor);	//Sub(arg1,arg2){ xxx }

var superObj = new Super();
console.log(superObj.constructor);	//Super(arg1,arg2){ xxx }
说明:此模式是继承组合式继承和寄生式继承的优点,该模式为最佳模式


14、jQuery核心框架
var $ = Fn = jQuery = function(){
	return new Fn.prototype.init();
}
Fn.prototype = jQuery.prototype = {
	init: function(){
		return this;
	},
	method1: function(){
		console.log("method1");
	},
	method2: function(){
		console.log("method2");
	}
}
Fn.prototype.init.prototype = Fn.prototype;
说明:
    以上代码不是上面任何模式中的一种,也没有涉及到选择器,只是模拟jQuery核心框架代码,该代码中涉及到函数返回值,原型对象以及继承。
    首先,jQuery指定的函数中返回一个实例化对象,这个返回的实例化对象是以jQuery函数中的原型属性中的init方法作为构造函数,init方法返回this,
此this并不会污染上一级作用域,因为它指向的是实例化init构造函数的对象,即jQuery函数中返回的对象;
    将init方法的原型属性赋值为jQuery函数的原型属性,那么jQuery函数的返回对象就会共享jQuery函数的原型属性中的属性和方法。

使用方法:
	var obj = $();
	obj.method1();	//method1

[注:此文章是总结JavaScript高级程序设计第二版中第六章面向对象]

 

转载于:https://www.cnblogs.com/yangjunhua/archive/2012/05/28/2521693.html