function Factory(name,age)
{
  var o=new Object();
  o.name=name;
  o.age=age;
  o.what=what;//用函数引用的方式消除重复创建相同函数的弊端，节省资源.函数引用可以修改this的指向，函数调用不可以！
  return o;
}
what=funciton()
{
  alert(this.name+this.age);
}
var o=Factory("12",12);
o.what();//what中的this指向o对象

console.log(o.constructor);
//打印function Object() { [native code] }
console.log(o instanceof Object);
//而且这时候所有的对象都是Object类型的

function Person(name,age)
{
this.name=name;
this.age=age;
this.sayName=function(){ alert(this.name);}//相当于this.sayName=new Function("alert(this.name)")
}
var p1=new Person("xx",12);
var p2=new Person("yy",13);
alert(p1.sayName==p2.sayName)//内存地址不一样!返回false

function Person(name,age)
{
this.name=name;
this.age=age;
this.sayName=sayName;//函数引用的方法，共享了同一个sayName,p1,p2的内存地址一样，p1.sayName==p2.sayName返回true
}
function sayName()
{
alert(this.name);
}

person1.sayName===person2.sayName//两者的引用是一样的

function Person(name,age)
{
 this.name=name;
 this.age=age;
 this.friends=['liangklfang','qinliang'];
}
//用原型定义共性
Person.prototype={
 constructor:Person,
 sayName:function()
 {
  console.log(this.name);
 }
}
var person1=new Person('liangklfang',"12");
var person2=new Person('liangklf',"14");
console.log(person1.sayName===person2.sayName);
//共性是函数，打印true
console.log(person1.friends===person2.friends);
//friends是个性，打印false

function Book(title,page)
{
 this.title=title;
 this.page=page;
 if(typeof Book.isLock=="undefined")
//第一次的时候，Book.isLock是undefined，给原型绑定函数，以后就不需要了，他相比于构造函数原型模式的优点在于把所有的逻辑全部封装到构造函数里面！
  {
   alert("Enter!");
Book.prototype.what=function() 
     {
   alert(this.title+this.pages);
     }
   Book.isLock=true;
 }
}
//下面的两次调用alert("Enter!")只会调用因此i，因为第一次已经通过Book.isLock设置为true了！相当于静态方法！;
var b1=new Book("me",12);
b1.what();
var b2=new Book("he",13);
b2.what();

function Book(title,page)
{
 this.title=title;
 this.page=page;
  if(typeof this.sayName!='function')
  //第二次构造对象的时候会在原型中查找到sayName!
  {
   Book.prototype.sayName=function()
 {
  console.log(this.title);
 }
  }
}

function SpecialArray()
{
  var value=new Array();
  value.push.apply(value,arguments);
  value.toPipedString=function()
  {
    return this.join("|");
}
 return value;
}

function Person(name,age,job)
{
   var o=new Object();
    o.sayName=funciton(){alert(name)}//这里实例方法没有引用this，除了sayName不会有方法访问传入到构造函数中的原始数据！
   return o;
}
var friend=Person("xx",12,"teacher");
friend.name="female";//即使可以为这个对象修改了属性name
friend.sayName();//不会被修改，依然弹出xx。不是female。但是，如果把上面的修改成：o.sayName=function(){alert(this.name)}//那么就会弹出female，也就是friend.name被修改成功了,如果没有this，那么name的值一直引用的是原来的参数值！