Valeurs par défaut de l'interface Typescript

J'ai l'interface suivante dans TypeScript:

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

Je déclare une variable de ce type et j'initialise toutes les propriétés

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

Ensuite, je leur attribue des valeurs réelles dans une fonction init plus tard

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

Mais je n'aime pas avoir à spécifier un tas de valeurs nulles par défaut pour chaque propriété lors de la déclaration de l'objet, alors qu'elles seront simplement définies plus tard sur des valeurs réelles. Puis-je dire à l'interface de définir par défaut les propriétés que je ne fournis pas à null? Qu'est-ce qui me permettrait de faire ceci:

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

sans obtenir une erreur du compilateur. En ce moment, ça me dit

TS2322: Le type '{}' n'est pas attribuable au type 'IX'. La propriété 'b' est manquante dans le type '{}'.

Puis-je dire à l'interface de définir par défaut les propriétés que je ne fournis pas à null? Qu'est-ce qui me permettrait de faire ça

Non, mais par défaut, ils le sont, undefinedce qui est généralement très bien. Vous pouvez utiliser le modèle suivant, c'est-à-dire avoir une assertion de type au point de création:

let x: IX = {} as any;

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

J'ai ceci et d'autres modèles documentés ici: https://basarat.gitbook.io/typescript/main-1/lazyobjectliteralinitialization

Vous ne pouvez pas définir de valeurs par défaut dans une interface, mais vous pouvez accomplir ce que vous voulez faire en utilisant les propriétés facultatives (comparez le paragraphe 3):

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

Changez simplement l'interface en:

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

Vous pouvez alors faire:

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

Et utilisez votre fonction init pour attribuer des valeurs par défaut à x.bet x.csi ces propriétés ne sont pas définies.

Alors que la réponse de @ Timar fonctionne parfaitement pour les nullvaleurs par défaut (ce qui a été demandé), voici une autre solution simple qui autorise d'autres valeurs par défaut: Définissez une interface d'option ainsi qu'une constante correspondante contenant les valeurs par défaut; dans le constructeur, utilisez l' opérateur spread pour définir la optionsvariable membre

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

Vous pouvez maintenant utiliser la classe comme ceci:

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

Production:

set
null
1

Vous pouvez implémenter l'interface avec une classe, puis vous pouvez vous occuper de l'initialisation des membres dans le constructeur:

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

Une autre approche consiste à utiliser une fonction d'usine:

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

Ensuite, vous pouvez simplement:

var ix: IX = null;
...

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

Vous pouvez utiliser le Partialtype mappé comme expliqué dans la documentation: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

Dans votre exemple, vous aurez:

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

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

Je suis tombé sur cela en cherchant un meilleur moyen que ce à quoi j'étais arrivé. Après avoir lu les réponses et les avoir essayées, j'ai pensé qu'il valait la peine de poster ce que je faisais car les autres réponses ne me semblaient pas aussi succinctes. Il était important pour moi de n'avoir à écrire qu'une petite quantité de code à chaque fois que je mettais en place une nouvelle interface. Je me suis installé sur ...

À l'aide d'une fonction deepCopy générique personnalisée:

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

Définissez votre interface

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

... et définissez les valeurs par défaut dans un const séparé.

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

Puis lancez comme ceci:

let x : IX = deepCopy(XDef);

C'est tout ce dont vous avez besoin.

.. cependant ..

Si vous souhaitez initialiser un élément racine de manière personnalisée, vous pouvez modifier la fonction deepCopy pour accepter les valeurs par défaut personnalisées. La fonction devient:

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

Qui peut alors être appelé comme ceci à la place:

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

Tout autre moyen préféré de copie profonde fonctionnerait. Si seulement une copie superficielle est nécessaire, Object.assign suffirait, renonçant au besoin de l'utilitaire deepCopyou de la deepCopyAssignfonction.

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

Problèmes connus

• Il ne sera pas assigné en profondeur sous cette forme, mais il n'est pas trop difficile de modifier deepCopyAssignpour itérer et vérifier les types avant d'affecter.
• Les fonctions et références seront perdues par le processus d'analyse / stringify. Je n'en ai pas besoin pour ma tâche et l'OP non plus.
• Les valeurs init personnalisées ne sont pas indiquées par l'EDI ou le type vérifié lors de l'exécution.

Ma solution:

J'ai créé un wrapper sur Object.assign pour résoudre les problèmes de frappe.

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

Usage:

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;