单信js——2原型（重点）

###面向对象 编程语言中，分为“面向过程”和“面向对象”两大类。面向过程就如自己造一台电脑，面向对象则是用现有的配件组装电脑。 在面向对象中就有两个重要的概念：类型（class）和对象实例（object） 一个类，通常具有两大特征：属性 和 方法。 属性：是指一个类型具有的共同“特征”。如人有2个眼睛，汽车有4个轮子等。 值是各种基本类型，引用类型 方法：是指一个类型具有的共同“行为”。如人能说话，狗能吃骨头等。 值是一个函数 如果想创建属于自己的对象，那么首先要体验分析。分析身边2件事物，抽取出他的属性和方法。 JavaScript的所有类型，都源于一个Object，也就是我们常说的万物皆对象。

JS提供了非常多内置的类： Number（数字类）、String（字符串类）、Date（日期类）、Math（数学类）、Array（数组类）、Function（函数类）、Object（对象类） new关键字: 使用new关键词可以将一个类进行实例化，根据类的特征和行为制作一个具体实例。 //可以使用new关键词用函数类实例化一个函数 : new Function('参数','函数体'); var show=new Function('a','alert(a);') show(10); console.log(show instanceof Function);

#####自定义类： 1.字面量对象 var obj2={name:'李白',age:999};

2. 工厂模式 就是设计中的工厂模式，给定一些值，创造一个结果

3. 构造函数/类 //ES5 【掌握】 function Person(参数){ this.属性=参数值; this.方法=function(){ //方法体 } } //使用构造函数实例化一个对象 var p1=new Person('小强',19);

类/构造函数的特征： 1) 构造函数的函数名（类名）首字母大写 2) 属性和方法都挂在this上 3) 没有return 语句

new关键字的实现机制： 1) 创建一个新对象 2) 将构造函数中的this指向新对象 3) 执行构造函数中的语句，将所有属性都挂到新对象（this指向新对象）

为每一个对象都创建一个单独的方法，就会占用过多的内容，就叫做过载。解决的办法是，在原型对象prototype上添加方法，给每个实例对象使用。

####原型prototype：

1. 什么是原型？ 原型就是 prototype属性，所有function定义的函数都拥有这个属性。 prototype属性是一个对象，可以添加属性和方法

2. 原型有什么用？

   1. 解决方法过载的问题
   2. 扩展类的功能

3. 原型的写法 //定义原型方法 类名.prototype.属性名或方法名=值;

   //使用原型方法 对象.方法名(); function Person(name,age){ this.name=name; this.age=age; }

//将所有的方法都放在原型上
Person.prototype.run=function(){
	console.log(this.name + '以每小时80公里的速度奔跑...');
};
Person.prototype.eat=function(){
	console.log(this.name+'吃了一惊！！');
};
//为Person添加一个新功能——学习方法
Person.prototype.study=function(){
	console.log(this.name+'正在努力学习！！！');
}
var p1=new Person('刘备',18);
var p2=new Person('张飞',16);
console.log(p1.run === p2.run);   //true
console.log(p1);    //刘备的对象
p1.study();   //刘备正在努力学习！！！

var Car = function (band,price) {
            this.band=band;
            this.price=price
        }
        var bens=new Car("meisai",56);
        console.log(bens);
        console.log(typeof bens);
        console.log(bens instanceof Car);        //true
        console.log(bens instanceof Object);     //true
        console.log(bens instanceof Function);   //false
        console.log(Car instanceof Object);      //true
        console.log(Car instanceof Function);    //true
        //此时，如果Car的原型上添加东西，即可扩展到bens上
        Car.prototype.color="white";
        console.log(bens.color);//父亲的属性或方法，都可以被儿子继承
        console.log(bens.constructor==Car);      //true
        console.log(bens.constructor==Car.prototype.constructor);   //true

        console.log(Car.prototype.color);    //white

####扩展内置类

