Как предотвратить ошибку «Индексная сигнатура типа объекта неявно имеет тип« любой »» при компиляции машинописи с включенным флагом noImplicitAny?

Я всегда компилирую Typescript с флагом --noImplicitAny. Это имеет смысл, поскольку я хочу, чтобы моя проверка типов была как можно более строгой.

Моя проблема в том, что с помощью следующего кода я получаю сообщение об ошибке Index signature of object type implicitly has an 'any' type:

interface ISomeObject {
    firstKey:   string;
    secondKey:  string;
    thirdKey:   string;
}

let someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue'
};

let key: string = 'secondKey';

let secondValue: string = someObject[key];

Важно отметить, что идея заключается в том, что переменная ключа происходит из другого места в приложении и может быть любым из ключей в объекте.

Я попытался явно привести тип:

let secondValue: string = <string>someObject[key];

Или мой сценарий просто невозможен --noImplicitAny?

Добавление подписи индекса позволит TypeScript знать, каким должен быть тип.

В вашем случае это было бы [key: string]: string;

interface ISomeObject {
    firstKey:      string;
    secondKey:     string;
    thirdKey:      string;
    [key: string]: string;
}

Однако это также заставляет все типы свойств соответствовать сигнатуре индекса. Поскольку все свойства stringэто работает.

Хотя подписи индекса являются мощным способом описания массива и шаблона «словаря», они также обеспечивают соответствие всех свойств их возвращаемому типу.

Редактировать:

Если типы не совпадают, можно использовать тип объединения [key: string]: string|IOtherObject;

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

// Type of `secondValue` is `string|IOtherObject`
let secondValue = someObject[key];
// Type of `foo` is `string`
let foo = secondValue + '';

Хотя это может стать немного запутанным, если у вас много разных типов в сигнатурах индекса. Альтернативой этому является использование anyв подписи. [key: string]: any;Тогда вам нужно будет разыграть типы, как вы делали выше.

Другой способ избежать ошибки - использовать приведение типа этого:

let secondValue: string = (<any>someObject)[key]; (Обратите внимание на круглые скобки)

Единственная проблема заключается в том, что это больше не является типобезопасным, как вы используете any. Но вы всегда можете привести к правильному типу.

PS: я использую машинопись 1.7, не уверен насчет предыдущих версий.

В TypeScript 2.1 представлен элегантный способ решения этой проблемы.

const key: (keyof ISomeObject) = 'secondKey';
const secondValue: string = someObject[key];

Мы можем получить доступ ко всем именам свойств объекта на этапе компиляции по keyofключевому слову (см. Список изменений ).

Вам нужно только заменить stringтип переменной на keyof ISomeObject. Теперь компилятор знает, что keyпеременная может содержать только имена свойств из ISomeObject.

Полный пример:

interface ISomeObject {
    firstKey:   string;
    secondKey:  string;
    thirdKey:   number;
}

const someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   3
};

const key: (keyof ISomeObject) = 'secondKey';
const secondValue: string = someObject[key];

// You can mix types in interface, keyof will know which types you refer to.
const keyNumber: (keyof ISomeObject) = 'thirdKey';
const numberValue: number = someObject[keyNumber];

Живой код на typescriptlang.org (установить noImplicitAnyопцию)

Дальнейшее чтение с большим количеством keyofиспользования .

Следующая настройка tsconfig позволит вам игнорировать эти ошибки - установите для нее значение true.

suppressImplicitAnyIndexErrors

Подавлять ошибки noImplicitAny для объектов индексации, в которых отсутствуют подписи индекса.

Решение «keyof», упомянутое выше, работает. Но если переменная используется только один раз, например, циклически проходя по объекту и т. Д., Вы также можете ввести ее.

for (const key in someObject) {
    sampleObject[key] = someObject[key as keyof ISomeObject];
}

использование keyof typeof

const cat = {
    name: 'tuntun'
}

const key: string = 'name' 

cat[key as keyof typeof cat]

