搞个抽象工厂 + 单利，每个都保存一份实例。

相互依赖会出现这样的情况，因为本身还没有运行完，所以是空的。

~/Desktop/stylus ᐅ ts-node b.ts
b
undefined
a
[Function: a]
~/Desktop/stylus ᐅ ts-node a.ts
a
undefined
b
[Function: b]

a.ts

import { Factory } from './factory'

export class a {
    name: string
    constructor() {
        this.name = "Yugo"

        let b = Factory('b');
        console.log(b);
        let b2 = Factory('b');
        console.log(b === b2);
    }
}

let assss = new a();

b.ts

export class b {
    name: string
    constructor() {
        this.name = "Yugo"
    }
}

factory.ts

import { a } from './a'
import { b } from './b'

let instace = {};

export const Factory = (className) => {
    if (instace[className]) return instace[className];
    console.dir(instace);
    switch (className) {
        case "a":
            instace[className] = new a();
            return instace[className];
        case "b":
            instace[className] = new b();
            return instace[className];
    }
}

import { a } from './a'
import { b } from './b'

let classList = {
     a,
     b
}

interface instaceType {
    a: a,
    b: b
}

let instace: instaceType = {
    a: null,
    b: null
};

type className = keyof instaceType;

export const Factory = (className: className, ...args) => {
    if (instace[className]) return instace[className];
    try{
        let currentClass = classList[className];
        if (!currentClass) throw new Error('not fond class ' + className);
        instace[className] = new currentClass()
        return instace[className];
    }catch(e){
        console.error(e)
    }
}

这个是懒汉模式，也可以自己搞一个饿汉模式。