TypeScript
Les fonctions

Remarques

Paramètres facultatifs et par défaut

Paramètres facultatifs

Dans TypeScript, chaque paramètre est supposé être requis par la fonction. Vous pouvez ajouter un ? à la fin d'un nom de paramètre pour le définir comme facultatif.

Par exemple, le paramètre lastName de cette fonction est facultatif:

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

Les paramètres facultatifs doivent venir après tous les paramètres non facultatifs:

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

Paramètres par défaut

Si l'utilisateur passe undefined ou ne spécifie pas d'argument, la valeur par défaut sera attribuée. Ce sont les paramètres initialisés par défaut .

Par exemple, "Smith" est la valeur par défaut du paramètre 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'

Types de fonctions

Fonctions nommées

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

Fonctions anonymes

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

Fonctions lambda / flèche

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

Fonction comme paramètre

Supposons que nous voulons recevoir une fonction en tant que paramètre, nous pouvons le faire comme ceci:

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

Si on veut recevoir un constructeur en paramètre:

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

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

Ou pour faciliter la lecture, nous pouvons définir une interface décrivant le constructeur:

interface IConstructor {
    new();
}

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

Ou avec des paramètres:

interface INumberConstructor {
    new(num: number);
}

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

Même avec les génériques:

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

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

Si nous voulons recevoir une fonction simple et non un constructeur, c'est presque pareil:

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

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

Ou pour faciliter la lecture, nous pouvons définir une interface décrivant la fonction:

interface IFunction {
    (): void;
}

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

Ou avec des paramètres:

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

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

Même avec les génériques:

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

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

Fonctions avec types d'union

Une fonction TypeScript peut prendre en compte les paramètres de plusieurs types prédéfinis à l'aide de types d'union.

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 traite ces paramètres comme un type unique qui est une union des autres types, de sorte que votre fonction doit être capable de gérer les paramètres de tout type qui se trouve dans l'union.

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