Question

假设我们在TypeScript中有以下2个外部模块：

OtpVC

和

export module My.Services.Common 
{
    export class Helper 
    {
       //...
    }
}

现在在我的app.ts中我想使用Connection和Helper类。我想要实现的内容类似于C＃中的以下代码：

export module My.Services 
{
    export class Connection
    {
        //...
    }    
}

或者至少只是

using My.Services;
using My.Services.Common;

但看起来我无法同时使用Helper和Connection工作。如果我写：

using My.Services;

导致错误＆＃34;重复标识符＆＃39;我的＆＃39;＆＃34;。这是合乎逻辑的。所以我的问题是如何从相同（或嵌套）的模块中使用不同的类？

Answer 1

我个人对此的看法是脱离您在C＃或Java中看到的内容（更贴近内部模块），并将其视为您正在使用的外部模块...

步骤1.抛弃module关键字。该文件已经是一个模块。

步骤2.导入时提供非虚线别名。

步骤3.您现在可以在导入时导入所有内容，'*'或特定类。

./服务/ common.ts

export class Helper 
{
   //...
}

./ services.ts

export class Connection
{
    //...
}

./ app.ts

import * as Services from './services'
import { Connection } from './services/common'

var x = new Services.Helper();

var y = new Connection();

您也可以从模块导入多个成员：

import { Connection, Example } from './services/common'

var y = new Connection();

var z = new Example();

Answer 2

要添加史蒂夫的好答案，因为我已经绘制了ASCII艺术：从此模块导出的顶级对象My，不会与任何人合并来自名为My的其他文件的其他对象。 My.Services.Common模块唯一能实现的目标是让导入Helper更加烦人，因为你必须完全限定其名称，即使其中没有其他内容

您认为自己已经完成了什么：

/-My--------------------\
| /-Services---------\  |
| | /-Common---\     |  |
| | | [Helper] |     |  |
| | \----------/     |  |
| |                  |  |
| | [Connection]     |  |
| \------------------/  |
\-----------------------/

你实际做了什么：

/-My---------------\   /-My---------------\ 
| /-Services-----\ |   | /-Services-----\ |
| | /-Common---\ | |   | | [Connection] | |
| | | [Helper] | | |   | \--------------/ |
| | \----------/ | |   \------------------/
| \--------------/ | 
\------------------/

这就像在你家里有一个组织系统，你有十几个鞋盒，每个，里面有一个小盒子，每个盒子里面都有一个小盒子。嵌套的盒子没有鞋盒的组织优势！

Answer 3

我找到了解决这个组织问题的另一种方法。

返回ASCII艺术（ᵔᴥᵔ）

我的文件夹结构是这样的：

|
|-- myawesomemodule
|         |
|         |-- myawesomeclass.ts
|         |-- myevenmoreawesomeclass.ts
|         |-- myawesomemodule.ts
|
|-- myevenmoreawesomemodule
|         |-- myotherclass.ts
|         |-- myanotherclass.ts
|         |-- myevenmoreawesomemodule.ts
|
index.ts

在myawesomemodule.ts，我这样做：

export {MyAwesomeClass} from './myawesomeclass'
export {MyEvenMoreAwesomeClass} from './myevenmoreawesomeclass'

同样在myevenmoreawesomemodule.ts中，我这样做：

export {MyOtherClass} from './myotherclass'
export {MyAnotherClass} from './myanotherclass'

最后在index.ts的根级别，我做了：

import * as MyAwesomeModule from "./myawesomemodule/myawesomemodule";
import * as MyEvenMoreAwesomeModule from "./myevenmoreawesomemodule/myevenmoreawesomemodule";

export {MyAwesomeModule};
export {MyEvenMoreAwesomeModule};

现在我可以将此模块发送给消费者，打包为NPM等。

来自消费者，我这样做：

import MyPackage = require("mypackage"); //assuming you did npm pack

OR

import * as MyPackage from "./path/to/index" //assuming you didn't

然后我引用我的班级姓名：

let instance = new MyPackage.MyAwesomeModule.MyAwesomeClass();

我发现这种方法比在根级别的大模块中公开我的所有类要好一些。

在TypeScript中使用外部模块

3 个答案: