成员属性、静态属性、私有属性、原型属性

一、成员属性和成员方法
     在构造函数中，通过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