Question

Javascript OOP中的事务多态性：

我正在努力通过javascript更好地使用OOP，目前正致力于处理不同类型商业交易的OOP解决方案，买入，买入等等。

我之前拥有它的方式是我在if语句的一侧有所有卖方操作，并带有一个处理每种交易类型的开关。

然后我为买家做了同样的事情。

通过这个我已经改进了代码的结构，所以它更容易阅读，但我发现自己认为＆＃34; SWITCH＆＃34; inside processSellerTransactions和processBuyerTransactions是错误的。

如果我已经设置了所有原型（购买，竞标）等。我想直接调用原型函数而不必使用switch语句。

任何人都可以指出我正确的方向（教程等）或指出我做错了什么。

我得到它（有点），但它仍然很新，所以任何帮助都会非常感激。

提前致谢。

var Transaction = function(transactionType) {
    this.transactionType = transactionType;
};

Transaction.prototype.buy = function(){
    console.log("Buy");
};

Transaction.prototype.bid = function(){
    console.log("Bid");
};

function Type(transactionType, transactionId) {
    Transaction.call(this, transactionType); 
    this.transactionId = transactionId;
}

Type.prototype = Object.create(Transaction.prototype);

Type.prototype.constructor = Type;

Type.prototype.processSellerTransactions = function(){ 

    switch(this.transactionType) {
        case 'buy':
                  console.log('do the buy logic for seller');
                break;
            case 'bid':
                  console.log('do the bid logic for seller')
                break;
    }
};

Type.prototype.processBuyerTransactions = function(){ 
    switch(this.transactionType) {
        case 'buy':
                 console.log('do the buy logic for buyer');
                break;
            case 'bid':
                 console.log('do the bid logic for buyer')
                break;
  }
};

var user = 'seller';
var transaction_type = 'buy';
var transaction_id = '12345';

var transaction = new Type(transaction_type, transactionId);

if(user == seller)
    transaction.processSellerTransactions();    

if(user == buyer)
    transaction.processBuyerTransactions();

感谢John对战略模式的建议。这是Javascript中的一个简单示例

Strategy Pattern In Javascript Example

Answer 1

您可以通过拥有BuyerTransaction和SellerTransactionClass来摆脱该switch语句。然后，将该逻辑移到另一个实例化正确类型的函数中。

e.g

function createTransaction(person){
if(person === 'buyer'){
  return new BuyerTransaction();
}
return new SellerTransaction();
}

var BuyerTransaction = function(){}
BuyerTransaction.prototype = Object.create(Transaction.prototype);
BuyerTransaction.prototype.buy = function(){}
BuyerTransaction.prototype.bid = function(){}

var SellerTransaction = function(){}
SellerTransaction.prototype = Object.create(Transaction.prototype);
SellerTransaction.prototype.buy = function(){}

//at runtime
var transaction = createTransaction('buyer');
transaction.buy();

Answer 2

您需要制作TransactionType和知道如何处理交易的抽象，然后您可以使用Strategy Pattern将处理传递给TransactionType

您可以将其转换为原型样式

function BidTransactionType(){
  this.processSellerTransaction = function(type){
    console.log('process seller transaction')
  }
  this.processBuyerTransaction = function(type){
    console.log('process buyer transaction')
  }
}
function Type(transactionType,
Type.prototype.processSellerTransactions = function(){ 

    switch(this.transactionType) {
        case 'buy':
                  console.log('do the buy logic for seller');
                break;
            case 'bid':
                  console.log('do the bid logic for seller')
                break;
    }
};
function Type(transactionType, transactionId) {
    this.transactionType = transactionType; 
    this.transactionId = transactionId;
}

Type.prototype.processBuyerTransactions = function(){ 
    transactionType.processBuyerTransaction(this);
};

Type.prototype.processSellerTransactions = function(){ 
    transactionType.processSellerTransaction(this);
};

var user = 'seller';
var transaction_type = new BuyerType();
var transaction_id = '12345';

var transaction = new Type(transaction_type, transactionId);

这样做的好处是，您可以创建更多交易类型，而无需更改Type对象，与Open/Closed Principle

保持一致

OOP建议使用原型

2 个答案: