Необязательный аргумент функции typescript

TypeScript. Функции

Функции — основные строительные блоки любого приложения, написанного как на JavaScript, так и на TypeScript. Но TypeSript привносит ряд новшеств и упрощает работу с ними.

Создаются функции с помощью ключевого слова function . Они могут быть анонимными или именованными:

// Анонимная функция let sumFunc = function (a, b) < return a + b; >; // Именованная функция function sum(a, b)

Типизация функций

Типы параметров функции

Каждый параметр функции может иметь свой тип, который указывается через знак двоеточия:

function sum(a: number, b: number)

Тип возвращаемого значения

Также в TypeScript можно задать тип значения, которое должна вернуть функция:

function sum(a: number, b: number): number

Полный тип функции

Полный тип функции собственно состоит из типов параметров функции и типа значения, возвращаемого этой функцией:

let sum: (a: number, b: number) => number; sum = function(x: number, y: number): number ; 

При описании полного типа функции тип возвращаемого значения указывается через жирную стрелку => . Названия параметров в строке описания типа функции не имеют значения. Их проверка производится по порядку, и они могут не совпадать с названиями параметров в реализации самой функции. Если функция ничего не возвращает, то указывается тип void .

Компилятор TypeScript может выводить тип из контекста функции и описание типов можно не дублировать:

let sum: (a: number, b: number) => number = function(x, y) ; 

Необязательные параметры функции

TypeScript, в отличие от JavaScript, требует, чтобы при вызове функции число параметров, которые в нее передаются, строго соответствовало числу параметров, описанных в ее типе. В то время как в JS при вызове функции некоторые параметры можно было не указывать, в TS подобное вызовет ошибку. Указать, что параметр является опциональным, можно при описании параметров, добавив в конце названия параметра ? :

function sum(a: number, b: number, c?: number): number < if (c) return a + b + c; else return a + b; >let result; result = sum(1); // Ошибка: не хватает параметров result = sum(1, 2); // OK result = sum(1, 2, 3); // OK result = sum(1, 2, 3, 4); // Ошибка: избыток параметров 

Все опциональные параметры должны следовать за обязательными. Если при вызове функции значение необязательного параметра не задано, то ему будет присвоено значение undefined .

Параметры функции по умолчанию

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

function sum(a: number, b: number, c = 0): number < return a + b + c; >let result; result = sum(1, 2); // 3 result = sum(1, 2, 3); // 6 

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

Остаточные параметры функции

Бывает, что функция должна работать с переменным числом аргументов и заранее это число не известно. А прописывать опциональные параметры на все случаи жизни не разумно. Для таких случаев можно использовать конструкцию остаточных (. rest) параметров:

function sum(a: number, . terms: number[]): number < let s = a; terms.forEach(function(term:number)< s += term; >) return s; > let result; result = sum(1, 2); // 3 result = sum(1, 2, 3, 4, 5); // 15 

Пишем многоточие перед названием последнего параметра terms . При вызове этой функции первое значение будет присвоено параметру a , а все последующие будут записаны в массив с именем terms .

Перегрузка функций

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

Предположим у нас есть функция, которая должна возвращать нам пользователя. Причем по имени пользователя она должна возвращать числовую айдишку, а по id — его имя. Перегрузка такой функции будет выглядеть следующим образом:

function getUser(id: number): string; function getUser(name: string): number; function getUser(value: number|string): string|number < if (typeof value === 'string') < let id: number = getUserByName(value); return id; >else if (typeof value === 'number') < let userName: string = getUserById(value); return userName; >> 

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

Павел Прудников

Постигающий дзен фулстэк вэб буддизма

Поделиться

Подписаться на Блог MEAN stack разработчика

Получайте свежие записи прямо на ваш почтовый ящик.

Или подпишитесь на RSS с Feedly!

Комментарии

TypeScript. Enums (перечисления)

Enum позволяет создать набор числовых значений с собственным именем у каждого элемента. Создаются перечисления с использованием ключевого слова enum.…

TypeScript. Классы

Наконец-таки наследование здорового человека, через классы, а не через ломающие мозг прототипы! Теперь и в JavaScript! Скоро. Но пока…

Источник

Необязательный аргумент функции typescript

В javascript функции определяются с помощью ключевого слова function , например:

function add(a, b) < return a + b; >// использование функции let result1 = add(1, 2); // результат 3 let result2 = add("1", "2"); // результат 12

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

Параметры функции

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

// определение функции function add(a: number, b: number) < let result = a + b; console.log(result); >// вызов функции add(20, 30); // 50 add(10, 15); //25

Однако поскольку параметры имеют тип number, то при вызове функции

компилятор TS выдаст ошибку, так как параметры должны иметь тип number, а не тип string.

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

let koef: number = 1.5; function add(a: number) < let result = a *koef; console.log(result); >add(20); // 30 add(10); //15

Результат функции

Функция может возвращать значение определенного типа, который еще называется типом функции. Возвращаемый тип функции ставится после списка параметров через двоеточие:

function add(a: number, b: number): number < return a + b; >let result = add(1, 2); console.log(result);

В данном случае функция будет возвращать значение типа number .

Если функция ничего не возвращает, то указывается тип void :

function add(a: number, b: number): void < console.log(a + b); >add(10, 20);

В принципе мы можем и не указывать тип, тогда он будет выводиться неявно на основе возвращаемого значения:

