So strukturieren Sie die Utility-Klasse

Ich habe mehrere Dienstprogrammfunktionen. Was ist der beste Weg, um diese zu verpacken und dann zu importieren?

Das versuche ich zu tun:

import * as util from './util'

export class myClass{
     constructor()
     {
           util.doSomething("test");
     }
}

Dann in der Klasse:

export class Util{
    doSomething(val: string){ return val;}

    doSomethingElse(val: string{ return val;}
}

Die Fehlermeldung, die ich von VS erhalte, lautet:

Property doSomething does not exist on type util.

Wenn Sie eine Datei erstellen, utils.tsdie enthält

export default class Utils {
    static doSomething(val: string) { return val; }
    static doSomethingElse(val: string) { return val; }
}

Dann können Sie Ihren Client-Code folgendermaßen vereinfachen:

import Utils from './utils'

export class MyClass {
     constructor()
     {
         Utils.doSomething("test");
     }
}

Hier gibt es ein paar Probleme:

1. Sie instanziieren nichts und doSomethingsind eine Instanzmethode
2. Wenn Sie dies tun import * as util, wird utildas Modul dargestellt, kein Objekt darin.

Wenn Sie möchten Util, sollten Sie einfach Folgendes importieren:

import { Util } from './util'

Als nächstes sollten Sie instanziieren Util, bevor Sie die Methode darauf aufrufen:

var u = new Util();
u.doSomething("test");

Hier ist Ihr Code gepatcht:

import { Util } from './util'

export class MyClass{
     constructor()
     {
         var u = new Util();
         u.doSomething("test");
     }
}

Alles in allem scheint die Art und Weise, wie Sie Ihre Utensilien verwenden, etwas Seltsames zu sein. Dies ist eine ganz persönliche Meinung, aber ich würde keine Methoden aufrufen, die in einem Konstruktor "etwas tun", dh Nebenwirkungen verursachen.

Außerdem sehen die Methoden in Utilnicht wirklich so aus, als müssten sie in dieser Klasse sein, da die Klasse keinen Status hat, von dem sie abhängen. Sie können jederzeit reguläre Funktionen aus einem Modul exportieren. Wenn Sie Ihr Utils-Modul folgendermaßen geschrieben haben:

export function doSomething(val: string) { return val; }

export function doSomethingElse(val: string) { return val; }

Sie würden Ihre Funktionen direkt exportieren und den Instanziierungsaufwand umgehen, und tatsächlich würde Ihr ursprünglicher Code so wie er ist korrekt funktionieren.

Alternativer Weg:

1. Exportieren Sie Konstanten in Ihre utils.tsDatei:

   export const doSomething = (val: string): any => {
     return val;
   };
   
   export const doSomethingElse = (val: string): any => {
     return val;
   };
   

2. Importieren und verwenden Sie diese Methoden in der Hauptdatei *.ts:

   import { doSomething, doSomethingElse } from './util';
   ...
   let value1 = doSomething('abc');
   let value2 = doSomethingElse ('efg');
   

Oder Sie könnten exportieren ist als Objektliteral:

export const Util = {
    doSomething(val: string){ return val;},
    doSomethingElse(val: string{ return val;}
}

Sie können auch eine util.tsKlasse erstellen , die eine zu exportierende Funktion hat

export const formatDateOfBirth = 
(dob: string) : string => `${dob.substring(0, 4)}-${dob.substring(4, 6)}-${dob.substring(6, 8)}`;

Jetzt können Sie die Methode importieren , wie unten, gemeinsame Ordnerstruktur ist src> app> shared, ich rufe diesen Import innen src> app>shelf > shelf.component.tsDatei

import { formatDateOfBirth } from '../shared/utils/util';
public getFormattedDate(dob: string):string{
  return formatDateOfBirth(dob);
}