JavaScript prototype(原型)

//原型 prototype
创建每一个函数都有一个prototype,这个属性其实是一个指针，这个指针总是指向一个对象
这个对象的用途就是将特定的属性和方法包含在内，起到一个所有实例共享的作用。
//构造函数方式
--1.
function Person(name, age){
	this.name = name;
	this.age = age;
	this.sayName = function(){alert('我是姓名!')};
}	
	var p1 = new Person('z1',20);
	var p2 = new Person('z3',20);
	alert(p1.sayName == p2.sayName); //false 每次实例化的对象不同
	alert(p1.name == p2.name); //false 
	


--2.
function Person(name, age){
	this.name = name;
	this.age = age;
	this.sayName = sayName;
}	
function sayName(){
	alert(this.name);
}
p1.sayName = sayName;
p2.sayName = sayName;

var p1 = new Person('z1',20);
var p2 = new Person('z3',20);
alert(p1.sayName == p2.sayName); //true 实例化的内容相同


--3.
function Person(){}
var obj = Person.prototype;
obj.name = 'z3';
obj.age  = 20;
obj.sayName = function(){alert(this.name)};
var p1 = new Person();
var p2 = new Person();
alert(p1.age);
alert(p2.age);
alert(p1.sayName == p2.sayName);//true
var obj1 = p1.prototype;
/*
每次代码读取一个对象的属性的时候，优先使用实例对象里name的属性，若没有则取原型里面的属性。
*/
p2.name = 'w5';
alert(p2.name); //w5
//删除实例的属性(原型的属性使用delete无法删除)
delete p2.name;
//显示实例原型的名称
alert(p2.name); //z3


//关于原型的常见方法

//obj.isPrototypeOf(Object) 用于检查传入的对象的原型是否是obj
alert(obj.isPrototypeOf(p1)); //true

//Object.getPrototypeOf() 根据实例对象获取原型对象
var prototypeObj = Object.getPrototypeOf(p1);
alert(prototypeObj == Person.prototype); //true

//obj.hasOwnProperty() 判断一个属性是否是属于实例的属性还是原型的属性
var p3 = new Person();
alert(p3.name);
alert(p3.hasOwnProperty('name'));//false,非当前实例的属性


//in 判断一个属性是否存在实例的属性或者原型的对象中
var p4 = new Person();
p4.name = 'z6';
alert('name' in p4); //true
var p2 = new Person();
alert('name' in p2); //true



//手工创建方法, 判断一个属性是否是原型中的属性	
function isPrototypeProperty(name){
	var obj = this;
	alert(!obj.hasOwnProperty(name) && name in obj);
}
var p1 = new Person();
isPrototypeProperty.call(p1,'name'); //true

//ECMA5新特性 Object.keys
//获取当前对象所有keys, 返回一个数组
var p1 = new Person();
p1.name = 'z3';
p1.age = 20;
var attributes = Object.keys(p1);
alert(attributes.length); //2
alert(attributes); //name,age

//枚举对象所有的属性,不管内部属性能否被枚举,比如构造函数
//构造函数方式
function Person(){}
var obj = Person.prototype;
obj.name = 'z3';
obj.age  = 20;
obj.sayName = function(){alert(this.name)};

var atr = Object.getOwnPropertyNames(Person.prototype);/
alert(atr); //constructor,name,age,sayName
-------------------------------------------------------------------------------------------------

原型的另外一个作用就是扩展对象中的属性和方法

利用JS实现数组中每个元素的遍历

var arr = [1,2,3,[4,[5,6]]];
Array.prototype.each = function(fn){
	var obj = this;
	try{
		//1.遍历每一个元素
		obj.i || (obj.i=0); //需要用括号括起来
		//2.判断this对象是数组且数组的大小大于0
		if(this.length>0 && fn.constructor == Function){
			while(obj.i < obj.length){ //while循环的位置
				// 获取数组的每一项
				var element = obj[obj.i];
				// 如果当前元素获取到 并且当前元素是一个数组
				if(element && element.constructor == Array){
					element.each(fn);
				}else{
					fn.call(null,element);//等同于fn(element)
				}
				obj.i++;
			}
			obj.i=null; //释放内存(delete this.i)
		}
	}catch(ex){
		//do something
	}
	return this;
}
arr.each(function(item){
	alert(item);
});



在javascript中，“&&”运算符运算法则如下：
数据类型 转换为bool后的值
null		FALSE
undefined	FALSE
Object		TRUE
function	TRUE
0			FALSE
1			TRUE
0、1之外的数字 TRUE
字符串		TRUE
""(空字符串) FALSE

如果&&左侧表达式的值为真值，则返回右侧表达式的值；否则返回左侧表达式的值。 
这就是说
var i=""&&"真值";//->i=""
i="真值"&&"其他真值";//->i="其他真值"
i="真值"&&"";//->i=""


“||”运算符的运算法则如下： 

如果||左侧表达式的值为真值，则返回左侧表达式的值；否则返回右侧表达式的值。 
这就是说：
var i=""||"真值";//->i="真值"
i="真值"||"其他真值";//->i="真值"
i="真值"||"";//->i="真值"