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试图告诉您，您的代码结构有问题。