function add(a: number, b: number) < return a + b; >let result = add(10, 20);

Необязательные параметры

В typescript при вызове в функцию должно передаваться ровно столько значений, сколько в ней определено параметров:

function getName(firstName: string, lastName: string) < return firstName + " " + lastName; >let name1 = getName("Иван", "Кузнецов"); let name2 = getName("Иван", "Михайлович", "Кузнецов"); //ошибка, много параметров let name3 = getName("Иван"); //ошибка, мало параметров

Чтобы иметь возможность передавать различное число значений в функцию, в TS некоторые параметры можно объявить как необязательные. Необязательные параметры должны быть помечены вопросительным знаком ? . Причем необязательные параметры должны идти после обязательных:

function getName(firstName: string, lastName?: string) < if (lastName) return firstName + " " + lastName; else return firstName; >let name1 = getName("Иван", "Кузнецов"); console.log(name1); // Иван Кузнецов let name2 = getName("Вася"); console.log(name2); // Вася

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

Значения параметров по умолчанию

Параметры позволяют задать начальное значение по умолчанию. И если для такого параметра не передается значение, то он использует значение по умолчанию:

function getName(firstName: string, lastName: string="Иванов") < return firstName + " " + lastName; >let name1 = getName("Иван", "Кузнецов"); console.log(name1); // Иван Кузнецов let name2 = getName("Вася"); console.log(name2); // Вася Иванов

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

function defaultLastName(): string < return "Smith"; >function getName(firstName: string, lastName: string=defaultLastName()) < return firstName + " " + lastName; >let name1 = getName("Tom"); console.log(name1); // Tom Smith

Источник

Функции¶

Система типов TypeScript уделяет большое внимание функциям, ведь они являются основными строительными блоками нашей составной системы.

Описание параметров¶

Конечно, вы можете описывать типы параметров функции так же, как вы можете описываете типы других переменных:

// описание переменной var sampleVariable:  bar: number >; // описание параметра функции function foo(sampleParameter:  bar: number >) <> 

Здесь я использовал встроенные описания типа. Конечно, вы можете использовать интерфейсы и т. д.

Описание типа возврата¶

Вы можете описывать тип того что возвращаете из функции после списка параметров функции тем же стилем, который вы используете для переменной, например, : Foo в следующем примере:

interface Foo  foo: string; > // Тип для описания возвращаемого функцией значения `: Foo` function foo(sample: Foo): Foo  return sample; > 

Да, я использовал здесь интерфейс, но вы можете использовать другие описания, например, встроенные описания.

Как правило, вам не нужно описывать тип возвращаемого функцией значения, так как он может быть автоматически распознан компилятором.

interface Foo  foo: string; > function foo(sample: Foo)  return sample; // распознан тип возвращаемого значения 'Foo' > 

Однако, как правило, рекомендуется добавлять эти описания типов для устранения ошибок, например:

function foo()  return  fou: 'John Doe' >; // Возможно, вы не сможете найти эту опечатку // `foo`, пока не станет слишком поздно > sendAsJSON(foo()); 

Если вы не планируете возвращать что-либо из функции, вы можете описать ее как :void , но как правило вы можете опустить :void .

Необязательные параметры¶

Вы можете пометить параметр как необязательный:

function foo(bar: number, bas?: string): void  // .. > foo(123); foo(123, 'hello'); 

В качестве альтернативы вы можете даже предоставить значение по умолчанию (используя = someValue после объявления параметра), которое будет использоваться если при вызове не было предоставлено иного значения этого параметра:

function foo(bar: number, bas: string = 'hello')  console.log(bar, bas); > foo(123); // 123, hello foo(123, 'world'); // 123, world 

Перегрузки¶

TypeScript позволяет объявлять перегрузки функций. Это полезно для документации + проверки типов. Рассмотрим следующий код:

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

function padding( a: number, b?: number, c?: number, d?: any )  if ( b === undefined && c === undefined && d === undefined )  b = c = d = a; > else if (c === undefined && d === undefined)  c = a; d = b; > return  top: a, right: b, bottom: c, left: d, >; > 

Если вы внимательно посмотрите на код, вы поймете значения a , b , c , d меняются в зависимости от количества переданных параметров. Также функция ожидает только 1 , 2 либо 4 параметра. Эти ограничения могут быть обеспечены и задокументированы с использованием перегрузки функций. По сути через условие вы просто объявляете параметры функции несколько раз. Последние объявленные параметры — это те, которые действительно используются внутри тела функции, но недоступные извне.

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// Перегрузки function padding(all: number); function padding( topAndBottom: number, leftAndRight: number ); function padding( top: number, right: number, bottom: number, left: number ); // Практическая реализация содержащая все случаи, которые должно обрабатывать // тело функции function padding( a: number, b?: number, c?: number, d?: number )  if ( b === undefined && c === undefined && d === undefined )  b = c = d = a; > else if (c === undefined && d === undefined)  c = a; d = b; > return  top: a, right: b, bottom: c, left: d, >; > 

Здесь первые три случая использования параметров доступны как допустимые вызовы padding :

padding(1); // Okay: все padding(1, 1); // Okay: topAndBottom, leftAndRight padding(1, 1, 1, 1); // Okay: top, right, bottom, left padding(1, 1, 1); // Ошибка: Не входит в число доступных перегрузок 

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

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

Источник