TypeScript
Funciones

Observaciones

Parámetros opcionales y predeterminados

Parámetros opcionales

En TypeScript, se supone que cada parámetro es requerido por la función. Usted puede agregar un ? al final de un nombre de parámetro para configurarlo como opcional.

Por ejemplo, el parámetro lastName de esta función es opcional:

function buildName(firstName: string, lastName?: string) {
    // ...
}

Los parámetros opcionales deben venir después de todos los parámetros no opcionales:

function buildName(firstName?: string, lastName: string) // Invalid

Parámetros predeterminados

Si el usuario pasa undefined o no especifica un argumento, se asignará el valor predeterminado. Estos se denominan parámetros inicializados por defecto .

Por ejemplo, "Smith" es el valor predeterminado para el parámetro lastName .

function buildName(firstName: string, lastName = "Smith") {
    // ...
}
buildName('foo', 'bar');      // firstName == 'foo', lastName == 'bar'
buildName('foo');             // firstName == 'foo', lastName == 'Smith'
buildName('foo', undefined);  // firstName == 'foo', lastName == 'Smith'

Tipos de funciones

Funciones nombradas

function multiply(a, b) {
    return a * b;
}

Funciones anonimas

let multiply = function(a, b) { return a * b; };

Funciones Lambda / flecha

let multiply = (a, b) => { return a * b; };

Función como parámetro

Supongamos que queremos recibir una función como parámetro, podemos hacerlo así:

function foo(otherFunc: Function): void {
    ...
}

Si queremos recibir un constructor como parámetro:

function foo(constructorFunc: { new() }) {
    new constructorFunc();
}

function foo(constructorWithParamsFunc: { new(num: number) }) {
    new constructorWithParamsFunc(1);
}

O para facilitar la lectura, podemos definir una interfaz que describa al constructor:

interface IConstructor {
    new();
}

function foo(contructorFunc: IConstructor) { 
    new constructorFunc();
}

O con parámetros:

interface INumberConstructor {
    new(num: number);
}

function foo(contructorFunc: INumberConstructor) {
    new contructorFunc(1);
}

Incluso con los genéricos:

interface ITConstructor<T, U> {
    new(item: T): U;
}

function foo<T, U>(contructorFunc: ITConstructor<T, U>, item: T): U {
    return new contructorFunc(item);
}

Si queremos recibir una función simple y no un constructor es casi lo mismo:

function foo(func: { (): void }) {
    func();
}

function foo(constructorWithParamsFunc: { (num: number): void }) {
    new constructorWithParamsFunc(1);
}

O para facilitar la lectura, podemos definir una interfaz que describa la función:

interface IFunction {
    (): void;
}

function foo(func: IFunction ) { 
    func();
}

O con parámetros:

interface INumberFunction {
    (num: number): string;
}

function foo(func: INumberFunction ) {
    func(1);
}

Incluso con los genéricos:

interface ITFunc<T, U> {
    (item: T): U;
}

function foo<T, U>(contructorFunc: ITFunc<T, U>, item: T): U {
    return func(item);
}

Funciones con tipos de unión

Una función de TypeScript puede admitir parámetros de múltiples tipos predefinidos utilizando tipos de unión.

function whatTime(hour:number|string, minute:number|string):string{
    return hour+':'+minute;
}

whatTime(1,30)         //'1:30'
whatTime('1',30)       //'1:30'
whatTime(1,'30')       //'1:30'
whatTime('1','30')     //'1:30'

Typescript trata estos parámetros como un tipo único que es una unión de los otros tipos, por lo que su función debe ser capaz de manejar parámetros de cualquier tipo que estén en la unión.

function addTen(start:number|string):number{
    if(typeof number === 'string'){
        return parseInt(number)+10;
    }else{
        else return number+10;
    }
}