Comment passer des paramètres facultatifs tout en omettant certains autres paramètres facultatifs?

Étant donné la signature suivante:

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

Comment puis-je appeler la fonction error() ne spécifiant pas le titleparamètre, mais le réglage autoHideAfterà dire 1000?

Comme spécifié dans la documentation , utilisez undefined:

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

class X {
    error(message: string, title?: string, autoHideAfter?: number) {
        console.log(message, title, autoHideAfter);
    }
}

new X().error("hi there", undefined, 1000);

Lien aire de jeux .

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 facultative par ?ou si vous avez plusieurs variables facultatives par ..., par exemple:

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

Au dessus:

• name est requis
• country est requis et a une valeur par défaut
• address est facultatif
• hobbies est un tableau de paramètres facultatifs

Une autre approche est:

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

Donc, quand vous voulez omettre le paramètre title, envoyez simplement les données comme ça:

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

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

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

Cela 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 avoir 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 fonctionnera:

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 errorméthode de INotificationServiceaura les options suivantes:

Terrain de jeux

Vous pouvez créer une méthode d'assistance qui accepte une base de paramètres d'un objet sur des arguments d'erreur

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

 getError(args: { message: string, title?: string, autoHideAfter?: number }) {
    return error(args.message, args.title, args.autoHideAfter);
 }

Vous pouvez essayer de définir le titre sur null.

Cela a fonctionné pour moi.

error('This is the ',null,1000)

Vous pouvez le faire sans interface.

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

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