刚接触 typescript，如何将类通过方法导出？

Promise<typeof ClassA> 哇

@oott123
```js
function bbb():Promise<typeof ClassA> {
return new ClassA()
}

```
不行，比如上面会报类型不一致

@zy445566 #2 你这个返回的怎么会是 Promise 呢，又不是 async 包装，而且 ClassA() 和 ClassA 肯定是两个东西。

@maichael
```js
function bbb():Promise<typeof ClassA> {
return Promise.resolve(new ClassA())
}
```
之前试过，回帖代码写快了，一样是报类型不一致

@zy445566 #4 你这个用直接用 ClassA，不要用 typeof ClassA

@maichael 那又回到了最初的问题 ClassA refers to a value, but is being used as a type here. ts(2749)。
报 ClassA 不是一个类，而是一个值，我感觉是 ts 没把 ClassA 在另一个文件注册为类导致的

@zy445566 #6 用 InstanceType<ClassA>

@maichael 没明白，能写一段么

(那个，其实你直接写的话
返回值不用标记的。。。
然后 vscode 鼠标移动上去看自动推导的类型

@codehz 不行，推导结果是: Promise<unknown>

```
type ClassA = class aaa{} class 声明的时候自带类型 不用再 typ
直接这样就行了
class ClassA {};
```

@MrJeff 这其实是我写错了，我其实就是要把这个类在另一个文件使用，且这个类必须通过方法来导出

@MrJeff 就是不通过 export 通过统一入口的一个方法来导出，我还尝试了
```js
getClassA():new ()=> ClassA{
return ClassA
}
```
也无法实现动态导出

@zy445566 这样是可以的 a~
const anOnymousA= new (getClassA())();

```
class aaa {

}

async function getClassA(): Promise<typeof aaa> {
return aaa
}

(async () => {
const b = new (await getClassA())();
console.log(b);
})()

```
大概这样?

@Kaakira 我主要是为了给第二个文件做推导，实例本来就是可以生成的

@fy136649111 我主要是为了给第二个文件做推导，实例本来就是可以生成的

写个伪代码
declare function requireClassA():Promise<typeof ClassA>;
async ()=>{
const c = await requireClassA();
const b:InstanceType<typeof c> =new a();
}

上面写错了点东西，看得懂就好（
平时你写 classA{}，这个文件里就出现了一个 classA 的构造器值和一个 classA 的类型是实例的类型，
用方法返回的肯定只能是一个值，按你的导出，导出的是这个构造器
typeof 这个值获得的当然是构造器的类型，不是实例的
实例的类型用 InstanceType 泛型获取

@islxyqwe 好吧，如果我希望 promise 接收的是实例而不是类呢？

要分清楚类型和值

class A {}
const a = new A()

其中 a 是值，代表 A 的实例
A 既是值也是类型，作为值的时候代表 A 本身，作为类型时代表 A 的实例类型
A(值)本身的类型呢？ typeof A
怎么通过类的类型获取实例类型？ InstanceType<T>

class A {}
const a: A = new A();

type AClassType = typeof A // 类的类型
const B: AClassType = A;
const a2: A = new B();
const a3: InstanceType<AClassType> = new A();

type Factory = () => A;
const factory: Factory = () => new A();

type Factory2 = <T extends { new(...p: any): any }>(c: T) => InstanceType<T>;
const factory2: Factory2 = (C) => new C();

const a4: A = factory2(A);