TypeScript
Funktionen

Bemerkungen

Optionale und Standardparameter

Optionale Parameter

In TypeScript wird davon ausgegangen, dass jeder Parameter von der Funktion benötigt wird. Sie können ein hinzufügen ? am Ende eines Parameternamens, um ihn als optional festzulegen.

Der lastName Parameter dieser Funktion ist beispielsweise optional:

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

Optionale Parameter müssen hinter allen nicht optionalen Parametern stehen:

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

Standardparameter

Wenn der Benutzer undefined übergibt oder kein Argument angibt, wird der Standardwert zugewiesen. Diese Parameter werden als Standardinitialisierungsparameter bezeichnet .

Beispielsweise ist "Smith" der Standardwert für den lastName Parameter.

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'

Arten von Funktionen

Benannte Funktionen

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

Anonyme Funktionen

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

Lambda / Pfeil-Funktionen

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

Funktion als Parameter

Angenommen, wir möchten eine Funktion als Parameter erhalten, können wir dies folgendermaßen tun:

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

Wenn wir einen Konstruktor als Parameter erhalten wollen:

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

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

Oder um das Lesen zu erleichtern, können wir eine Schnittstelle definieren, die den Konstruktor beschreibt:

interface IConstructor {
    new();
}

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

Oder mit Parametern:

interface INumberConstructor {
    new(num: number);
}

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

Auch bei Generika:

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

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

Wenn wir eine einfache Funktion und keinen Konstruktor erhalten wollen, ist das fast dasselbe:

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

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

Oder um das Lesen zu erleichtern, können wir eine Schnittstelle definieren, die die Funktion beschreibt:

interface IFunction {
    (): void;
}

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

Oder mit Parametern:

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

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

Auch bei Generika:

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

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

Funktionen mit Unionstypen

Eine TypeScript-Funktion kann Parameter mehrerer vordefinierter Typen aufnehmen, die Unionstypen verwenden.

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 behandelt diese Parameter als einen einzigen Typ, der eine Vereinigung der anderen Typen darstellt. Ihre Funktion muss daher in der Lage sein, Parameter eines beliebigen Typs zu behandeln, der in der Union enthalten ist.

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