在我看来，有很多使用场景。如果你需要一个灵活且功能丰富的mixin,你通常需要指定使用你的mixin的类的(构造函数)依赖关系。你希望将你的mixin限制在一组类中，例如控制器类，并希望访问像当前用户这样的属性，而不强制超状态包含这个属性。特别是如果mixin是从库中导入的，你真的不希望强制库的用户为了使用mixin而改变他的父类结构。

+1 - 我的用例也是关于构造函数依赖注入的。我的混入限制了可能的基类，而那个基类有构造函数依赖。我希望强制混入的子类向构造函数提供正确的依赖项。就像常规(子)类一样。如果受限制的基类的构造函数签名发生变化，那么应该出现编译错误。

我目前使用以下解决方法：

class MyDependency {
}
class MyBaseType {
    // Changing the constructor signature here will not cause an error
    // inside the MyMixin constructor
    constructor(readonly dep: MyDependency) {
    }
}
type Constructor<T extends object> = new (...args: any[]) => T;
type MyBaseTypeConstructor = new (dep: MyDependency) => MyBaseType;
function MyMixin<T extends MyBaseTypeConstructor>(base: T) {
    // Ideally this cast would not be required
    // For now it solves the "Type 'T' is not a constructor function type"
    const baseConstructor: Constructor<MyBaseType> = base;
    return class extends baseConstructor {
        constructor(dep: MyDependency) {
            super(dep); // This call is not type-checked, because of ...any[] rest argument
        }
    };
}
class ExampleUsage extends MyMixin(MyBaseType) {
        constructor(dep: MyDependency) {
            super(dep); // This should be type-checked to be the same signature as MyBaseType
        }
}

使用这个解决方法，仅更改 MyBaseType 构造函数签名就可以得到编译错误(这就是我想要的)。然而，在更改 MyBaseTypeConstructor 为正确签名后，不要忘记更改 MyMixin 构造函数，因为在只更改 MyBaseTypeConstructor 之后，你将不会再收到任何错误。那将是一个问题，因为 MyMixin 的子类应该在这一点上导致编译错误。幸运的是，在更新 MyMixin 内的构造函数后，你会得到剩余的错误，这些错误需要修复。

另一个模式(在JS中)是传递一个包含任何构造函数都可以读取的属性的options对象，而不考虑顺序。super()调用栈中的任何构造函数都可以提取所需的内容。

这很好，大多数情况下它只是工作得很好，只要层次结构中的所有类和mixin都使用单个options参数约定，并且不要在属性名称上发生冲突(这与示例属性/方法名称上的冲突问题相同，因此我们应该努力实现唯一命名)。

使用类型Assert，一切皆有可能😊。这对于mixin的用户来说效果很好(尽管编写mixin有点像黑魔法):

type ComposeConstrucrtor<T, U> = 
    [T, U] extends [new (a: infer O1) => infer R1,new (a: infer O2) => infer R2] ? {
        new (o: O1 & O2): R1 & R2
    } & Pick<T, keyof T> & Pick<U, keyof U> : never
    
function Foo<T extends new (o: any) => any>(Base: T) {
    class Foo extends (Base as new (...a: any[]) => {}) {
        constructor(options: { foo: string }) {
            super(options)
            console.log(options.foo)
        }
        foo() {}
        static foo() {}
    }
    return Foo as ComposeConstrucrtor<typeof Foo, T>
}
function Bar<T extends new (o: any) => any>(Base: T) {
    class Bar extends (Base as new (...a: any[]) => {}) {
        constructor(options: { bar: string }) {
            super(options)
            console.log(options.bar)
        }
        bar() {}
        static bar() {}
    }
    return Bar as ComposeConstrucrtor<typeof Bar, T>
}
class Baz extends Foo(Bar(class { }))  {
    constructor(options: { foo: string, bar: string, whatever: string }) {
        super(options)
        console.log(options.whatever)
    }
    baz() {}
    static baz() {}
}
let baz = new Baz({ bar: "", foo: "", whatever: ""});
baz.bar();
baz.baz();
baz.foo()
Baz.foo();
Baz.bar();
Baz.baz();

@justinfagnani

关于相关问题，你在其他mixin中使用mixin时遇到过问题吗？似乎不起作用，在应用___ is not a constructor function mixin的extends部分时，显示#32004。