Ist es in Ordnung, Maybe <T> und Ergebnis <T> Typen in Typescript/Javascript zu verwenden?

Question

Es gibt einen guten Mechanismus, um Asycn-Methoden in TS zu verketten: Versprechungen. Sie können do1.then (() => ...). Catch (() => ...).

Aber was zu tun, wenn ich synchrone Methoden verketten möchte? In dieser Frage How to avoid logic duplication when promisifying js methods? war ich Ratschläge nicht zu versprechen, es zu tun.

In C# war ich glücklich, verwenden Sie vielleicht < T> und Ergebnis < T> Klassen, es zu tun. Jede Methode würde eine Klasse Ergebnis zurückgeben. Es würde Methoden haben OnSuccess (Ergebnis der Methode in es) und OnFailure übergeben (Fehler in es).

Mit Nutzung dieser Code Klassen TS aussehen würde:

public processAndDouble(input: number) : number { 
 
    return processData(input) 
 
     .onSuccess((processedInput)=>{ 
 
     return processedInput * 2; 
 
     }) 
 
     .onFailure((error)={ 
 
     return 0; 
 
     }) 
 
} 
 

 
public processData(input: number) : Result<number> { 
 
    if(input >= 0) 
 
    return Result.Ok(input + 1); 
 
    else 
 
    return Result.Fail("can't process negative numbers"); 
 
}

So ist die Frage, ist es in Ordnung, diesen Ansatz zu benutzen?

Widerspricht es nicht einigen Best Practices, Prinzipien?

Answer 1

Es gibt sogar einen besseren Mechanismus, um mit asynchronen Methoden in Typoskript umzugehen: async/await. Also in Ihrem Fall, wenn Sie Ihre Root-Methode definieren zu async, können Sie einfach ‚Kette‘ zusammen synchronisieren und Asynchron-Methoden ohne zusätzliche Kopfschmerzen:

class A 
{ 
    public async processAndDouble(input: number): Promise<number> 
    { 
     try 
     { 
      //Sync method 
      let processedInput = this.processDataSync(input); 
      //Async method 
      processedInput = await this.processDataAsync(processedInput); 
      //Sync operation again 
      return processedInput * 2; 
     } 
     catch (error) 
     { 
      return 0; 
     } 
    } 

    public async processDataAsync(input: number): Promise<number> 
    { 
     if (input >= 0) 
     { 
      //Do your async operation here 
      return input + 1; 
     } 
     else 
     { 
      throw new Error("can't process negative numbers"); 
     } 
    } 

    public processDataSync(input: number): number 
    { 
     if (input >= 0) 
     { 
      return input + 1; 
     } 
     else 
     { 
      throw new Error("can't process negative numbers"); 
     } 
    } 
} 

Beachten Sie, dass intuitiven Mechanismus der Ausnahmen nach wie vor zur Verfügung haben - Es gibt also keine Notwendigkeit, sich mit Erfolg/Ablehnungshandler anzulegen.

Hoffe, das hilft.