跨 CommonJS 模块的 Typescript 继承 - 循环依赖

Question

我无法在使用 typescript 1.0 生成的 CommonJS 模块之间进行继承（tscis run using --module commonjs）

当两个类继承同一个基类，“通过”基类相互调用时，这会失败。

似乎是第一个类导入了基类，它导入了第二个类，第二个类也导入了基类，但最后一个基类导入失败。

下面提供了一个说明此行为的示例。

Typescript 或 CommonJS 规范中是否有任何内容阻止我这样做，或者这是一个错误？

=== 示例 ===

这个迷人的软件因运行Lower.test.ts 而失败。它试图实现的只是将一个单词加载到Lower 中，使其保持小写，然后使用从Base 类继承的toUpper() 方法，使用Upper 类将其转换为大写（这也是继承Base)

Lower.test.ts

import Lower = require('./Lower')

console.log(new Lower('smallcaps').toUpper())

Base.ts

import Upper = require('./Upper')

class Base {

    word: string

    toUpper(): string {
        return new Upper(this.word).word
    }
}

export = Base

Upper.ts

import Base = require('./Base')

class Upper extends Base {

    constructor(word:string) {
        super()
        this.word = word.toUpperCase()
    }
}

export = Upper

Lower.ts

import Base = require('./Base')

class Lower extends Base {

    constructor(word:string) {

        super()
        this.word = word.toLowerCase()
    }
}

export = Lower

Answer 1

通常最好只依赖一个方向 - 根据 SOLID 原则。

但是，由于您始终需要 Base 和 Upper（即不能没有另一个），您可以将它们添加到同一个模块中...

base.ts

export class Base {
    word: string

    toUpper(): string {
        return new Upper(this.word).word
    }
}

export class Upper extends Base {

    constructor(word: string) {
        super()
        this.word = word.toUpperCase()
    }
}

lower.ts

import b = require('base')

class Lower extends b.Base {

    constructor(word: string) {

        super()
        this.word = word.toLowerCase()
    }
}

export = Lower 

app.ts

import Lower = require('lower');

console.log(new Lower('smallcaps').toUpper());

Answer 2

经过一些研究和测试，这最终是一个循环依赖的情况。

这个问题已经得到很好的记录，并且已经提出了各种解决方案：

1. 在requiring:here之前导出
2. 延迟require 或使用注入：here
3. 移动语句：很长的列表here

不幸的是，在 Typescript 中可以设置 import 和 export 语句的位置几乎没有控制，这减少了仅注入的解决方案。下面提供了重写的Base 类。

循环依赖是 Javascript 模块化项目中的一个难题。打字稿不知何故使事情变得更糟。对于本应处理大型项目的语言来说，这是个坏消息

编辑 我已经打开了一个案例并向 TypeScript 项目提交了一个建议的转译器修复：here

Base.ts

//This import will "fail" by importing an empty object but is needed to trick the compiler
//An alternative is to design and Upper.d.ts definition file and reference it
import Upper = require('./Upper')

class Base {

    //Upper is a sub-class of Base and needs to be injected to be instantiated
    private _Upper: typeof Upper

    word: string

    constructor(_Upper: typeof Upper) {
        this._Upper = _Upper
    }

    toUpper(): string {
        //This where the injection is used
        return new this._Upper(this.word).word
    }


    getUpperWord(upper: Upper): string {
        //The injection is not reauired in this case
        return upper.word
    }
}

export = Base

Upper.ts

import Base = require('./Base')

class Upper extends Base {

    constructor(word:string) {
        super(Upper)
        this.word = word.toUpperCase();
    }
}

export = Upper