js面向对象设计之function类

本文仅探讨如何合理的使用 function 在 javascript中实现一个面向对象设计的类。总所周知，javascript 并不能实现一个真正意义上的类，比如 protect 比如 函数重载。
下面开始由浅入深的讨论 function 作为类来使用如何尽可能的模拟传统的面向对象设计。
还有一篇相关博文（关于 class）可对比阅读：js面向对象设计之class类。
下面的 Class01 一个最简单的类。
function Class01( val, pVal ) {
    this.val = val; /*实例可直接读写的属性*/
    var pVal = pVal; /*实例无法直接读写的属性*/
}
Class01.prototype.printVal = function () {
    var _this = this;
    /*此处并不会出现this丢失，但推荐这么做*/
    console.log( _this.val );
};

对于实例无法直接读写的属性，需要提供接口，首先想到的是提供实例方法，如下面这个例子的 getpVal 和 setpVal。
这样做的弊端十分明显，每一个实例都将拥有getpVal和setpVal，是否可以在原型上定义getpVal和setpVal，先来试试。
function Class01( val, pVal ) {
    this.val = val; /*实例可直接读写的属性*/
    var pVal = pVal; /*实例无法直接读写的属性*/
    this.getpVal = function () {
        return pVal;
    };
    this.setpVal = function ( v ) {
        pVal = v;
        return this;
    }
}

下面的例子是通过原型方法读取“私有”属性pVal，试过发现，运行报错，pVal并不存在，路子都被堵死了，采用这种方式定义“私有”属性将只能通过实例方法读写。
这种方式显然不能在工程中使用，下面介绍另外一种方法
function Class01( val, pVal ) {
    this.val = val; /*实例可直接读写的属性*/
    var pVal = pVal; /*实例无法直接读写的属性*/
}
Class01.prototype.printVal = function (){
    var _this = this;
    console.log( _this.val );
};
Class01.prototype.getpVal = function (){
    console.log( pVal );
};
var ins01 = new Class01( , 2 );
ins01.getpVal(); /*此处报错*/

采用高阶函数，return function的方式,在Class01的内部只定义可直接读写的属性,而把“私有”属性或方法放到Class作用域外部
var Class01 = ( function () {
    var pValue = ''; /*实例无法直接读写的属性*/
    function hello (){
        console.log( '欢迎来到nDos的博客' );
    }
    function Class( val, pVal ){
        this.val = val; /*实例可直接读写的属性*/
        pValue = pVal;
    }
    Class.prototype.printVal = function (){
        var _this = this;
        console.log( _this.val );
    };
    Class.prototype.getpVal = function (){
        console.log( pValue );
        return pValue;
    };
    Class.prototype.setpVal = function ( v ){
        pValue = v;
        return this;
    };
    Class.prototype.sayHello = function (){
        hello();
        return this;
    };
    return Class;
} )();
var ins01 = new Class01( , 2 );
ins01.getpVal();
ins01.setpVal( '2222' ).getpVal();
ins01.sayHello();

小问题：实例 ins01 是由 Class 实例化而来，还是由 Class01 实例化而来。
console.log( ins01.constructor.name ); /* 此处是 Class */
console.log( ins01 instanceof Class01 ); /* 此处是 true */
显然在这里会在类的使用过程中造成疑惑，也会使得项目的实例的归属产生问题。可以把 Class01 直接改为 Class 即可。

小tips：在 Google 开发者工具中找到 Class.__proto__.constructor["[[Scopes]]"]
在这里可以看到闭包、全局作用域等信息。

至此，function 类中已经可以实现实例属性、实例私有属性和方法、原型方法。
实例方法一般不会在类中定义，而是在实例化之后有客户自行添加。
原型上也一般不会定义属性，原因在于原型属性并不能读写（对于数值字符串和布尔值），若可读写会影响所有实例。

小tips：对于私有属性和方法，建议将它们写入到一个对象当中，进行块状管理，在大型项目中代码结构清晰一些。
var pV = { pVal:'', hello:() => console.log('ok') }