Похоже на ответ @Piotr Lewandowski, но в пределах forEach:

const config: MyConfig = { ... };

Object.keys(config)
  .forEach((key: keyof MyConfig) => {
    if (config[key]) {
      // ...
    }
  });

Объявите объект следующим образом.

export interface Thread {
    id:number;
    messageIds: number[];
    participants: {
        [key:number]: number
    };
}

Нет индексатора? Тогда сделай свой собственный!

Я глобально определил это как простой способ определить сигнатуру объекта. Tможно anyпри необходимости:

type Indexer<T> = { [ key: string ]: T };

Я просто добавляю indexerкак ученик.

indexer = this as unknown as Indexer<Fruit>;

Итак, я в конечном итоге с этим:

constructor(private breakpointResponsiveService: FeatureBoxBreakpointResponsiveService) {

}

apple: Fruit<string>;
pear: Fruit<string>;

// just a reference to 'this' at runtime
indexer = this as unknown as Indexer<Fruit>;

something() {

    this.indexer['apple'] = ...    // typed as Fruit

Преимущество этого состоит в том, что вы получаете правильный тип - многие решения, которые используют <any>, потеряют типизацию для вас. Помните, что это не выполняет никакой проверки во время выполнения. Вам все равно нужно будет проверить, существует ли что-то, если вы точно не знаете, существует ли оно.

Если вы хотите быть чрезмерно осторожным и используете его, strictвы можете сделать это, чтобы выявить все места, которые вам могут понадобиться для явной неопределенной проверки:

type OptionalIndexed<T> = { [ key: string ]: T | undefined };

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

Я нашел этот метод особенно полезным, если у меня много кода, необходимого для доступа к индексатору, и типизацию можно изменить только в одном месте.

Примечание: я использую strictрежим, и unknownэто определенно необходимо.

Скомпилированный код будет просто indexer = thisтак, поэтому он очень похож на то, когда _this = thisдля вас создает машинопись .

Создайте интерфейс для определения интерфейса индексатора

Затем создайте свой объект с этим индексом.

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

Вы можете сделать параметр универсального типа любым необходимым: ObjectIndexer< Dog | Cat>

// this should be global somewhere, or you may already be 
// using a library that provides such a type
export interface ObjectIndexer<T> {
  [id: string]: T;
}

interface ISomeObject extends ObjectIndexer<string>
{
    firstKey:   string;
    secondKey:  string;
    thirdKey:   string;
}

let someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue'
};

let key: string = 'secondKey';

let secondValue: string = someObject[key];

Машинопись детская площадка

Вы даже можете использовать это в универсальном ограничении при определении универсального типа:

export class SmartFormGroup<T extends IndexableObject<any>> extends FormGroup

Тогда Tвнутри класса можно проиндексировать :-)

Объявите тип, ключ которого является строковым, а значение может быть любым, затем объявите объект с этим типом, и lint не будет отображаться

type MyType = {[key: string]: any};

Так твой код будет

type ISomeType = {[key: string]: any};

    let someObject: ISomeType = {
        firstKey:   'firstValue',
        secondKey:  'secondValue',
        thirdKey:   'thirdValue'
    };

    let key: string = 'secondKey';

    let secondValue: string = someObject[key];

На сегодняшний день лучшим решением является объявление типов. подобно

enum SomeObjectKeys {
    firstKey = 'firstKey',
    secondKey = 'secondKey',
    thirdKey = 'thirdKey',
}

let someObject: Record<SomeObjectKeys, string> = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue',
};

let key: SomeObjectKeys = 'secondKey';

let secondValue: string = someObject[key];

Простейшее решение, которое я смог найти с помощью Typescript 3.1 в 3 этапа:

1) Сделать интерфейс

interface IOriginal {
    original: { [key: string]: any }
}

2) Сделайте печатную копию

let copy: IOriginal = (original as any)[key];

3) Использовать везде (в комплекте JSX)

<input customProp={copy} />