Tapuscrit de la sécurité de la navigation de l'opérateur ( ?. ) ou (!.) et de la propriété null chemins

Question

Angular2 modèles d'assurer la sécurité de l'opérateur (?.), mais dans le composant.ts (tapuscrit 2.0). La sécurité de la navigation de l'opérateur (!.) pas de travail.

Exemple:

Ce Texte Dactylographié

if (a!.b!.c) { }

compile de ce JavaScript

if (a.b.c) { }

Mais quand je le lance, j'obtiens l'erreur de suivi:

Impossible de lire la propriété 'b' undefined

Est-il une alternative à:

if (a && a.b && a.b.c) { }

?

Answer 1

Actuellement, il n'y a pas la sécurité de la navigation de l'opérateur en caractères d'imprimerie (encore en discussion).

!. est non-nulle affirmation de l'opérateur - il juste de dire au vérificateur de types que vous êtes sûr qu' a n'est null ou undefined.

Plus d'infos ici

Answer 2

Vous pouvez essayer d'écrire fonction personnalisée comme ça.

Le principal avantage de cette approche est d'une vérification de type, et partielle intellisense.

export function nullSafe<T, 
    K0 extends keyof T, 
    K1 extends keyof T[K0],
    K2 extends keyof T[K0][K1],
    K3 extends keyof T[K0][K1][K2],
    K4 extends keyof T[K0][K1][K2][K3],
    K5 extends keyof T[K0][K1][K2][K3][K4]>
    (obj: T, k0: K0, k1?: K1, k2?: K2, k3?: K3, k4?: K4, k5?: K5) {
    let result: any = obj;

    const keysCount = arguments.length - 1;
    for (var i = 1; i <= keysCount; i++) {
        if (result === null || result === undefined) return result;
        result = result[arguments[i]];
    }

    return result;
}

Et de l'usage (prend en charge jusqu'à 5 paramètres, et peut être étendue):

nullSafe(a, 'b', 'c');

Exemple sur l' aire de jeux.

Answer 3

Une autre alternative qui utilise une bibliothèque externe est _.a() à partir de Lodash.

E. g.

_.has(a, 'b.c')

est égal à

(a && a.b && a.b.c)

Answer 4

Bâtiment sur @Pvl réponse, vous pouvez inclure le type de sécurité de votre valeur retournée ainsi si vous utilisez les remplacements:

function dig<
  T,
  K1 extends keyof T
  >(obj: T, key1: K1): T[K1];

function dig<
  T,
  K1 extends keyof T,
  K2 extends keyof T[K1]
  >(obj: T, key1: K1, key2: K2): T[K1][K2];

function dig<
  T,
  K1 extends keyof T,
  K2 extends keyof T[K1],
  K3 extends keyof T[K1][K2]
  >(obj: T, key1: K1, key2: K2, key3: K3): T[K1][K2][K3];

function dig<
  T,
  K1 extends keyof T,
  K2 extends keyof T[K1],
  K3 extends keyof T[K1][K2],
  K4 extends keyof T[K1][K2][K3]
  >(obj: T, key1: K1, key2: K2, key3: K3, key4: K4): T[K1][K2][K3][K4];

function dig<
  T,
  K1 extends keyof T,
  K2 extends keyof T[K1],
  K3 extends keyof T[K1][K2],
  K4 extends keyof T[K1][K2][K3],
  K5 extends keyof T[K1][K2][K3][K4]
  >(obj: T, key1: K1, key2: K2, key3: K3, key4: K4, key5: K5): T[K1][K2][K3][K4][K5];

function dig<
  T,
  K1 extends keyof T,
  K2 extends keyof T[K1],
  K3 extends keyof T[K1][K2],
  K4 extends keyof T[K1][K2][K3],
  K5 extends keyof T[K1][K2][K3][K4]
  >(obj: T, key1: K1, key2?: K2, key3?: K3, key4?: K4, key5?: K5):
  T[K1] |
  T[K1][K2] |
  T[K1][K2][K3] |
  T[K1][K2][K3][K4] |
  T[K1][K2][K3][K4][K5] {
    let value: any = obj && obj[key1];

    if (key2) {
      value = value && value[key2];
    }

    if (key3) {
      value = value && value[key3];
    }

    if (key4) {
      value = value && value[key4];
    }

    if (key5) {
      value = value && value[key5];
    }

    return value;
}

Exemple sur l' aire de jeux.