传统面向对象设计中类还存在静态方法和静态属性，在 javascript 中也可以轻松实现。
静态方法只能通过类调用，静态属性也只能如此使用。静态属性和方法，类的实例无法获取。
var Class = ( function (){
    /*代码略*/
    Class.prototype.nDos = {
        name: 'nDos',
        sayHello: hello
    };
    Class.prototype.noChangeVal = '实例拿我没办法';
    Class.staticVal = 'Class的静态属性';
    Class.staticMethod = function (){
        console.log( 'Class的静态方法' );
    };
    return Class;
} )();
var ins01 = new Class( , 2 ),
    ins02 = new Class( 'a', 'b' );
ins01.nDos.name = 'ins01 say hello nDos'; /*对于数组也是一样的*/
console.log( 'ins02中的name值:' + ins02.nDos.name );
try {
    ins01.noChangeVal = '实例1改变原型属性值';
    console.log( ins01.noChangeVal );
    console.log( ins02.noChangeVal );
    ins01.prototype.noChangeVal = '我就是想改变它'; /*报错*/
} catch ( e ) {
    console.Error( e );
}

总结：
1、静态属性和原型属性，都可以用来储存实例化次数，同样也可以用来储存每个实例的引用。
此处建议尽量使用静态属性，不使用原型属性的原因在于原型属性容易被实例属性覆盖。
2、显然 function 也可以被当作函数执行，在实际项目中为了防止这种情况发生，需要加入防御性代码：
    if ( this.constructor.name !== 'Class' ) {
      throw new Error( '类只能被实例化' );
    }
就算这么做了，还是可以绕过去：
    function fakeClass () {
      Class01.call(this, '1', '2');
    }
    fakeClass.prototype = Class.prototype;
    var ins = new fakeClass();
当然这算是继承里边的内容。
3、为避免2中出现的情况，就是加入以下代码：
    if ( !new.target || new.target.name !== 'Class' ) { 
      throw new Error( '类只能被实例化' ); 
    }
4、只有函数才能被实例化，实例化之后得到的变量是实例并不是函数或者说是 object。
5、function 类实例化过程，实际上是函数体的执行过程。这个执行过程也就是初始化的过程。
在这种过程当中可以做相当多的事情，比如 上述的防御性代码、实例（this）的传递与储存、使用 Object.assign 给this扩充功能（Mixin）
以及加入钩子函数，让类消费者自行决定如何实例化等
6、function 类一般不会有 return 当然也可以存在。若没有 return，函数会自动返回 this 做为类的实例。
若存在 return，该类生成的内容便可比较灵活丰富，读者可自行想象，比如通过不同的钩子函数返回不同的内容。

结尾是学习用源代码：

var Class = ( function (){
    var pValue = ''; /*实例无法直接读写的属性*/
    function hello (){
        console.log( '欢迎来到nDos的博客' );
    }
    function Class( val, pVal ){
        if ( this.constructor.name !== 'Class' ){
            throw new Error( '类只能被实例化' );
        }
        if ( !new.target || new.target.name !== 'Class' ){
            throw new Error( '类只能被实例化' );
        }
        this.val = val; /*实例可直接读写的属性*/
        pValue = pVal;
    }
    Class.prototype.printVal = function (){
        var _this = this;
        /*尽管此处并不会出现this丢失的情况，但推荐总是这么做*/
        console.log( _this.val );
    };
    Class.prototype.getpVal = function (){
        console.log( pValue );
        return pValue;
    };
    Class.prototype.setpVal = function ( v ){
        pValue = v;
        return this;
    };
    Class.prototype.sayHello = function (){
        hello();
        return this;
    };
    Class.prototype.nDos = {
        name: 'nDos',
        sayHello: hello
    };
    Class.prototype.noChangeVal = '实例拿我没办法';
    Class.staticVal = 'Class的静态属性';
    Class.staticMethod = function (){
        console.log( 'Class的静态方法' );
    };
    return Class;
} )();
var ins01 = new Class( , 2 ),
    ins02 = new Class( 'a', 'b' );
ins01.nDos.name = 'ins01 say hello nDos'; /*对于数组也是一样的*/
console.log( 'ins02中的name值:' + ins02.nDos.name );
try {
    ins01.noChangeVal = '实例1改变原型属性值';
    console.log( ins01.noChangeVal );
    console.log( ins02.noChangeVal );
    /* ins01.prototype.noChangeVal = '我就是想改变它'; 报错*/
} catch ( e ) {
    console.error( e );
}
function fakeClass(){
    Class.call( this, '1', '2' );
}
fakeClass.prototype = Class.prototype;
var ins = new fakeClass();