Standardwerte der Typoskript-Schnittstelle

Ich habe die folgende Oberfläche in TypeScript:

interface IX {
    a: string,
    b: any,
    c: AnotherType
}

Ich deklariere eine Variable dieses Typs und initialisiere alle Eigenschaften

let x: IX = {
    a: 'abc',
    b: null,
    c: null
}

Dann weise ich ihnen später in einer Init-Funktion echte Werte zu

x.a = 'xyz'
x.b = 123
x.c = new AnotherType()

Aber ich mag es nicht, für jede Eigenschaft eine Reihe von Standard-Nullwerten angeben zu müssen, wenn das Objekt deklariert wird, wenn sie später nur auf echte Werte gesetzt werden sollen. Kann ich der Schnittstelle mitteilen, dass die Eigenschaften, die ich nicht angegeben habe, standardmäßig auf null gesetzt werden sollen? Was würde mich das tun lassen:

let x: IX = {
    a: 'abc'
}

ohne einen Compilerfehler zu bekommen. Im Moment sagt es mir

TS2322: Typ '{}' kann nicht dem Typ 'IX' zugewiesen werden. Die Eigenschaft 'b' fehlt im Typ '{}'.

Kann ich der Schnittstelle mitteilen, dass die Eigenschaften, die ich nicht angegeben habe, standardmäßig auf null gesetzt werden sollen? Was würde mich das machen lassen?

Nein, aber standardmäßig sind sie undefineddas, was meistens in Ordnung ist. Sie können das folgende Muster verwenden, dh eine Typzusicherung zum Zeitpunkt der Erstellung:

let x: IX = {} as any;

x.a = 'xyz'
x.b = 123
x.c = new AnotherType()

Ich habe dieses und andere Muster hier dokumentiert: https://basarat.gitbook.io/typescript/main-1/lazyobjectliteralinitialization

Sie können keine Standardwerte in einer Schnittstelle festlegen, aber Sie können das erreichen, was Sie tun möchten, indem Sie die optionalen Eigenschaften verwenden (vergleiche Absatz 3):

https://www.typescriptlang.org/docs/handbook/interfaces.html

Ändern Sie einfach die Benutzeroberfläche in:

interface IX {
    a: string,
    b?: any,
    c?: AnotherType
}

Sie können dann tun:

let x: IX = {
    a: 'abc'
}

Verwenden Sie Ihre Init-Funktion, um Standardwerte zuzuweisen, x.bund x.cwenn diese Eigenschaften nicht festgelegt sind.

Während die Antwort von @ Timar für nullStandardwerte (nach denen gefragt wurde) perfekt funktioniert , gibt es hier eine weitere einfache Lösung, die andere Standardwerte zulässt: Definieren Sie eine Optionsschnittstelle sowie eine entsprechende Konstante, die die Standardwerte enthält. Verwenden Sie im Konstruktor den Spread-Operator , um die optionsElementvariable festzulegen

interface IXOptions {
    a?: string,
    b?: any,
    c?: number
}

const XDefaults: IXOptions = {
    a: "default",
    b: null,
    c: 1
}

export class ClassX {
    private options: IXOptions;

    constructor(XOptions: IXOptions) {
        this.options = { ...XDefaults, ...XOptions };
    }

    public printOptions(): void {
        console.log(this.options.a);
        console.log(this.options.b);
        console.log(this.options.c);
    }
}

Jetzt können Sie die Klasse folgendermaßen verwenden:

const x = new ClassX({ a: "set" });
x.printOptions();

Ausgabe:

set
null
1

Sie können die Schnittstelle mit einer Klasse implementieren und dann die Elemente im Konstruktor initialisieren:

class IXClass implements IX {
    a: string;
    b: any;
    c: AnotherType;

    constructor(obj: IX);
    constructor(a: string, b: any, c: AnotherType);
    constructor() {
        if (arguments.length == 1) {
            this.a = arguments[0].a;
            this.b = arguments[0].b;
            this.c = arguments[0].c;
        } else {
            this.a = arguments[0];
            this.b = arguments[1];
            this.c = arguments[2];
        }
    }
}

