Question

我目前正在阅读一本关于JS设计模式的书，想要对某些事情做一些确认以下代码说明了本书所示的状态模式：

var BankAccountManager = (function () {
 function BankAccountManager() {
     this.currentState = new GoodStandingState(this);
 }
 BankAccountManager.prototype.Deposit = function (amount) {
     this.currentState.Deposit(amount);
 };
 BankAccountManager.prototype.Withdraw = function (amount) {
     this.currentState.Withdraw(amount);
 };
 BankAccountManager.prototype.addToBalance = function (amount) {
     this.balance += amount;
 };
 BankAccountManager.prototype.getBalance = function () {
     return this.balance;
 };
 BankAccountManager.prototype.moveToState = function (newState) {
     this.currentState = newState;
 };
 return BankAccountManager;
})(); 

var GoodStandingState = (function () {
 function GoodStandingState(manager) {
     this.manager = manager;
 }
 GoodStandingState.prototype.Deposit = function (amount) {
     this.manager.addToBalance(amount);
 };
 GoodStandingState.prototype.Withdraw = function (amount) {
     if (this.manager.getBalance() < amount) {
         this.manager.moveToState(new OverdrawnState(this.manager));
     }
     this.manager.addToBalance(-1 * amount);
 };
 return GoodStandingState;
})();

在上一个代码段中，BankAccountManager和GoodStandingState保持对彼此的引用，从而创建一个循环。
正如我所读到的，由于用于垃圾收集的Mark-and-sweep算法，这不再构成问题：

垃圾收集器会定期从这些根开始查找从这些根引用的所有对象，然后是所有对象从这些引用，等等。从根，垃圾开始因此，collector将找到所有可到达的对象并收集所有对象不可到达的对象。

仍然，我想知道是否将this作为参数传递，并将其作为引用变量绑定到另一个对象（由当前对象引用）是一种良好的做法，或者是否仍然可以更好地避免它。在另一种应用GC引用计数算法的语言中，我假设前一个片段可能导致内存泄漏。

是否可以应用此模式，还是更明智地避免它？

国家模式好的做法？

0 个答案: