一、构造函数和原型
1.静态成员和实例成员（成员就是属性和方法）
（1）实例成员就是构造函数内部通过this添加的成员 。实例成员只能通过实例化的对象来访问
（2）静态成员 在构造函数本身上添加的成员 。静态成员只能通过构造函数来访问
function Star(uname, age) {
this.uname = uname; //实例成员
this.age = age; //实例成员
this.sing = function() { //实例成员
console.log('我会唱歌');
}
}
Star.sex = '男'; //静态成员
var ldh = new Star('刘德华', 18);
console.log(Star.sex);//静态成员只能通过构造函数来访问
2.构造函数原型prototype
（1）每一个构造函数都有一个prototype 属性，prototype是一个对象。
（2）一般情况下，我们把构造函数的公共方法放到原型对象prototype里面，实现方法共享。
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
// 构造函数的公共方法写到原型对象里面
Star.prototype.sing = function (song) {
console.log(this.uname + '会唱' + song);
};
var WuLei = new Star('吴磊',22);
WuLei.sing('苦乐年华');
3._proto_对象原型
（1）每个实例对象中都有一个_proto_属性，它指向构造函数中的原型对象prototype。
（2）_proto_对象原型和原型对象 prototype 是等价的。也是对象
（3）实例对象调用方法时，先去查找本身是否有该方法；再去prototype原型对象中查找。
4.constructor属性
（1）对象原型（ __ proto__）和构造函数的原型对象（prototype）里面都有一个属性 constructor 属性 ，constructor 我们称为构造函数，它指回构造函数本身。
（2）如果给prototype原型对象赋值为一个对象类型的数据,会覆盖原本的对象，则必须手动地把constructor指回原来的构造函数。
function Star(uname, age) {
this.uname = uname;
this.age = age;
}
// 对象原型（ __proto__）和构造函数的原型对象（prototype）里面都有一个属
// 性 constructor 属性 ，constructor 我们称为构造函数，因为它指回构造函数本身。
Star.prototype = {
constructor: Star, //在原型对象中手动将constructor属性指向构造函数
sing: function () {
console.log('我会唱歌');
},
film: function () {
console.log('我会演电影');
},
};
var star = new Star('吴磊', 22);
5.实例对象原型（ _proto_）、构造函数（prototype）原型对象、constructor属性
（1）构造函数通过prototype指向子属性原型对象prototype。
（2）原型对象prototype通过子属性constructor指向构造函数。
（3）实例对象通过_proto_对象原型与构造函数的原型对象prototype等价。
6.原型链
构造函数（prototype）原型对象也是一个对象，也有对象原型（_proto_），它指向Object的原型对象(prototype)。
7.实例对象调用属性和方法时的查找机制
（1）首先查找这个对象自身有没有该属性。
（2）如果没有就查找它的原型对象 （也就是 __ proto__指向的 prototype 原型对象）。
（3）如果还没有，就查找原型对象的对象原型（指向的是Object的原型对象）。
（4）_proto_对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线。
8.this指向
构造函数中的this和原型对象的this,都指向我们new出来的实例对象。
9.利用prototype原型对象扩展内置对象方法
（1）构造函数.prototype.新方法( ) = function( ){ }
这是给原型对象追加新方法。
（2）构造函数.prototype = { 新方法1 ： function( ) { } ，新方法2 ： function( ) { } }
这种形式会覆盖原型对象prototype原本的内容。禁止用这种形式扩展内置对象方法。
// 为数组添加自定义方法
Array.prototype.sum = function () {
var sum = 0;
for (var i = 0; i < this.length; i++) {
sum += this[i];
}
return sum;
};
//实例化数组对象
var arr = new Array(11,22,33);
console.log(arr.sum());
});
10.call( )方法
方法名.call (this的指向, 参数1，参数2）
call( )方法可以调用函数；改变函数的this指向。
function fn(x, y) {
console.log(x + y);
console.log(this);
}
var o = {};
fn.call(o,1,2);//调用函数，并将fn函数的this指向改为对象o
11.子构造函数继承父构造函数
核心：（1）在子构造函数里调用父构造函数；把父构造函数的this指向修改为子构造函数。
（2）把父构造函数的实例化对象赋值给子原型对象。
（3）用对象赋值的方法会覆盖子原型对象的内容，要手动把子原型对象的constructor属性指回子构造函数。
function Father(uname,age){
this.uname = uname;
this.age = age;
}
function Son(u_uname,a_age,weight){
Father.call(this,u_uname,a_age);//1.子构造函数调用父构造函数
this.weight = weight;
}
Son.prototype = new Father();//2.将父构造函数的实例对象赋值给子原型对象
Son.prototype.constructor = Son;//3.将子原型对象的constructor属性指回子构造函数
// 实例化子构造函数
var son = new Son('吴磊',22,'60kg')
console.log(son);
12.类class的本质是构造函数。
二、ES5新增的方法
forEach、filter、some方法的后面两个参数可以省略，只写一个参数就代表每个数组元素。
1.数组方法forEach( )遍历数组（对象也有）
数组名.forEach( function(item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：数组对象本身
var arr = [0, 1, 2];
arr.forEach(function (item, index, array) {
console.log('每一个数组元素' + item);
console.log('每一个元素的索引号' + index);
console.log('数组对象本身' + array);
});
2.数组方法filter( )筛选数组元素
var 新数组名 = 数组名.filter( function( item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：原数组对象本身
注意：filter( )方法会遍历原数组，并把所有符合要求的元素筛选出来,一定要加return，返回值是一个新数组。
var arr = [10,22,35,40];
var newArr = arr.filter(function(item,index,array){
return item% 2 == 0;//返回偶数装到新数组中
})
console.log(newArr);
3.数组方法some( )查找是否有满足条件的数组元素
var flag = 数组名.some( function( item, index , array ) { } )
item：每一个数组元素
index：每一个数组元素的索引号
array：原数组对象本身
注意：（1）some( )方法会遍历数组，判断是否有元素满足要求，返回值是布尔值。
（2）some( )方法查找到第一个满足要求的元素后，立即停止循环遍历。
（3）return true可以停止some( )方法的循环。另外两个方法不行。
（4）注意return true 的位置，写到 if 判断语句中。
var arr = [12, 45, 2, 67];
var flag = arr.some(function (item, index, array) {
if(item>= 100)
return true;//判断是否有满足要求的条件
});
console.log(flag);
实际应用：查询并操作数组中的唯一元素时，用some()效率更高。
var arr = [];
data.some(function (value) {
if (product.value === value.pname) {
arr.push(value);
return true;
}
}
4.字符串方法trim( )去除字符串两侧空格
字符串.trim( )
注意：trim( )方法可以去除字符串两侧的空格，但不会对字符串中间的空格有影响。返回值是一个新字符串。
5.获取对象的属性名
var arr = Object.keys(对象名)
注意：返回值是一个数组，里面是对象的属性名集合。
var obj = {
id: 1,
pname: '小米',
price: 1999,
num: 2000
};
var result = Object.keys(obj)
console.log(result)//[id，pname,price,num]
6.修改与设置对象的属性
Object.defineProperty( 要修改的对象，要修改或新增的属性，｛｝)
- 三个参数都是必须属性，第三个参数是对象，属性如下：
（1）value:修改或新增的属性的值
（2）writable：true / false。默认值为false ，不允许修改这个属性值。
（3）enumerable：true / false。 默认值为false ，不允许遍历这个属性。
（4）configurable: true / false。 默认值为false，不允许删除这个属性。并且configurable的值不能二次修改。
var WuLei = {
uname: '吴磊',
age: 22,
height: 183,
};
// 添加属性
Object.defineProperty(WuLei, 'hobby', {
value: '撸铁',
writeable: false,
enumerable: false,
configurable: false
});
// writeable设置为false,则不允许再修改hobby的value值
WuLei.hobby = '撸串'
console.log( WuLei.hobby);
//enumerable设置为false，获取WuLei的属性名集合时，就没有hobby
var arr = Object.keys(WuLei);
console.log(arr);
// configurable设置为false,不允许删除hobby属性
delete WuLei.hobby;
console.log(WuLei);
7. map 函数
var newArr = arr.map(function(item,value,arr){ })
（1）map方法会遍历数组，每个数组元素都会执行回调函数。
（2）map方法的回调函数中，必须有 return，返回的数据被 存入新数组中。
（3）map方法返回值是一个 新数组，不会改变原来数组。
8. filter和map的区别
let arr=[2,4,1,5,3,1];
let res1=arr.map(function (item,index,array) {
// return array[index]; //用这种方法也可以获取到当前处理的元素
return item>1;
});
let res2=arr.filter(function (item,index,array) {
return item>1;
});
console.log(res1,res2);//[ true, true, false, true, true, false ] [ 2, 4, 5, 3 ]
map的结果只是对当前元素调用函数后（x是否大于1）的结果。而filter 会将结果为true的数组存到新的数组里面。
三、补充
1.for... in
for (index in 数组/对象)
for...in 语句用于对数组或者对象的属性进行循环操作。
for ... in 循环中的代码每执行一次，就会对数组的元素或者对象的属性进行一次操作。
var x
var mycars = new Array()
mycars[0] = "Saab"
mycars[1] = "Volvo"
mycars[2] = "BMW"
for (x in mycars)
{
document.write(mycars[x] + "<br />")
}
2.for ... of
for( const value of 被遍历的数据)
①for...of 语句用于循环遍历。
②在 ES6 中引入的 for...of 循环，以替代 for...in 和 forEach() ，并支持新的迭代协议。
③for...of 允许遍历 Arrays（数组）, Strings（字符串）, Maps（映射）, Sets（集合）等可迭代的数据结构等。
④不能遍历对象Object。
function args() {
for (const arg of arguments) {
console.log(arg);
}
}
args('a', 'b', 'c');
// Output:
// a
// b
// c
const arr = ['mini', 'mani', 'mo'];
for (const value of arr) {
console.log(value);
}
// Output:
// mini
// mani
// mo
小结
（1）构造函数有原型对象prototype
（2）原型对象prototype有constructor属性，指向构造函数
（3）构造函数可以通过原型对象prototype添加方法。
（4）构造函数的实例对象有_proto_属性，指向构造函数的原型对象prototype
