使用 `import type` 语句修复循环依赖引用错误

Question

假设我有两个文件，A.js 和 B.js。两者都需要像这样相互引用。

A.js

import { B } from "b"

export class A {
  constructor(public name: string) {}
}

let b = new B();
b.print(new A("This is a random name"));

B.js

import { A } from "a"

export class B {
  print(a: A) {
    console.log(a.name);
  }
}

上面的示例将创建一个循环引用，该引用当前在我使用的 JavaScript 运行时中不起作用。 B.js 文件实际上只需要类型信息，而不需要实际的导出对象）。我希望 A.js 中的类型进行静态类型检查。这可能吗？

Answer 1

这现在可以在 TypeScript 2.9 中直接实现。

type MyType = import('mymodule').MyType;
const myValue: import('mymodule').MyType;

Answer 2

更新：这个答案可能会过时 as soon as TypeScript 3.8 is released

你不需要做任何特别的事情来只从模块a导入类型信息。

Typescript 会为你做这件事 - 如果模块 b 需要表单 a 的唯一东西是类型信息，编译文件 b.js 将没有 require("./a") 语句，也就是说，它不会有运行时依赖a。引用typescript handbook:

编译器检测每个模块是否在发出的 JavaScript。如果模块标识符仅用作类型的一部分 注释并且从不作为表达式，则不需要调用 为该模块发出。

我刚试过：

文件a.ts

import { B } from "./b"

export class A {
    constructor(public name: string) {}
}

let b = new B();
b.print(new A("This is a random name"));

文件b.ts

import { A } from './a';

export class B {
    print(a: A) {
        console.log(a.name);
    }
}

一起编译

tsc a.ts b.ts

这是结果 b.js：

"use strict";
var B = (function () {
    function B() {
    }
    B.prototype.print = function (a) {
        console.log(a.name);
    };
    return B;
}());
exports.B = B;

看到了吗？没有require("./a")，不像a.js 包含

var b_1 = require("./b");

很可能，您在问题中发布的示例代码不完整，并且真正的 b 模块在运行时依赖于 a - 找出它的位置并摆脱它，您就不会遇到这个问题.

Answer 3

从 TypeScript 3.8 开始，使用 import type:

import type { SomeThing } from "./some-module.js";

export type { SomeThing };

参考：

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#type-only-imports-exports

Answer 4

你在这里使用了 [typescript] 标签，所以我假设你使用的是 typescript。

将此设为单向街道。杀死循环依赖。我可能会将它移动到 1 个文件中，但您仍然可以像这样拆分它。

a.ts（只是一个界面）

export interface A {
    name: string;
    new (name: string);
}

b.ts（实现）

import { A } from 'a';

export class B implements A {
    /*...*/
}