Как получить тип аргумента функции или ее возвращаемый тип?
Очередной странный вопрос. Навеян книгой Discovering Modern C++ Готтшлига. Пытаюсь написать шаблон, который бы возвращал функтор, применяющий некоторую функцию рекурсивно предопределенное количество раз. Примерно так:
Так как использование в духе
душу не греет, сделал такую функцию:
Функция сама по переданным значениям выводит типы, так что можно вычислять как
Но мне не понравилось, что каждый раз создается объект Recurs. . Хотелось бы получать его один раз, и вызывать как функтор — типа,
И вот тут у меня затык. Я написал примерно так —
но что мне теперь писать вместо . . В принципе, меня устроит в данном случае и тип аргумента f , и тип ее возвращаемого значения (для рекурсии они должны совпадать), но как их записать?
И еще — насколько я помню, decltype(auto) — это уже C++14. А можно ли такое сотворить на версиях языка помладше, и как?
Карманная книга по TypeScript. Часть 4. Подробнее о функциях
Обратите внимание: для большого удобства в изучении книга была оформлена в виде прогрессивного веб-приложения.
Функции — это основные строительные блоки любого приложения, будь то функции, импортируемые из другого модуля, или методы класса. В TS существует несколько способов описания того, как фукнции вызываются.
Тип функции в форме выражения (function type expressions)
Простейшим способом описания типа функции является выражение. Такие типы похожи на стрелочные функции:
Выражение (a: string) => void означает «функция с одним параметром a типа string , которая ничего не возвращает». Как и в случае с определением функции, если тип параметра не указан, он будет иметь значение any .
Обратите внимание: название параметра является обязательным. Тип функции (string) => void означает «функция с параметром string типа any «!
Разумеется, для типа функции можно использовать синоним:
Сигнатуры вызова (call signatures)
В JS функции, кроме того, что являются вызываемыми (callable), могут иметь свойства. Однако, тип-выражение не позволяет определять свойства функции. Для описания вызываемой сущности (entity), обладающей некоторыми свойствами, можно использовать сигнатуру вызова (call signature) в объектном типе:
Обратите внимание: данный синтаксис немного отличается от типа-выражения функции — между параметрами и возвращаемым значением используется : вместо => .
Сигнатуры конструктора (construct signatures)
Как известно, функции могут вызываться с ключевым словом new . TS считает такие функции конструкторами, поскольку они, как правило, используются для создания объектов. Для определения типов таких функций используется сигнатура конструктора:
Некоторые объекты, такие, например, как объект Date , могут вызываться как с, так и без new . Сигнатуры вызова и конструктора можно использовать совместно:
Общие функции или функции-дженерики (generic functions)
Часто тип данных, возвращаемых функцией, зависит от типа передаваемого функции аргумента или же два типа возвращаемых функцией значений зависят друг от друга. Рассмотрим функцию, возвращающую первый элемент массива:
Функция делают свою работу, но, к сожалению, типом возвращаемого значения является any . Было бы лучше, если бы функция возвращала тип элемента массива.
В TS общие типы или дженерики (generics) используются для описания связи между двумя значениями. Это делается с помощью определения параметра Type в сигнатуре функции:
Добавив параметр Type и использовав его в двух местах, мы создали связь между входящими данными функции (массивом) и ее выходными данными (возвращаемым значением). Теперь при вызове функции возвращается более конкретный тип:
Предположение типа (inference)
Мы можем использовать несколько параметров типа. Например, самописная версия функции map может выглядеть так:
Обратите внимание, что в приведенном примере TS может сделать вывод относительно типа Input на основе переданного string[] , а относительно типа Output на основе возвращаемого number .
Ограничения (constraints)
Ограничение, как следует из названия, используется для ограничения типов, принимаемых параметром типа.
Реализуем функцию, возвращающую самое длинное из двух значений. Для этого нам потребуется свойство length , которое будет числом. Мы ограничим параметр типа типом number с помощью ключевого слова extends :
Мы позволяем TS предполагать тип значения, возвращаемого из функции longest .
Поскольку мы свели Type к < length: number >, то получили доступ к свойству length параметров a и b . Без ограничения типа у нас бы не было такого доступа, потому что значения этих свойств могли бы иметь другой тип — без длины.
Типы longerArr и longerStr были выведены на основе аргументов. Запомните, дженерики определяют связь между двумя и более значениями одного типа!
Наконец, как мы и ожидали, вызов longest(10, 100) отклоняется, поскольку тип number не имеет свойства length .
Работа с ограниченными значениями
Вот пример распространенной ошибки, возникающей при работе с ограничениями дженериков:
На первый взгляд может показаться, что все в порядке — Type сведен к < length: number >, и функция возвращает либо Type , либо значение, совпадающее с ограничением. Проблема состоит в том, что функция может вернуть объект, идентичный тому, который ей передается, а не просто объект, совпадающий с ограничением. Если бы во время компиляции не возникло ошибки, мы могли бы написать что-то вроде этого:
Определение типа аргументов
Обычно, TS делает правильные выводы относительно типов аргументов в вызове дженерика, но так бывает не всегда. Допустим, мы реализовали такую функцию для объединения двух массивов:
При обычном вызове данной функции с несовпадающими по типу массивами возникает ошибка:
Однако, мы можем вручную определить Type , и тогда все будет в порядке:
Руководство по написанию хороших функций-дженериков
Используйте параметры типа без ограничений
Рассмотрим две похожие функции:
Предполагаемым типом значения, возвращаемого функцией firstElement1 является Type , а значения, возвращаемого функцией firstElement2 — any . Это объясняется тем, что TS разрешает (resolve) выражение arr[0] с помощью ограничения типа вместо того, чтобы ждать разрешения элемента после вызова функции.
Правило: по-возможности, используйте параметры типа без ограничений.
Используйте минимальное количество параметров типа
Вот еще одна парочка похожих функций:
Во втором случае мы создаем параметр типа Func , который не связывает значения. Это означает, что при вызове функции придется определять дополнительный аргумент типа без веских на то причин. Это не есть хорошо.
Правило: всегда используйте минимальное количество параметров типа.
Параметры типа должны указываться дважды
Иногда мы забываем, что функция не обязательно должна быть дженериком:
Вот упрощенная версия данной функции:
Запомните, параметры типа предназначены для связывания типов нескольких значений.
Правило: если параметр типа появляется в сигнатуре функции только один раз, то, скорее всего, он вам не нужен.
Опциональные параметры (optional parameters)
Функции в JS могут принимать произвольное количество аргументов. Например, метод toFixed принимает опциональное количество цифр после запятой:
Мы можем смоделировать это в TS , пометив параметр как опциональный с помощью ? :
Несмотря на то, что тип параметра определен как number , параметр x на самом деле имеет тип number | undefined , поскольку неопределенные параметры в JS получают значение undefined .
Мы также можем указать «дефолтный» параметр (параметр по умолчанию):
Теперь в теле функции f параметр x будет иметь тип number , поскольку любой аргумент со значением undefined будет заменен на 10 . Обратите внимание: явная передача undefined означает «отсутствующий» аргумент.
Опциональные параметры в функциях обратного вызова
При написании функций, вызывающих «колбеки», легко допустить такую ошибку:
Указав index? , мы хотим, чтобы оба этих вызова были легальными:
В действительности, это означает, что колбек может быть вызван с одним аргументом. Другими словами, определение функции говорит, что ее реализация может выглядеть так:
Поэтому попытка вызова такой функции приводит к ошибке:
В JS при вызове функции с большим (ударение на первый слог) количеством аргументов, чем указано в определении фукнции, дополнительные параметры просто игнорируются. TS ведет себя аналогичным образом. Функции с меньшим количеством параметров (одного типа) могут заменять функции с большим количеством параметров.
Правило: при написании типа функции для колбека, не указывайте опциональные параметры до тех пор, пока не будете вызывать функцию без передачи этих параметров.
Перегрузка функции (function overload)
Некоторые функции могут вызываться с разным количеством аргументов. Например, мы можем написать функцию, возвращающую Date , которая принимает время в мс (timestamp, один аргумент) или день/месяц/год (три аргумента).
В TS такую функцию можно реализовать с помощью сигнатур перегрузки (overload signatures). Для этого перед телом функции указывается несколько ее сигнатур:
В приведенном примере мы реализовали две перегрузки: одну, принимающую один аргумент, и вторую, принимающую три аргумента. Первые две сигнатуры называются сигнатурами перегрузки.
Затем мы реализовали функцию с совместимой сигнатурой (compatible signature). Функции имеют сигнатуру реализации (implementation signature), но эта сигнатура не может вызываться напрямую. Несмотря на то, что мы написали функцию с двумя опциональными параметрами после обязательного, она не может вызываться с двумя параметрами!
Сигнатуры перегрузки и сигнатура реализации
Предположим, что у нас имеется такой код:
Почему в данном случае возникает ошибка? Дело в том, что сигнатура реализации не видна снаружи (за пределами тела функции). Поэтому при написании перегруженной функции всегда нужно указывать две или более сигнатуры перегрузки перед сигнатурой реализации.
Кроме того, сигнатура реализации должна быть совместима с сигнатурами перегрузки. Например, при вызове следующих функций возникают ошибки, поскольку сигнатура реализации не совпадает с сигнатурами перегрузки:
Правила реализации хороших перегрузок функции
Рассмотрим функцию, возвращающую длину строки или массива:
На первый взгляд кажется, что все в порядке. Мы можем вызывать функцию со строками или массивами. Однако, мы не можем вызывать ее со значением, которое может быть либо строкой, либо массивом, поскольку TS ассоциирует вызов функции с одной из ее перегрузок:
Поскольку обе перегрузки имеют одинаковое количество аргументов и один и тот же тип возвращаемого значения, мы можем реализовать такую «неперегруженную» версию данной функции:
Так намного лучше! Теперь мы можем вызывать функцию с любым значением и, кроме того, нам не нужно предварительно определять правильную сигнатуру реализации функцию.
Правило: по-возможности используйте объединения вместо перегрузок функции.
Определение this в функциях
TS «понимает», что значением this функции user.becomeAdmin является внешний объект user . В большинстве случаев этого достаточно, но порой нам требуется больше контроля над тем, что представляет собой this . Спецификация JS определяет, что мы не можем использовать this в качестве названия параметра. TS использует это синтаксическое пространство (syntax space), позволяя определять тип this в теле функции:
Обратите внимание: в данном случае мы не можем использовать стрелочную функцию.
Другие типы, о которых следует знать
void представляет значение, возвращаемое функцией, которая ничего не возвращает. Если в теле функции отсутствует оператор return или после этого оператора не указано возвращаемого значения, предполагаемым типом возвращаемого такой функцией значения будет void :
В JS функция, которая ничего не возвращает, «неявно» возвращает undefined . Однако, в TS void и undefined — это разные вещи.
Обратите внимание: void — это не тоже самое, что undefined .
object
Специальный тип object представляет значение, которое не является примитивом ( string, number, boolean, symbol, null, undefined ). object отличается от типа пустого объекта ( <> ), а также от глобального типа Object . Скорее всего, вам никогда не потребуется использовать Object .
Правило: object — это не Object . Всегда используйте object !
Обратите внимание: в JS функции — это объекты: они имеют свойства, Object.prototype в цепочке прототипов, являются instanceof Object , мы можем вызывать на них Object.keys и т.д. По этой причине в TS типом функций является object .
unknown
Тип unknown представляет любое значение. Он похож на тип any , но является более безопасным, поскольку не позволяет ничего делать с неизвестным значением:
Это бывает полезным для описания типа функции, поскольку таким способом мы можем описать функцию, принимающую любое значение без использования типа any в теле функции. Другими словами, мы можем описать функцию, возвращающую значение неизвестного типа:
never
Некоторые функции никогда не возвращают значений:
Тип never представляет значение, которого не существует. Чаще всего, это означает, что функция выбрасывает исключение или останавливает выполнение программы.
never также появляется, когда TS определяет, что в объединении больше ничего не осталось:
Function
Глобальный тип Function описывает такие свойства как bind , call , apply и другие, характерные для функций в JS . Он также имеет специальное свойство, позволяющее вызывать значения типа Function — такие вызовы возвращают any :
Такой вызов функции называется нетипизированным и его лучше избегать из-за небезопасного возвращаемого типа any .
Если имеется необходимость принимать произвольную функцию без ее последующего вызова, лучше предпочесть более безопасный тип () => void .
Оставшиеся параметры и аргументы
Оставшиеся параметры (rest parameters)
Кроме использования опциональных параметров или перегрузок для создания функций, принимающих разное или фиксированное количество аргументов, мы можем определять функции, принимающие произвольное количество аргументов с помощью синтаксиса оставшихся параметров.
Оставшиеся параметры указываются после других параметров с помощью . :
В TS неявным типом таких параметров является any[] , а не any . Любая аннотация типа для них должна иметь вид Array<T> или T[] , или являться кортежем.
Оставшиеся аргументы (rest arguments)
Синтаксис распространения (синонимы: расширение, распаковка) (spread syntax) позволяет передавать произвольное количество элементов массива. Например, метод массива push принимает любое количество аргументов:
Обратите внимание: TS не считает массивы иммутабельными. Это может привести к неожиданному поведению:
Самым простым решением данной проблемы является использование const :
Деструктуризация параметров (parameter destructuring)
Деструктуризация параметров используется для распаковки объекта, переданного в качестве аргумента, в одну или более локальную переменную в теле функции. В JS это выглядит так:
Аннотация типа для объекта указывается после деструктуризации:
Для краткости можно использовать именованный тип:
Возможность присвоения функций переменным
Использование void в качестве типа возвращаемого функцией значения может приводить к необычному, но вполне ожидаемому поведению.
Контекстуальная типизация (contextual typing), основанная на void , не запрещает функции что-либо возвращать. Другими словами, функция, типом возвращаемого значения которой является void — type vf = () => void , может возвращать любое значение, но это значение будет игнорироваться.
Все приведенные ниже реализации типа () => void являются валидными:
Когда возвращаемое любой из этих функций значение присваивается переменной, она будет хранить тип void :
Поэтому следующий код является валидным, несмотря на то, что Array.prototype.push возвращает число, а Array.prototype.forEach ожидает получить функцию с типом возвращаемого значения void :
Существует один специальный случай, о котором следует помнить: когда литеральное определение функции имеет тип возвращаемого значения void , функция не должна ничего возвращать:
Облачные серверы от Маклауд быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
Как получить тип возвращаемого значения функции
В прошлой теме была определена функция factorial, которая в качестве возвращаемого типа имела тип void , то есть по факту ничего не возвращает:
Хотя эта функция не использует явно оператор return , но компилятор сам его добавляет автоматически в конец функции:
Эти оба определения фактически равнозначны.
Но также функция может возвращать какое-то конкретное значение. Например, изменим функцию factorial, чтобы она возвращала вычисляемое значение:
Теперь функция factorial в качестве возвращаемого типа имеет тип int . Если тип функции отличен от void , то функция обязательно должна возвращать значение данного типа. Для возвращения значения применяется оператор return , после которого указывается возвращаемое значение.
В данном случае функция factorial возвращает значение переменно result, которая содержит факториал числа.
Если функция возвращает какое-либо значение, то при ее вызове мы можем получить это значение в переменную:
Как и в случае с параметрами и аргументами функции возвращаемое значение должно соответствовать типу функции. Если подобного соответствия нет, компилятор пытается выполнить преобразование возвращаемого значения к типу функции:
В данном случае функция exchange возвращает объект типа int , но возвращаемое значение, описываемое выражением sum/rate будет представлять тип double , поэтому в данном случае компилятор автоматически выполнит преобразование: