创建对象--构造函数

一、什么是对象：键值对的集合{key:value}

JSON表示法，变量的直接量

var p={

  'name':'alvin',

  'age':19,

  'gender':'boy',

  'sayHello':function(){

    alert('hello world');

}

};

调用json的方法：

方法一：p.sayHello();

方法二：p['sayHello']();//加上引号，访问的是属性，不是变量

//使用json对象的方法有一个缺点：无法复用；优点：方便简洁

二、结果复用问题，采用构造函数

var p=function(){                                                                                 构造函数中不需要return；

   this.name='alvin";//必须要this，表示当前对象                         为对象添加成员时使用：this.成员名=值

  this.age=19;

  this.gender="boy";

  this.sayHello=function(){

   alert("say hello");

   };

};

var p=new Person();

p.sayHello();

var p1=new Person();

console.log(p===p1);//结果：false，重新new出来的构造函数不相同

//这个构造函数缺点：构造出来的内容无法修改，所以要改成带参数

三、带参数的构造函数

1、函数参数调用

function getArea(w,h){

 return w*h/2;

}

//在参数中写变量的好处是：A、相当于声明了变量，B、调用时又一次赋值

var area=getArea(1,2);

alert(area);//结果为1

形参：就是形式参数                                         实参：实际参数

2、形参

var Person=function(newName,newAge,newGender){

  this.name=newName;

 this.age=newAge;

 this.gender=newGender;

 };

var myP=new Person('alvin',24,'boy');

alert(myP);

例子

var Student=function(mathG,chineseG,englishG){

 this.math=mathG;

 this.chinese=chineseG;

 this.english=englishG;

};

var p=new Student(70,80,99);

改良----》方法

var Student=function(myName,myScores){

   this.name=myName;

  this.scores=myScores; 

  this.sayHelo=function(){

   alert(this.name+this,scores.math+this.scores.chinese+this.cores.english);

};

var StudentTwo=new Student('alvin',{math:90,chinese:90,english:70});//Json格式

StudentTwo.sayHelo();

四、构造函数的劣势
function Fn(name){
  this.name=name;
  this.sayHello=function(){
    alert("hello world");
    };
 }
var pp1=new Fn("alvin");
var pp2=new Fn("feng");

1、传统构造函数的劣势

(1)、假定所有成员都占4个字符；（2）、创建一个对象需要8个字符；（3）、创建10个对象就需要80个字符

2、改良后构造函数的优点

（1）、采用prototype原形将同样的方法进行共享；（2）、此时10个对象就只需要44个字符



*****重点********
在函数里有一个属性叫prototype：有该函数创建的对象会默认的连接到该属性上

function Fn(){

 }
Fn.prototype.num=123;//共享的数据，减少占用字符的方法

var f=new Fn();

//f.num=1;     当前对象

alert(f.num);

1、在访问对象的某个属性（方法）的时候，首先会在当前对象中查找有没有该属性；
2、如果当前对象中没有该属性，就会在构造方法的定义规则中查找该对象；
3、如果构造方法中也没有，就会到与对象联系起来的构造函数的prototype属性中找；

例子
function Fn(name){
  this.name=name;
  }
Fn.prototype.sayHello=function(){//对于共同的数据可以用prototype属性放进里面，因为（1）、对象会到与它联系的prototype中找数据，（2）、可以考虑将共享的数据放到里面    
   alert('hello world');
  }
var pp1=new Fn('alvin');//当前对象无论创建多少个都只有一个sayHello副本，减少字符的占用
var pp2=new Fn('feng');

console.log(pp1.sayHello===pp2.sayHello);//结果：true

注意：（1）、pp1.sayHello不能加（）括号，加了（）括号就等于调用sayHello方法，因为sayHello()没有return值，所以结果都是undefine，相等
      （2）、不加（）括号就等于比较两的属性。


五、对象的基本概念
1、对象中有一个  _proto_:通过调用可以发现对象的 _proto_与创建它的构造函数的prototype是同一个东西

function Fn(){}
var p=new Fn();
console.log(p._proto_===Fn.prototype);//结果：true，同一个东西

2、_proto_是非标准属性

3、原型：
   （1）、Fn.prototype 是构造函数Fn的原型属性   （2）、p.prototype  是对象p的原型对象

4、在访问一个对象的属性的时候，首先在当前对象中找，如果没有在其原型对象中找（这个原型对象是创造构造它的函数的prototype属性）；


5、原型对象和原型属性的区别：

  ***凡是函数就有属性prototype：由某一个函数new出来的对象，会自动连接到该函数的Prototype
   举例：
   function Fn1(){}
   function Fn2(){}
   var f1=new Fn(); //f1--》自动连接到Fn1.prototype
   var f2=new Fn();//f2-->自动连接到Fn2.prototype
 

   var o1=new Object();//o1-->Object.prototype
   var f=new Array(3);//f-->Array.prototype
   var d=new Date(0;//d-->Date.prototype;

（1）、连接到prototype有什么用呢？   资源共享

答：属性（属性与方法），属性和方法不加以区分
var p={
 name:"alvin",//属性
 age:19,
 sayHello:function(){},//属性里面有function方法
}；

（2）、在访问一个对象的属性的时候，首先在当前对象中找，如果没有在其原型对象中找（这个原型对象是创造构造它的函数的prototype属性）；
（3）、原型对象：就是对象的构造函数的prototype属性
（4）、原型对象与原型属性   A、原型对象：new出来的对象，是根据对象讨论的  B、站在构造函数的角度；两者指的是同一个东西

（5）、_proto_和prototype有什么区别？
       _proto_是站在对象的角度讨论起原型对象
       prototype是站在构造函数的角度讨论原型属性，或构造函数创建的对象的原型对象




基础：
（1）、isFinite(10/0);结果：false,判断是否为无限的，false就是为有限的，true就是无限的
（2）、判断数字
      var a='123';
      var b='abc';
      console.log(a-0);//123
      console.log(b*1);//NaN
 (3)、判断NaN:
      1、isNaN;
      2、在js中有一个特性，NaN与自己不相等
      console.log(NaN==NaN);//结果为：false

 (4)、setTimeout：多少秒后执行一次
      setInterval:多少秒后执行，间隔该秒数再次执行，直到遇到clearInterval