JS高级-构造函数、原型、继承、ES5新增方法（数组、字符串、对象）

构造函数和原型

• 对象的三种创建方式

1. 字面量方式
var obj = {};

2. new关键字
var obj = new Object();

3. 构造函数方式
function Person(name,age){
this.name = name;
this.age = age;
}
var obj = new Person('zs',12);

• 静态成员和实例成员

 实例成员 
 实例成员就是构造函数内部通过this添加的成员、实例成员只能通过实例化的对象来访问
 
 静态成员  
 在构造函数本身上添加的成员、静态成员只能通过构造函数来访问

• 构造函数原型prototype
  – 创建的构造函数、但是每次调用都会存在浪费内存的问题这时就出现了prototype

构造函数是什么？构造函数与其他函数唯一的区别在于调用方式不同。任何函数只要通过new来调用就可以作为构造函数，它是用来创建特定类型的对象
每一个构造函数都有一个prototype属性，这个属性就指向原型对象。其实原型对象就只是个普通对象，里面存放着所有实例对象需要共享的属性和方法！所以，我们把需要共享的放到原型对象里，把那些不需要共享的属性和方法存在在构造函数里！

> 每一个构造函数都有一个原型对象 
> 原型就是一个对象 
> 原型的作用就是共享方法

• 对象原型__proto__

对象都会有一个属性 __proto__ 指向构造函数的 prototype 原型对象，之所以我们对象
可以使用构造函数 prototype 原型对象的属性和方法，就是因为对象有 __proto__ 原型
的存在。

• constructor构造函数

对象原型（ __proto__）和构造函数（prototype）原型对象里面都有一个属性 constructor 属性 ，constructor 我们称为构造函数，因为它指回构造函数本身。 constructor 主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来 的构造函数。

如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用 constructor指回原来的构造函数如:

function Star(uname, age) {     
this.uname = uname;     
this.age = age;  }  // 很多情况下,我们需要手动的利用constructor 这个属性指回 原来的构造函数  Star.prototype = {  // 如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用 constructor指回原来的构造函数  
constructor: Star, // 手动设置指回原来的构造函数  
sing: function() {   
console.log('我会唱歌');  
},  
movie: function() {   
console.log('我会演电影');  
} } 
var zxy = new Star('张学友', 19); 
console.log(zxy)

• 原型链
  每一个实例对象又有一个proto属性，指向的构造函数的原型对象，构造函数的原型 对象也是一个对象，也有proto属性，这样一层一层往上找就形成了原型链。
  
• 构造函数实例和原型对象三角关系

1.构造函数的prototype属性指向了构造函数原型对象 
2.实例对象是由构造函数创建的,实例对象的__proto__属性指向了构造函数的原型对象
3.构造函数的原型对象的constructor属性指向了构造函数,实例对象的原型的 constructor属性也指向了构造函数

• 原型链和成员的查找机制
  任何对象都有原型对象,也就是prototype属性,任何原型对象也是一个对象,该对象就 有proto属性,这样一层一层往上找,就形成了一条链,我们称此为原型链;

当访问一个对象的属性（包括方法）时，首先查找这个对象自身有没有该属性。 如果没有就查找它的原型（也就是 __proto__指向的prototype 原型对象）。 如果还没有就查找原型对象的原型（Object的原型对象）。 依此类推一直找到 Object为止（null）。
__proto__对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线

• 原型对象中this指向
  构造函数中的this和原型对象的this,都指向我们new出来的实例对象

function Star(uname, age) {
this.uname = uname;   
this.age = age; }
var that; 
Star.prototype.sing = function() {   
console.log('我会唱歌');    
that = this; } 
var ldh = new Star('刘德华', 18); 
// 1. 在构造函数中,里面this指向的是实例对象
ldh console.log(that === ldh);//true
 // 2.原型对象函数里面的this 指向的是 实例对象 ldh

• 通过原型为数组扩展内置方法

 Array.prototype.sum = function() {
var sum = 0;  
for (var i = 0; i < this.length; i++) {  
sum += this[i]; 
}  
return sum;  
};  //此时数组对象中已经存在sum()方法了  可以始终 数组.sum()进行数据的求和

