ES6循環依賴

Question

這是我遇到的相當頻繁的問題，我希望找到正確的方法來處理它。

所以我有這樣的設置：

parent.js：

export default { 
    x: 1 
} 

a.js：

import parent from 'parent.js' 
export default parent.extend(a, { title: 'a' }) 

b.js：

import parent from 'parent.js' 
export default parent.extend(b, { title: 'b' }) 

很酷，現在我有一些孩子。 但我決定我想在parent.js中有一個函數來檢查對象是否爲a或b的實例。

，所以我可能做到這一點：

parent.js：

import a from 'a' 
import b from 'b' 

export default { 
    x: 1, 
    checkType (obj) { 
    if (obj instanceof a) { 
     return 'a' 
    } else if (obj instanceof b) { 
     return 'b' 
    } 
    } 
} 

現在好了，這是一個循環依賴。有沒有一種優雅的方式來處理這個問題？

Answer 1

如果您能夠使用es6類，那麼您可以利用構造函數中的super（）調用。我會經常做這樣的事情：

Parent.js

export default class { 
    constructor(options, child) { 
     this.child = child; 
     this.x = 1; 
    } 

    checkType() { 
     return this.child; 
    } 
} 

A.js

import Parent from './Parent'; 

export default class extends Parent { 
    constructor(options) { 
     super(options, 'a'); 
    } 
} 

B.js

import Parent from './Parent'; 

export default class extends Parent { 
    constructor(options) { 
     super(options, 'b'); 
    } 
} 

如果你不想使用類，也許想要更多的FP風格。你可以讓父功能：

parent.js

export default function(child) { 
    return { 
     x: 1, 
     checkType (obj) { 
      return child; 
     } 
     extend (something) { 
      // assuming the returns something as you said 
     } 
    } 
} 

a.js

import parent from 'parent.js' 
export default parent('a').extend(a, { title: 'a' }) 

b.js

import parent from 'parent.js' 
export default parent('b').extend(b, { title: 'b' }) 

Answer 2

在父類中有邏輯知道的子類是嚴重的反模式。相反，在返回類型的子類中添加方法。例如，在a.js：

import parent from 'parent.js'; 
export default parent.extend(a, { title: 'a', checkObj() { return 'a'; }}); 

如果從checkObj期望的回報始終是title屬性的值，那麼當然只是：

// parent.js 
export default { 
    x: 1, 
    checkObj() { return this.title; } 
} 

我不知道到底是什麼extend做這裏。我假設它是某種子類機制。

通常，循環導入依賴關係，儘管在真正必要時有辦法處理它們，但是Universe試圖告訴您，您的代碼結構有問題。