Тип поля класса на основе универсального

Основная проблема заключается в том, что параметры универсального типа не сужаются с помощью анализа потока управления, что является довольно давней открытой проблемой в TypeScript, см. microsoft / TypeScript # 24085 для получения дополнительной информации.

Когда вы проверяете type в инструкции _2 _ / _ 3_, компилятор может сузить тип переменной type до буквального типа "array", но не сузит параметр типа T до "array". И поэтому он не может проверить, безопасно ли присвоить значение any[] типу AvailableTypes[T]. Компилятору придется провести некоторый анализ, который он в настоящее время не выполняет, например, хорошо, если type === "array", и мы вывели T из типа type, то внутри этого блока case мы можем сузить T до "array", и, следовательно, тип this.value будет AvailableTypes["array"], он же any[], поэтому присвоить ему [] безопасно. Но этого не происходит.

Эта же проблема вызывает ошибку value не определенно назначена. У компилятора нет средств, чтобы увидеть, что _21 _ / _ 22_ исчерпывает все возможности для T, поскольку он не выполняет здесь анализ потока управления.

Самый простой обходной путь здесь - использовать утверждения типа, чтобы сообщить компилятору, что вы знаете, что делаете, поскольку он не может это проверить.

Чтобы справиться с проблемой полноты, вы можете создать default прецедент, который бросает, как в:

class Wrapper<T extends keyof AvailableTypes> {

    private readonly type: T;
    private readonly value: AvailableTypes[T];
    constructor(type: T) {
        this.type = type;

        switch (type) {
            case 'array':
                this.value = [] as AvailableTypes[T]; // assert
                break;
            case 'string':
                this.value = '' as AvailableTypes[T]; // assert
                break;
            case 'object':
                this.value = {} as AvailableTypes[T]; // assert
                break;
            default:
                throw new Error("HOW DID THIS HAPPEN"); // exhaustive
        }
    }
}

или вы можете расширить type с T до keyof AvailableTypes, что позволит компилятору выполнить анализ потока управления, необходимый ему, чтобы понять, что случаи являются исчерпывающими:

class Wrapper<T extends keyof AvailableTypes> {
    private readonly type: T;
    private readonly value: AvailableTypes[T];
    constructor(type: T) {
        this.type = type;
        const _type: keyof AvailableTypes = type; // widen to concrete type
        switch (_type) {
            case 'array':
                this.value = [] as AvailableTypes[T]; // assert
                break;
            case 'string':
                this.value = '' as AvailableTypes[T]; // assert
                break;
            case 'object':
                this.value = {} as AvailableTypes[T]; // assert
                break;
        }
    }
}

Другой обходной путь (упомянут в комментарии человека, который реализовал изменение устойчивости ) состоит в том, чтобы воспользоваться тем фактом, что если у вас есть значение t типа T и ключ k типа K extends keyof T, тогда тип t[k] будет рассматриваться компилятором как T[K]. Итак, если мы можем создать действительный AvailableTypes, мы можем просто проиндексировать его с помощью type. Может быть так:

class Wrapper<T extends keyof AvailableTypes> {
    private readonly type: T
    private readonly value: AvailableTypes[T];
    constructor(type: T) {
        this.type = type;
        const initValues: AvailableTypes = {
            array: [],
            string: "",
            object: {}
        };
        this.value = initValues[type];
    }
}

Это намного лучше, чем утверждения типа и операторы switch, и он довольно безопасен для загрузки. Поэтому я бы выбрал это решение, если это не запрещено вашим вариантом использования.

Хорошо, надеюсь, что это поможет. Удачи!

площадка ссылка на код

обновление: размеченное объединение вместо общих классов