TypeScript
functies

Opmerkingen

Optionele en standaardparameters

Optionele parameters

In TypeScript wordt ervan uitgegaan dat elke parameter vereist is voor de functie. U kunt een toevoegen ? aan het einde van een parameternaam om deze als optioneel in te stellen.

De parameter lastName van deze functie is bijvoorbeeld optioneel:

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

Optionele parameters moeten achter alle niet-optionele parameters komen:

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

Standaard parameters

Als de gebruiker undefined doorgeeft of geen argument opgeeft, wordt de standaardwaarde toegewezen. Dit worden standaard-geïnitialiseerde parameters genoemd.

"Smith" is bijvoorbeeld de standaardwaarde voor de parameter 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'

Soorten functies

Benoemde functies

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

Anonieme functies

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

Lambda / pijl-functies

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

Functie als parameter

Stel dat we een functie als parameter willen ontvangen, we kunnen het zo doen:

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

Als we een constructor als parameter willen ontvangen:

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

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

Of om het gemakkelijker te kunnen lezen, kunnen we een interface definiëren die de constructor beschrijft:

interface IConstructor {
    new();
}

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

Of met parameters:

interface INumberConstructor {
    new(num: number);
}

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

Zelfs met generieke geneesmiddelen:

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

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

Als we een eenvoudige functie willen ontvangen en geen constructor, is het bijna hetzelfde:

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

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

Of om het gemakkelijker te kunnen lezen, kunnen we een interface definiëren die de functie beschrijft:

interface IFunction {
    (): void;
}

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

Of met parameters:

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

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

Zelfs met generieke geneesmiddelen:

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

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

Functies met Union-typen

Een TypeScript-functie kan parameters van meerdere, vooraf gedefinieerde typen opnemen met behulp van unietypes.

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 deze parameters als een enkel type dat een unie van de andere typen is, dus uw functie moet in staat zijn om parameters van elk type dat zich in de unie bevindt te kunnen verwerken.

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