TypeScript 4.4 Бета

typescript44Бета

Дэниел

Сегодня мы рады объявить о выпуске бета-версии TypeScript 4.4!

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

 npm install typescript @ beta 

Вы также можете получить поддержку редактора по

Некоторые основные особенности TypeScript 4.4:

Давайте рассмотрим их подробнее!

Анальный поток управления ysis псевдонимов условий

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

анализ потока управления для определения типа в каждой языковой конструкции .

Например, мы можно написать что-то вроде

 
функция foo (
arg : неизвестный
) { если
( тип
arg === "нить" )
{ // Теперь мы знаем, что это строка. приставка . бревно (
arg .
в верхний регистр (
) )
; }
}

В этом Например, мы проверили, arg был нить. TypeScript распознал typeof arg === “строка” проверка, которую он считал охранником типа, и смог чтобы определить, что arg должен быть нить в теле if блок.

Однако что произойдет, если мы переместим преобразовать условие в константу?

  функция   foo   (  arg : неизвестный )   {  const  
argIsString знак равно тип arg === "нить"
; если (
argIsString )
{ приставка
. бревно ( arg . в верхний регистр ( )
)
; // ~~~~~~~~~~~ // Ошибка! Свойство toUpperCase не существует для типа unknown.
} }
 

В предыдущих версиях TypeScript это было бы ошибкой, даже если argIsString было присвоено значение защиты типа, TypeScript просто потерял эту информацию. Это прискорбно, поскольку мы можем захотеть повторно использовать одну и ту же проверку в нескольких местах. Чтобы обойти это, пользователям часто приходится повторяться или использовать утверждения типа (приведение).

В TypeScript 4.4 это уже не так. Приведенный выше пример работает без ошибок! Когда TypeScript видит, что мы тестируем постоянное значение, он проделает небольшую дополнительную работу, чтобы увидеть, содержит ли оно защиту типа. Если защита этого типа работает с const , а только для чтения или неизмененный параметр, TypeScript сможет соответствующим образом сузить это значение. Сохраняются различные типы условий защиты типов, а не только тип чеки. Например, проверки на дискриминируемые союзы работают как чудо.

тип Форма знак равно   |  
{ Добрый: "круг" , радиус: номер
} | { Добрый: "квадрат" , длина стороны: номер }
; функция площадь (форма: Форма) : номер { const
isCircle 05 знак равно форма . Добрый == знак равно "круг" ; если
( - круг
) {
// Мы знаем, что у нас здесь есть круг! возвращение
Математика . ПИ
форма
. радиус
2
; } еще {
// Мы знаем, что здесь остался квадрат! возвращение форма . длина стороны
2 ;
} }

В качестве другого примера рассмотрим функцию, которая проверяет, есть ли у двух входов содержимое.

 
функция doSomeChecks
( inputA : нить | неопределенный , inputB : нить | неопределенный ,
shouldDoExtraWork :
логическое ,
) { позволять mustDoWork знак равно inputA && inputB
&& shouldDoExtraWork
; если ( mustDoWork ) {
// Может получить доступ к свойствам 'string' как для 'inputA', так и 'inputB'! const знак равно
inputA .
в верхний регистр ( )
; const upperB знак равно
inputB .
в верхний регистр (
) ;
// ... } }

TypeScript может понимать, что оба inputA и inputB присутствуют, если mustDoWork является истинный. Это означает, что нам не нужно писать ненулевое утверждение вроде inputA! , чтобы убедить TypeScript, что inputA не неопределенный.

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

функция

f ( Икс: нить | номер | логическое ) { const isString знак равно тип Икс

=== "нить"; const

isNumber знак равно тип Икс === "номер" ; const isStringOrNumber знак равно isString

|| isNumber

; если

( isStringOrNumber

) { Икс ;

// Тип 'x' - 'строка | номер'.

} еще { Икс ; // Тип 'x' является 'логическим'. } }

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

Эта функция должна сделать многие интуитивно понятными JavaScript код «просто работает» в TypeScript, не мешая вам. Для получения более подробной информации реализация на GitHub !

Символ и Подписи индекса шаблона строки шаблона

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

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

интерфейс  Логический словарь  
{ : логическое
; } объявить позволять
myDict : Логический словарь
; // Допустимо для назначения логических значений
myDict ["foo"] знак равно истинный ; myDict ["bar"] знак равно ложный
; // Ошибка, "ой" не логическое myDict
["baz"] знак равно «упс» ;

Пока a Карта могла бы быть лучшей информацией структура здесь (в частности, Карта ), объекты JavaScript часто более удобны в использовании или просто оказываются тем, с чем нам дано работать.

Сходным образом, Множество s уже определяет номер подпись индекса, которая позволяет нам вставлять / извлекать значения типа Т .

 
// Это часть определения TypeScript встроенного типа Array. интерфейс Множество < Т >
{ [index: number] :
Т ; // .. .
} позволять arr знак равно новый Множество < нить
> (
) ; // Действительный
arr [0] знак равно "Привет!" ; // Ошибка, здесь ожидается строковое значение arr
[1] знак равно 617 ;

Индексные подписи очень полезны для выражения большого количества кода в «дикой природе»; однако до сих пор они были ограничены строкой и номер клавиши (и строка подписи индекса имеют намеренную причуду, когда они могут принять номер ключи, так как они все равно будут преобразованы в строки). Это означает, что TypeScript не позволял индексировать объекты с символом TypeScript также не мог смоделировать подпись индекса некоторого подмножества из нить - например, подпись индекса, которая описывает только свойства, имена которых начинаются с текста данные-.

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

Например, TypeScript теперь позволяет нам объявлять тип, который может быть введен в произвольный символ s.

  интерф  туз Цвета 
{ [sym: symbol] : номер; }
const красный знак равно Символ ("красный " ) ; const зеленый знак равно Символ ( "зеленый" )
; const синий знак равно Символ
( "синий"
) ; позволять цвета: Цвета знак равно {
} ; цвета [red] знак равно 696
; // Назначение номера разрешено позволять redVal знак равно цвета
[red] ; // 'redVal 'имеет тип' номер ' цвета [blue] знак равно «да ба ди»
; // Ошибка: тип 'строка' не может быть назначен типу 'номер'.

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

 интерфейс Опции  { ширина ?: номер 
; высота ?: номер ; } позволять a : Опции знак равно { ширина: 342 , высота: 342 ,
"data-blah" : истинный
, // Ошибка! 'data-blah' не был объявлен в 'Параметры'.
} ; интерфейс OptionsWithDataProps расширяется Опции { // Разрешить любое свойство, начинающееся с 'data -'.
[optName: `data-${string}`] : неизвестный ;
} позволять b : OptionsWithDataProps знак равно { ширина: 372
, высота:
372 ,
"data-blah" : истинный
, // Работает!
"неизвестное свойство" : истинный , // Ошибка! 'unknown-property' не было объявлено в 'OptionsWithDataProps'.
} ;
 

Последнее замечание об индексных сигнатурах состоит в том, что теперь они разрешают объединение типов, если они объединяют бесконечные- примитивные типы домена, а именно:

Leave a comment

Your email address will not be published. Required fields are marked *