Comment passer des paramètres optionnels dans TypeScript tout en omettant d'autres paramètres optionnels?

Malheureusement, il n'y a rien de Tel dans TypeScript (plus de détails ici: https://github.com/Microsoft/TypeScript/issues/467 )

Mais pour contourner cela, vous pouvez changer vos paramètres pour être une interface:

export interface IErrorParams {
  message: string;
  title?: string;
  autoHideAfter?: number;
}

export interface INotificationService {
  error(params: IErrorParams);
}

//then to call it:
error({message: 'msg', autoHideAfter: 42});

, Vous pouvez utiliser la variable optionnelle par ?, ou si vous avez plusieurs variables en option par ..., exemple:

function details(name: string, country="CA", address?: string, ...hobbies: string) {
    // ...
}

Dans ce qui précède:

• {[3] } est obligatoire
• country est obligatoire et a une valeur par défaut
• address est facultatif
• hobbies est un tableau de paramètres optionnels

C'est presque la même chose que la réponse de @Brocco, mais avec une légère torsion: ne passe que des paramètres optionnels dans un objet. (et aussi rendre l'objet params facultatif).

Il finit par être un peu comme les * * kwargs de Python, mais pas exactement.

export interface IErrorParams {
  title?: string;
  autoHideAfter?: number;
}

export interface INotificationService {
  // make params optional so you don't have to pass in an empty object
  // in the case that you don't want any extra params
  error(message: string, params?: IErrorParams);
}

// all of these will work as expected
error('A message with some params but not others:', {autoHideAfter: 42});
error('Another message with some params but not others:', {title: 'StackOverflow'});
error('A message with all params:', {title: 'StackOverflow', autoHideAfter: 42});
error('A message with all params, in a different order:', {autoHideAfter: 42, title: 'StackOverflow'});
error('A message with no params at all:');

, Vous pouvez spécifier plusieurs signatures de méthode sur l'interface, puis plusieurs surcharges de méthode sur la méthode de classe:

interface INotificationService {
    error(message: string, title?: string, autoHideAfter?: number);
    error(message: string, autoHideAfter: number);
}

class MyNotificationService implements INotificationService {
    error(message: string, title?: string, autoHideAfter?: number);
    error(message: string, autoHideAfter?: number);
    error(message: string, param1?: (string|number), param2?: number) {
        var autoHideAfter: number,
            title: string;

        // example of mapping the parameters
        if (param2 != null) {
            autoHideAfter = param2;
            title = <string> param1;
        }
        else if (param1 != null) {
            if (typeof param1 === "string") {
                title = param1;
            }
            else {
                autoHideAfter = param1;
            }
        }

        // use message, autoHideAfter, and title here
    }
}

Maintenant, tout cela va fonctionner:

var service: INotificationService = new MyNotificationService();
service.error("My message");
service.error("My message", 1000);
service.error("My message", "My title");
service.error("My message", "My title", 1000);

...et la méthode error de {[3] } aura les options suivantes:

Aire de Jeux

Vous pouvez le faire sans interface.

class myClass{
  public error(message: string, title?: string, autoHideAfter? : number){
    //....
  }
}

Utilisez l'opérateur ? comme paramètre facultatif.

Vous pouvez essayer de définir title sur null.

Cela a fonctionné pour moi.

Erreur ('ceci est le', null, 1000)

Une autre approche est:

error(message: string, options?: {title?: string, autoHideAfter?: number});

Donc, lorsque vous voulez omettre le paramètre title, envoyez simplement les données comme ceci:

error('the message', { autoHideAfter: 1 })

Je préfère cette option car me permet d'ajouter plus de paramètre sans avoir à envoyer les autres.