走进javascript(五)

面向对象

创建对象

对象封装

(function($){
	
	/**
	 * @param {Object} config
	 */
	function Log(config) {
		return new Log.fn.init( config );
	}
	
	/**
	 * 将Log.fn 指向Log.prototype
	 */
	Log.fn = Log.prototype = {
		constructor: Log,
		defaultconfig : {
			uid :　_randomUid()
		},
		init: function(config) {
			_init(this, config);
		},
		err: function(msg) {
			console.info(this.config.uid + ': msg' + "： " + this.config.name);
		}, 
		info: function() {
			console.info(this.config);
		}
	}
	
	/**
	 * 使init方法的构造函数指向Log的构造函数
	 */
	Log.fn.init.prototype = Log.fn;
	
	/**
	 * 生成一个随机数
	 */
	function _randomUid() {
		return Math.random();
	}
	
	/**
	 * 初始化配置
	 */
	function _init(_target, config) {
		_target.config = $.extend({}, _target.defaultconfig, config);
	}
	
})(jQuery);

继承

通过原型链实现继承

通过原型指向一个对象来实现继承
但会存在一个问题，当子对象修改父对象里的数据的时候
子对象所有所有都会有影响

function SuperType () {
}

SuperType.prototype = {
	info: function(){
		console.info('very good');
	},
	config: {
	}
};

function SubType(){
}

SubType.prototype = new SuperType();

var ins = new SubType();
ins.info();

使用字面量添加方法，会导致原型初定义失效
SubType.prototype = new SuperType();

SubType.prototype= {
	someOtherMethod: function(){...}
};

借用构造函数来实现继承
在子类型的构造函数内部调用超类的构造函数

function SuperType(){ this.colors = {"red", "blue"}}

function SubType() {
	SuperType.call(this);
}

var ins = new SubType();
ins.colors.push('black');

缺点：
借用的构造函数原型链中的函数在子类下不可见

组合继承
通过将原型链和借用构造函数组合使用

function SuperType() {
	this.colors = ['red'];
}

SuperType.prototype.info = function () {
	console.info('info func');
}

function SubType() {
	SuperType.call(this);
}

SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;

原型式继承
通过一个已知的对象创建另一个对象的方式来实现继承

function SubType(o) {
	function Temp() {}
	Temp.prototype = o;
	new Temp();
}

Ecmascript Object.create() 方法规范化了原型式继承