• 继承
  1、call()可以调用函数
  2、call()可以修改this的指向,使用call()的时候 参数一是修改后的this指向,参数2,参数3… 使用逗号隔开连接

function fn(x, y) {  
console.log(this);   
console.log(x + y); }  
var o = {    name: 'andy'      }; 
fn.call(o, 1, 2);//调用了函数此时的this指向了对象o,

• 子构造函数继承父构造函数中的属性

1. 先定义一个父构造函数
2. 再定义一个子构造函数
3. 子构造函数继承父构造函数的属性(使用call方法)

// 1. 父构造函数 
function Father(uname, age) { 
// this 指向父构造函数的对象实例  
this.uname = uname;    this.age = age;  }   // 2 .子构造函数
function Son(uname, age, score) { 
// this 指向子构造函数的对象实例   3.使用call方式实现子继承父的属性   
Father.call(this, uname, age);   
this.score = score; }
var son = new Son('刘德华', 18, 100); 
console.log(son);

借用原型对象继承方法
1.先定义一个父构造函数
2. 再定义一个子构造函数
3. 子构造函数继承父构造函数的属性(使用call方法)

 
如上代码结果如图:
// 1. 父构造函数 
function Father(uname, age) {   // this 指向父构造函数的对象实例  
this.uname = uname;   
this.age = age;
} 
Father.prototype.money = function() {   
console.log(100000); 
};  
// 2 .子构造函数    
function Son(uname, age, score) {     
// this 指向子构造函数的对象实例    
Father.call(this, uname, age);    
this.score = score;   } 
// Son.prototype = Father.prototype;  这样直接赋值会有问题,如果修改了子原型对 象,父原型对象也会跟着一起变化 
Son.prototype = new Father();   
// 如果利用对象的形式修改了原型对象,别忘了利用constructor 指回原来的构造函数   
Son.prototype.constructor = Son;  
// 这个是子构造函数专门的方法   
Son.prototype.exam = function() {   
  console.log('孩子要考试');
}   
var son = new Son('刘德华', 18, 100);  
 console.log(son)

-ES5新增方法
数组方法forEach遍历数

 arr.forEach(function(value, index, array) {     
//参数一是:数组元素      
//参数二是:数组元素的索引      
//参数三是:当前的数组 
 })   
//相当于数组遍历的 for循环 没有返回值

数组方法filter过滤数

var arr = [12, 66, 4, 88, 3, 7];
var newArr = arr.filter(function(value, index,array) {  
//参数一是:数组元素       
//参数二是:数组元素的索引    
//参数三是:当前的数组    
return value >= 20;  
});  
console.log(newArr);//[66,88] //返回值是一个新数组

数组方法some

some 查找数组中是否有满足条件的元素   
var arr = [10, 30, 4]; 
var flag = arr.some(function(value,index,array) {
//参数一是:数组元素      
//参数二是:数组元素的索引      
//参数三是:当前的数组      
return value < 3;   }); 
console.log(flag);//false返回值是布尔值,只要查找到满足条件的一个元素就立马终止循环

some和forEach区别

- 如果查询数组中唯一的元素, 用some方法更合适,在some 里面 遇到 return true 就 是终止遍历 迭代效率更高 
- 在forEach 里面 return 不会终止迭代  

trim方法去除字符串两端的空格

var str = '   hello   ' 
console.log(str.trim()） 
 //hello 去除两端空格 
 var str1 = '   he l l o   ' 
 console.log(str.trim()）  //he l l o  去除两端空

获取对象的属性名
Object.keys(对象) 获取到当前对象中的属性名 ，返回值是一个数组

var obj = {      id: 1,   
pname: '小米',      
price: 1999,     
num: 2000 
};
var result = Object.keys(obj) 
console.log(result)//[id，pname,price,num]

Object.defineProperty
Object.defineProperty设置或修改对象中的属性

Object.defineProperty(对象，修改或新增的属性名，{
value:修改或新增的属性的值,       
writable:true/false,//如果值为false 不允许修改这个属性值      
enumerable: false,//enumerable 如果值为false 则不允许遍历                  
configurable: false  //configurable 如果为false 则不允许删除这个属性  属性是否可以被删除或是否可以再次修改特性 })