Введите 'строка | логическое значение не может быть назначено для ввода «никогда» в машинописном тексте

TypeScript не анализирует типы значений свойств, определенных в вашем CreditRiskRatingKeys, чтобы попытаться выяснить, назначаете ли вы правильный тип значения данному свойству.

Одним из решений является введение типа Property, который ограничивает типы значений перечисленных свойств:

export type Property<T, U> = {
  [K in keyof T]: T[K] extends U ? K : never
}[keyof T];

export const CreditRiskRatingKeys: Property<CreditRiskRating, string>[] = [
   'applicant_id'
] as const;

export class CreditRiskRating {
  applicant_id: string = '';

  fillQuestionDictionaryToModel() {
    let f = this[CreditRiskRatingKeys[0]];

    for (const key of CreditRiskRatingKeys) {
      this[key] = 'test';
    }
  }
}

^{Playground link}

Тип keyof CreditRiskRating бывает не только applicant_id, но и fillQuestionDictionaryToModel. В JS нет реального различия между методами и свойствами.

Таким образом, хотя CreditRiskRatingKeys является массивом только со значением applicant_id, в зависимости от типа это может быть массив с 'applicant_id' и/или 'fillQuestionDictionaryToModel'. Таким образом, typeof this[key] может быть либо строкой, либо функцией () => void.

Чтобы решить эту проблему, вы можете создать новый тип утилиты PropertyOf, исключающий методы:

type PropertyOf<T> = {
  [K in keyof T]: T[K] extends Function ? never : K
}[keyof T];

и использовать его как

export const CreditRiskRatingKeys: PropertyOf<CreditRiskRating>[] = [
   'applicant_id'
];

export class CreditRiskRating {
  applicant_id: string = '';


  fillQuestionDictionaryToModel() {
    for (const key of CreditRiskRatingKeys) {
      this[key] = 'test';
    }
  }
}

По сути, вы столкнулись с microsoft/TypeScript#32693 , а также microsoft/TypeScript#58905. См. эти вопросы для получения канонического ответа.

Назначение формы

bar[k] = foo[k]

где Pick<typeof foo, typeof k> присваивается Pick<typeof bar, typeof k> (используя тип утилиты Pick, чтобы сказать, что нас интересуют только свойства foo и bar, которые существуют в ключах типа k), почти наверняка безопасно. Но TypeScript не видит этого в большинстве случаев.

Первая проблема возникает, когда k имеет тип объединения , например "applicant_id" | "is_dirty". TypeScript отслеживает только тип k, а не его идентичность, поэтому, насколько знает TypeScript, вы пишете

bar[k2] = foo[k1]

где k2 и k1 относятся к одному и тому же типу объединения. Это было бы небезопасно, поэтому TypeScript жалуется. Единственный способ, которым такое присвоение может быть безопасным, — это если foo[k1] имеет тип, который работает для всех возможных k2, который будет пересечением соответствующих типов свойств, а не объединением:

interface Foo {
    a: string,
    b: boolean,
}
interface Bar extends Foo {
    c: Date
}
function f(foo: Foo, bar: Bar, k: keyof Foo) {
    bar[k] = foo[k]; // error!
    //~~~~ <-- Type 'string | boolean' is not assignable to type 'never'.
}

Это тема microsoft/TypeScript#32693, и это давняя открытая проблема в TypeScript.

TypeScript разрешает присвоение bar[k] только в том случае, если это значение одновременно является string и boolean. Такого значения нет... другими словами, string & boolean - это невозможное, никогда не набирайте. По сути, это ошибка, которую вы видите.

Рекомендуемый подход — переключиться с ключей с объединением на универсальные ключи. Таким образом, вместо k типа MyKeys у вас должен быть общий тип K extends MyKeys. И если bar и foo — идентичные типы, то это работает:

function g<K extends keyof Foo>(bar: Foo, foo: Foo, k: K) {
    bar[k] = foo[k]; // okay, because bar is a Foo
}

Но если эти два типа различны, даже если они эквивалентны во всем, что имеет значение, вы снова получите ошибку:

function h<K extends keyof Foo>(bar: Bar, foo: Foo, k: K) {
    bar[k] = foo[k]; // error!
    //~~~~ <-- Property 'c' is missing in type 'Foo' but required in type 'Bar'.
}

Это тема microsoft/TypeScript#58905, и это считается ограничением дизайна TypeScript. Обходной путь — синтезировать собственные типы для bar и foo так, чтобы они воспринимались как идентичные. Это можно сделать, просто расширив их до эквивалентов типов Pick. Поскольку каждый Bar также является Foo, мы можем просто расширить bar и оставить foo в покое:

function i<K extends keyof Foo>(bar: Bar, foo: Foo, k: K) {
    const _bar: Foo = bar; // okay
    _bar[k] = foo[k]; // okay
}

Итак, нам нужно сделать вещи универсальными, а типы объектов должны быть идентичными. Выполнение того и другого с вашим кодом выглядит так:

type CreditRiskRatingKey = typeof creditRiskRatingKeys[number];

class CreditRiskRating {
    applicant_id: string = '';
    is_dirty: boolean = false;
    fillQuestionDictionaryToModel() {
        const thiz: typeof dict = this;
        creditRiskRatingKeys.forEach(<K extends CreditRiskRatingKey>(key: K) => {
            thiz[key] = dict[key];
        });
    }

}

Здесь я изменил ваш цикл for...of на общий обратный вызов на forEach() и расширил this до typeof dict перед выполнением задания. Теперь компилируется без ошибок. Досадно преодолевать такие препятствия, но это самое близкое к тому, чтобы TypeScript понимал нашу логику. Если вы не хотите этого делать, вы всегда можете использовать утверждения типа например this[key] = dict[key] as never.

Детская площадка, ссылка на код