一、成员属性和成员方法
在构造函数中，通过this.属性声明，或者实例化出对象后，通过“对象.属性”追加的，都属于成员属性或成员方法，也叫实例属性与实例方法；
成员属性/方法，是属于实例化的这个对象，通过“对象.属性”调用；
function Person(name) {
this.name = name; // 声明成员属性
this.say = function() { // 声明成员方法
console.log('haha')
}
}
var chaiting=new Person('chaiting');
chaiting.age=18; // 追加成员属性
console.log(chaiting.name); // chaiting
console.log(chaiting.age); // 18
chaiting.say(); // haha
二、静态属性和静态方法
通过“类名.属性名”，“类名.方法名”声明的变量，成为静态属性、静态方法，也叫类属性、类方法；类属性、类方法是属于类的（构造函数的），这类属性或方法必须通过“类名.属性”调用，而不能通过对象名调用；
function Person(){}
Person.age = 21;
Person.say = function(){
alert('haha');
}
console.log(Person.age,111); // 21 111
Person.say(); // haha
var chaiting = new Person();
console.log(chaiting.age,222); // undefined 222
chaiting.say(); // chaiting.say is not a function
三、私有属性和私有方法
在构造函数中，通过var声明的属性，成为私有属性，私有属性的作用域仅在当前函数有效，对外不公开，即通过对象/类都无法调用到；
function Person(){
var sex = 'male';
console.log(sex); // male 私有属性只能在类内使用
}
console.log(Person.sex); // undefined 无法调用，私有属性只能在类内使用，且js变量具有函数作用域
var chaiting=new Person();
console.log(chaiting.sex); // undefined 无法调用，私有属性只能在类内使用
四、原型属性和原型方法
写在了构造函数的prototype上，当使用构造函数实例化对象时，该属性方法会进入新对象的proto上；
function Person(){}
Person.prototype.name="chaiting"; // 声明原型属性
Person.prototype.say=function(){ // 声明原型方法
console.log('haha');
}
var person = new Person();
console.log(person.name); // chaiting 使用对象调用原型属性
person.say(); // haha 使用对象调用原型方法
成员属性和原型属性的区别：成员属性是直接声明在对象自身上的，而原型属性是声明在对象的__proto__上，在我们使用“对象名.属性名”访问一个属性时，会先访问成员属性，如果成员属性中找不到，JS会沿着对象的原型链，继续通过__proto__向上查找，也就找到了原型属性，这就是我们可以使用“对象名.属性名”访问成员属性和原型属性的原因；
function Person(name) {
this.name = name; // 声明成员属性
this.say = function() { // 声明成员方法
console.log('haha')
}
}
Person.prototype.sex='female';
var person=new Person('chaiting');
person.age=18; // 追加成员属性
console.log(person)
成员属性和原型属性的区别
五、原型与原型链
- prototype和__proto__
① prototype（函数的原型对象）：函数才有prototype，而且所有函数必有prototype，prototype是一个对象，指向当前构造函数的引用地址；
② __proto__(对象的原型)：对象才有__proto__，而且所有对象必有__proto__（这里的对象除了我们理解的狭义对象，也包括了函数、数组等对象），当用构造函数实例化(new)一个对象时，会将新对象的__proto__属性指向构造函数的prototype；
function Person(){}
var zhangsan = new Person();
console.log(zhangsan.__proto__ == Person.prototype); // true
//【解释】上例中，我们使用函数Person，new出了一个对象zhangsan。 那么对象zhangsan的__proto__就等于函数Person的prototype。
- 原型链
从上面的介绍中我们得知：对象的__proto__指向函数的prototype，函数的prototype本身也是个对象，是对象肯定也有__proto__，那他的__proto__指向了谁呢，顺着这个问题，我们延着一个对象__proto__向上查找，这条线路就是我们所说的原型链；
①通过构造函数，new出的对象，新对象的__proto__指向构造函数的prototype；
②所有函数的__proto__指向Function()的prototype；
③非构造函数new出的对象（{} new Object() 对象的prototype）的__proto__指向Object的prototype；
④ Object的prototype的__proto__指向null；
原型链
六、成员属性与原型方法
习惯上，我们会将属性写为成员属性，而方法写为原型方法，原因如下：
①实例化出对象后，所有属性直接在对象上，所有方法都在__proto__上，非常直观清晰；
②方法写到prototype上，要更加节省内存；
③使用for in循环时，会将对象以及对象原型链上的所有属性和方法打印出来，而方法往往是不需要展示的，将方法写到__proto__上，可以使用hasOwnProperty将原型上的方法过滤掉，不显示；
④ 官方都这么写；
function Person(name) {
this.name = name; // 声明成员属性
this.say = function() { // 声明成员方法
console.log('haha')
}
}
Person.prototype.sex='female';
var person=new Person('chaiting');
person.age=18; // 追加成员属性
for(keys in person){
if(person.hasOwnProperty(keys)){
console.log(person[keys]) // 未打印出'female'
}
}
七、prototype扩展内置函数
我们通过使用prototype扩展内置函数的方法，可以直接使用内置函数的对象，调用我们扩展的方法；
// 为Array类添加一个find(val)方法，当一个Array对象调用该方法的时候，如果能找到val值，则返回其下标，否则返回-1
Array.prototype.find = function(val) {
for (var i = 0; i < this.length; i++) {
if (this[i] == val) {
return i;
}
}
return -1;
}
var arr = new Array(1, 2, 3, 4, 5);
console.log(arr.find(1)); // 0
参考：https://www.cnblogs.com/jerehedu/p/7495098.html