js 編寫一個神奇的四則運算

寫一個算法，有時候可以用簡單的方法就可以寫出來，但是只能針對特定的環境，如果要能夠適應不同的環境，就需要對算法進行優化，在優化的過程中，你會覺得非常神奇，下面來看一個簡單的四則運算的算法編寫方式：

1.簡單粗暴的實現：直接創建一個對象，在對象上直接掛載加減乘除方法

 <script>
        var per = {
            add: function(n1, n2) {
                return n1 + n2;
            },
            sbb: function(n1, n2) {
                return n1 - n2;
            },
            multi: function(n1, n2) {
                return n1 * n2;
            },
            div: function(n1, n2) {
                return n1 / n2;
            },

        }
        console.log(per.add(10, 20));
        console.log(per.sbb(10, 20));
        console.log(per.multi(10, 20));
        console.log(per.div(10, 20));
    </script>

運行結果：

2.采用構造函數的方式，把方法加減乘除方法寫在構造函數中

<script>
        function OPP(n1, n2) {
            this.num1 = n1 || 0; // 當傳入參數n1時，設置this.num1 = n1,否則設置為0；
            this.num2 = n2 || 0; // 當傳入參數n2時，設置this.num2 = n2,否則設置為0；
            this.setdata = function(n1, n2) {
                this.num1 = n1 || 0; // 當傳入參數n1時，設置this.num1 = n1,否則設置為0；
                this.num2 = n2 || 0; // 當傳入參數n2時，設置this.num2 = n2,否則設置為0；
            };
            // 函數的運行，首先設置相關元素的屬性值，然后再進行調用
            this.add = function() {
                // 當add()函數傳入參數時，那么設置參數就使用傳入的參數arguments[0]/arguments[1],否則使用原先的構造函數的參數this.num1/this.num2
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 + this.num2;
            };
            this.sbb = function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 - this.num2;
            };
            this.multi = function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 * this.num2;
            };
            this.div = function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 / this.num2;
            }
        }
        console.log(new OPP(10, 20).add()); // 30
        console.log(new OPP().add(10, 20)); // 30
        console.log(new OPP(100, 200).add(10, 20)); //30
        console.log(new OPP(10, 20).sbb()); //-10
        console.log(new OPP().sbb(10, 20)); //-10
        console.log(new OPP(100, 200).sbb(10, 20)); //-10
        console.log(new OPP(10, 20).multi()); //200
        console.log(new OPP().multi(10, 20)); //200
        console.log(new OPP(10, 20).div()); //0.5
        console.log(new OPP().div(10, 20)); //0.5
    </script>

運行結果：

3. 采用構造函數的原型對象的方式，即將調用函數掛載到了構造函數的原型對象上，當調用函數時，是通過原型鏈進行調用的，而上一個沒有涉及到原型鏈的問題，這是與上一種方式的本質區別

<script>
        function OPP(n1, n2) {
            this.num1 = n1 || 0; // 當傳入參數n1時，設置this.num1 = n1,否則設置為0；
            this.num2 = n2 || 0; // 當傳入參數n2時，設置this.num2 = n2,否則設置為0；
        }
        OPP.prototype = {
            constructor: OPP,
            setdata: function(n1, n2) {
                this.num1 = n1 || 0;
                this.num2 = n2 || 0;
            },
            add: function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 + this.num2;
            },
            sbb: function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 - this.num2;
            },
            multi: function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 * this.num2;
            },
            div: function() {
                this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
                return this.num1 / this.num2;
            },
        };

        console.log(new OPP(10, 20).add()); // 30
        console.log(new OPP().add(10, 20)); // 30
        console.log(new OPP(100, 200).add(10, 20)); //30
        console.log(new OPP(10, 20).sbb()); //-10
        console.log(new OPP().sbb(10, 20)); //-10
        console.log(new OPP(100, 200).sbb(10, 20)); //-10
        console.log(new OPP(10, 20).multi()); //200
        console.log(new OPP().multi(10, 20)); //200
        console.log(new OPP(10, 20).div()); //0.5
        console.log(new OPP().div(10, 20)); //0.5
    </script>

運行結果：

4. 使用繼承的方式實現：

<script>
        function OPP(n1, n2) {
            this.num1 = n1 || 0; // 當傳入參數n1時，設置this.num1 = n1,否則設置為0；
            this.num2 = n2 || 0; // 當傳入參數n2時，設置this.num2 = n2,否則設置為0；
        };
        OPP.prototype.run = function() {
            throw new Error('原型鏈中沒有該方法，請從寫該方法才能調用！');
        };

        function object(o) {
            var G = function() {};
            G.prototype = o;
            return new G();
        };

        function inheritPrototype(subObj, superObj) {
            //調用中間函數:object,實現把子類的原型對象指向中間函數G的實例，而G的實例指向想父類的原型對象，
            // 同時把實例的constructor 屬性指向子類；相當於在原型鏈中增加了一個實例，而實例作為子類的原型對象，這樣子類就可以通過原型鏈實現對父類的繼承了
            var proObj = object(superObj.prototype);
            // 調用object()函數的意義，基本上就是實現以下注釋的功能
            // var G = function() {};
            // G.prototype = superObj.prototype;
            // var proObj = new G();
            proObj.constructor = subObj;
            subObj.prototype = proObj;
        };

        function add(n1, n2) {
            OPP.call(this, n1, n2);
        };
        inheritPrototype(add, OPP);
        add.prototype.run = function() {
            return this.num1 + this.num2;
        };

        function sbb(n1, n2) {
            OPP.call(this, n1, n2);
        };
        inheritPrototype(sbb, OPP);
        sbb.prototype.run = function() {
            return this.num1 - this.num2;
        };

        function multi(n1, n2) {
            OPP.call(this, n1, n2);
        };
        inheritPrototype(multi, OPP);
        multi.prototype.run = function() {
            return this.num1 * this.num2;
        };

        function div(n1, n2) {
            OPP.call(this, n1, n2);
        };
        inheritPrototype(div, OPP);
        div.prototype.run = function() {
            return this.num1 / this.num2;
        };

        var huanying2015 = function(n1, n2, oper) {
            switch (oper) {
                case '+':
                    return new add(n1, n2).run();
                    break;
                case '-':
                    return new sbb(n1, n2).run();
                    break;
                case '*':
                    return new multi(n1, n2).run();
                    break;
                case '/':
                    return new div(n1, n2).run();
                    break;
            }
        }

        console.log(huanying2015(100, 200, '+'));
        console.log(huanying2015(100, 200, '-'));
        console.log(huanying2015(100, 200, '*'));
        console.log(huanying2015(100, 200, '/'));
    </script>

 

運行結果：