扩展String类，编写方法实现获取字符串的第一个字
var str="我们在上课，好海哦~~~";			
//对字符串类进行扩展（编写插件）
var str="我们在上课，好海哦~~~";
//对字符串类进行扩展（编写插件）
String.prototype.findFirst=function(){
	return this.substr(0,1);
}
console.log( str.findFirst() );
console.dir(String); //查看对象的结构

扩展Array类型，提供inArray方法用来检查数组中是否包含”张三”
Array.prototype.inArray=function(name){
//找到数组 this
for(var i=0;i<this.length;i++){
	if(this[i] === name){
		return true;
	}
}
//将数据遍历完还找不到，就返回false
return false;
}
var arr=['刘备','张飞','张三','关羽'];
console.log( arr.inArray('张三') );  //true

对象属性的优先级： 对象 > 构造函数 > 原型 > 原型链（父类原型）

####神秘的__proto__： __proto__实际上是对类的prototype属性进行引用！！！

__proto__出现在【对象】上， prototype出现在【类/构造函数】上， 对象上的__proto_实际上是对类的prototype进行引用（内存地址都一样）

常见属性：constructor	在原型上声明构造函数
function User(username,password){
this.username=username;
this.password=password;
}
User.prototype.login=function(){
console.log(this.username+'登陆了系统');
}
var u1=new User('曹操','123456');
console.log(u1.__proto__ === User.prototype); //true
console.dir(u1);

下面是前两天的复习：

1. 变量高级

   1. 按数据类型进行划分，将变量划分为： Number String Boolean Undefined NULL Array Function Object

   2. 按数据在内存中的存储位置划分： 基本类型（简单类型）： 存储在内存的栈里面，在赋值时直接将变量的值复制一份给另外一个变量，两个变量相互不影响。 包含： Number String Boolean Undefined NULL

      引用类型（复杂类型）： 存储在内存堆里面，在赋值时将变量指向的内存地址（指针）赋值给另外一个变量，两个变量指向同一个内存空间，相互会影响 包含：Array Function Object

   3. 检测变量 typeof 检测变量自身的类型 instanceof 检测变量属性哪种类型

2. 函数进阶

   1. 函数的内置对象 arguments a. 什么是arguments arguments是函数的内置对象，只能在函数内部使用，不能在外部使用。 是一个对象，表现起来像一个数组，就是伪数组。

      b. arguments的作用 获取函数的所有实际参数 调用到函数本身（开发测试时使用）

      c. 写法 function show(){ console.log(arguments); //arguments[0] //注意：遍历arguments不能用for in，使用传统的for循环 }

3. 面向对象 面向过程POP： 关注每一个过程和细节 面向对象OOP： 关注结果，找一个具备相关能力的对象，使用这个能力实现目标 $('div').html('Hello world')

   类（class）：类是一个抽象化的概念， 将一类事物共有的特征进行抽取，得到类（对一类事物进行描述） 对象（object）：对象是一个具体的实例，可以将类进行实例化产生一个对象，对象具备类上面描述的所有特征

4. 构造函数/类

   1. 创建类/构造函数 function Person(name,age){ //定义成员属性 => 特征 => 普通变量 this.name=name; this.age=age; //定义成员方法 => 行为 => 函数 this.showName=function(){ } }

   2. 使用构造函数 var p1=new Person('张三',1);

   3. 构造函数的特征 a. 类名就是构造函数名 首字母必须大写 b. 所有属性和方法都挂载到this上 c. 没有返回值 return

5. 原型prototype

   1. 什么是原型？ 原型就是prototype属性， 所以的函数都拥有这个属性， prototype属性是一个对象，可以添加属性和方法，称为原型属性和原型方法， prototype属性会被实例化出来的对象所引用

   2. 原型的作用 a. 解析方法过载的问题 b. 对已有的类进行扩展（内置类、自定义类）

   3. 原型的写法 function Person(name,age){ this.name=name; this.age=age; }

      //将所有类的方法都定义在原型上 Person.prototype.showName=function(){ //... }