Ein anderer Ansatz ist die Verwendung einer Factory-Funktion:

function ixFactory(a: string, b: any, c: AnotherType): IX {
    return {
        a: a,
        b: b,
        c: c
    }
}

Dann können Sie einfach:

var ix: IX = null;
...

ix = new IXClass(...);
// or
ix = ixFactory(...);

Sie können den Partialzugeordneten Typ wie in der Dokumentation beschrieben verwenden: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

In Ihrem Beispiel haben Sie:

interface IX {
    a: string;
    b: any;
    c: AnotherType;
}

let x: Partial<IX> = {
    a: 'abc'
}

Ich stolperte darüber, als ich nach einem besseren Weg suchte als dem, zu dem ich gekommen war. Nachdem ich die Antworten gelesen und ausprobiert hatte, dachte ich, es lohnt sich zu posten, was ich tat, da sich die anderen Antworten für mich nicht so prägnant anfühlten. Es war mir wichtig, jedes Mal, wenn ich eine neue Schnittstelle einrichte, nur eine kurze Menge Code schreiben zu müssen. Ich entschied mich für ...

Verwenden einer benutzerdefinierten generischen deepCopy-Funktion:

deepCopy = <T extends {}>(input: any): T => {
  return JSON.parse(JSON.stringify(input));
};

Definieren Sie Ihre Schnittstelle

interface IX {
    a: string;
    b: any;
    c: AnotherType;
}

... und definieren Sie die Standardeinstellungen in einer separaten Konstante.

const XDef : IX = {
    a: '',
    b: null,
    c: null,
};

Dann Init wie folgt:

let x : IX = deepCopy(XDef);

Das ist alles was benötigt wird ..

.. jedoch ..

Wenn Sie ein Stammelement benutzerdefiniert initialisieren möchten, können Sie die deepCopy-Funktion so ändern, dass benutzerdefinierte Standardwerte akzeptiert werden. Die Funktion wird:

deepCopyAssign = <T extends {}>(input: any, rootOverwrites?: any): T => {
  return JSON.parse(JSON.stringify({ ...input, ...rootOverwrites }));
};

Was dann stattdessen so genannt werden kann:

let x : IX = deepCopyAssign(XDef, { a:'customInitValue' } );

Jede andere bevorzugte Art der Tiefenkopie würde funktionieren. Wenn nur eine flache Kopie benötigt wird, würde Object.assign ausreichen und auf die Notwendigkeit des Dienstprogramms deepCopyoder der deepCopyAssignFunktion verzichten.

let x : IX = object.assign({}, XDef, { a:'customInitValue' });

Bekannte Probleme

• In dieser Form wird es nicht tief zugewiesen, aber es ist nicht allzu schwierig, Änderungen deepCopyAssignvorzunehmen, um Typen vor dem Zuweisen zu iterieren und zu überprüfen.
• Funktionen und Referenzen gehen beim Parse / Stringify-Prozess verloren. Ich brauche diese nicht für meine Aufgabe und das OP auch nicht.
• Benutzerdefinierte Init-Werte werden von der IDE oder dem Typ, der bei der Ausführung überprüft wird, nicht angedeutet.

Meine Lösung:

Ich habe einen Wrapper über Object.assign erstellt, um Tippprobleme zu beheben.

export function assign<T>(...args: T[] | Partial<T>[]): T {
  return Object.assign.apply(Object, [{}, ...args]);
}

Verwendung:

env.base.ts

export interface EnvironmentValues {
export interface EnvironmentValues {
  isBrowser: boolean;
  apiURL: string;
}

export const enviromentBaseValues: Partial<EnvironmentValues> = {
  isBrowser: typeof window !== 'undefined',
};

export default enviromentBaseValues;

env.dev.ts

import { EnvironmentValues, enviromentBaseValues } from './env.base';
import { assign } from '../utilities';

export const enviromentDevValues: EnvironmentValues = assign<EnvironmentValues>(
  {
    apiURL: '/api',
  },
  enviromentBaseValues
);

export default enviromentDevValues;