Wie übergeben Sie optionale Parameter in TypeScript, während Sie einige andere optionale Parameter auslassen?

Question

die folgende Signatur Gegeben:

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

Wie kann ich die Funktion Fehler() nicht Angabe der Titel Parameter nennen, aber Einstellung autoHideAfter 1000 zu sagen?

Answer 1

Wie in den documentation angegeben verwenden, 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); 

Playground link.

Answer 2

Leider gibt es nichts Vergleichbares in Typoskript (mehr Details hier: https://github.com/Microsoft/TypeScript/issues/467)

Aber, dies zu umgehen Sie Ihre params ändern können eine Schnittstelle sein:

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

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

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

Answer 3

Sie mehrere Methodensignaturen auf der Schnittstelle angeben können dann mehrere Verfahren Überlastungen auf der Klassenmethode:

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 
    } 
} 

Und dies alles funktioniert:

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); 

... und die error Methode von INotificationService wird die folgenden Optionen haben:

Playground

Answer 4

Dies ist fast die gleiche wie @Brocco ‚s Antwort, aber mit einer leichten Drehung: nur optionale Parameter in einem Objekt übergeben. (Und auch params -Objekt optional).

Es endet irgendwie wie Pythons ** Kwargs, aber nicht genau.

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:'); 

Answer 5

Sie können ohne Schnittstelle dies tun.

Verwenden Sie den Operator ? als optionalen Parameter.

Answer 6

können Sie optionale Variable von ? oder wenn Sie durch ... mehrere optionale Variable haben, Beispiel:

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

In der oben:

• name erforderlich ist
• country erforderlich ist und hat einen Standardwert
• address ist optional
• hobbies ein Array von optionalem params ist