Перейти к содержанию

Логический вывод типа в TypeScript

TypeScript может логически вывести (а затем проверить) тип переменной на основе нескольких простых правил. Потому как эти правила просты, вы можете научить свой мозг распознавать безопасный / небезопасный код (это случилось со мной и моими товарищами по команде довольно быстро).

Поток типов - это то, как я представляю себе в уме распространение информации о типах.

Определение переменной

Типы переменной определяются по её определению.

let foo = 123; // foo `число`
let bar = 'Hello'; // bar `строка`
foo = bar; // Ошибка: невозможно `строке` присвоить `число`

Это пример типов, распространяющихся справа налево.

Типы значений возвращаемых функцией

Тип возвращаемого значения определяется инструкцией возврата, например, предполагается, что следующая функция возвращает число.

function add(a: number, b: number) {
    return a + b;
}

Это пример типов, распространяющихся снизу вверх.

Присвоение

Тип параметров функции / возвращаемых значений также может быть определен посредством присваивания, например, здесь мы говорим, что foo является сумматором, и это делает a и b типом число.

type Adder = (a: number, b: number) => number;
let foo: Adder = (a, b) => a + b;

Этот факт может быть продемонстрирован с помощью приведенного ниже кода, который вызывает ошибку, как можно было и ожидать:

type Adder = (a: number, b: number) => number;
let foo: Adder = (a, b) => {
    a = 'hello'; // Ошибка: невозможно `строке` присвоить `число`
    return a + b;
};

Это пример типов, распространяющихся слева направо.

Логический вывод типов срабатывает с этим же стилем присвоения, если вы создаете функцию с параметром в виде колбэка. В конце концов, argument -> parameter - это просто еще одна форма присвоения переменных.

type Adder = (a: number, b: number) => number;
function iTakeAnAdder(adder: Adder) {
    return adder(1, 2);
}
iTakeAnAdder((a, b) => {
    // a = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`
    return a + b;
});

Структурирование

Эти простые правила также работают при использовании структурирования (создание литерала объекта). Например, в следующем случае тип foo определяется как {a:number, b:number}

let foo = {
    a: 123,
    b: 456,
};
// foo.a = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`

Аналогично для массивов:

const bar = [1, 2, 3];
// bar[0] = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`

Ну и конечно же любое вложение:

let foo = {
    bar: [1, 3, 4],
};
// foo.bar[0] = 'hello'; // Будет ошибка: невозможно `строке` присвоить `число`

Деструктуризация

И, конечно же, они также работают с деструктуризацией, оба:

let foo = {
    a: 123,
    b: 456,
};
let { a } = foo;
// a = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`

и массивы:

const bar = [1, 2];
let [a, b] = bar;
// a = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`

И если параметр функции может быть логически выведен, то могут и его деструктурированные свойства. Например, здесь мы деструктурируем параметр на a/b.

type Adder = (numbers: { a: number; b: number }) => number;
function iTakeAnAdder(adder: Adder) {
    return adder({ a: 1, b: 2 });
}
iTakeAnAdder(({ a, b }) => {
    // Типы `a` и` b` логически выводятся
    // a = "hello"; // Будет ошибка: невозможно `строке` присвоить `число`
    return a + b;
});

Защита типа

Мы уже видели, как Защита типа помогает изменять и уточнять типы (особенно в случае объединений). Защиты типов - это просто еще одна форма логического вывода типа для переменной в блоке.

Предупреждения

Будьте осторожны с параметрами

Типы не распространяются в параметры функции, если они не могут быть логически выведены из присвоения. Например, в следующем случае компилятор не знает тип foo, поэтому он не может определить тип a или b.

const foo = (a, b) => {
    /* сделать что-нибудь */
};

Однако, если был введен foo, тип параметров функции может быть логически выведен (a,b оба выведены как имеющие тип number в примере ниже).

type TwoNumberFunction = (a: number, b: number) => void;
const foo: TwoNumberFunction = (a, b) => {
    /* сделать что-нибудь */
};

Будьте осторожны с возвращаемыми значениями

Хотя TypeScript может обычно логически выводить тип возвращаемого значения функции, он может не соответствовать ожидаемому. Например, здесь функция foo имеет тип возврата any.

function foo(a: number, b: number) {
    return a + addOne(b);
}
// Какая-то внешняя функция в библиотеке, которую кто-то написал в JavaScript
function addOne(c) {
    return c + 1;
}

Это связано с тем, что на возвращаемый тип влияет плохое определение типа для addOne (c равно any, поэтому возвращаемое от addIn равно any, поэтому отсюда и foo равно any).

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

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

noImplicitAny

Флаг noImplicitAny указывает компилятору выдавать ошибку, если он не может определить тип переменной (и, следовательно, может иметь ее только как неявный any тип). Далее вы сможете

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