nom du mot clé dans le script

Question

Comme je l'ai vu, il n'est pas natif nameof-mot-clé comme le C# a construit en caractères d'imprimerie . Cependant, pour les mêmes raisons, cela existe en C#, je veux être capable de faire référence à des noms de propriété dans un type de manière sécuritaire.

Ceci est particulièrement utile dans la Machine lors de l'utilisation de plugins jQuery (Bootstrap-Tagsinput) ou d'autres bibliothèques où le nom d'une propriété doit être configuré.

Il pourrait ressembler à:

const name: string = nameof(Console.log);
// 'name' is now equal to "log"

La cession de l' name devrait changer aussi, lorsqu' Console.log obtenu reconstruit et rebaptisé.

Ce qui est le plus proche possible de l'utilisation d'une telle fonction en caractères d'imprimerie pour l'instant?

Answer 1

Comme vous l'avez déjà dit, il n'est pas construit dans la fonctionnalité sur la Machine à partir de la version 2.8. Cependant, il ya des façons d'obtenir le même résultat:

Option 1: à l'Aide d'une bibliothèque

ts-nameof est une bibliothèque qui fournit exactement la fonctionnalité comme C#. Avec ce que vous pouvez faire:

nameof(console); // => "console"
nameof(console.log); // => "log"
nameof<MyInterface>(); // => "MyInterface"
nameof<MyNamespace.MyInnerInterface>(); // => "MyInnerInterface"

ts-simple-nameof propose une alternative. Essentiellement, il traite un stringified lambda de comprendre le nom de la propriété:

nameof<Comment>(c => c.user); // => "user"
nameof<Comment>(c => c.user.posts); // => "user.posts"

Option 2: Définir une fonction d'assistance

Vous pouvez facilement définir vos propres nameof qui ajoute de la vérification de type, cependant il ne sera pas refactoriser automatiquement que vous aurez toujours besoin de taper une chaîne de caractères littérale:

const nameof = <T>(name: keyof T) => name;

Il sera de retour le passé nom de la propriété mais génère une erreur de compilation lorsque le nom de la propriété n'existe pas sur le type T. L'utiliser comme ceci:

interface Person {
    firstName: string;
    lastName: string;
}

const personName1 = nameof<Person>("firstName"); // => "firstName"
const personName2 = nameof<Person>("noName");    // => compile time error

Crédits et plus d'informations sur ce

Mise à jour sur la fonction d'assistance avec Tapuscrit de 2,9+

Le type keyof T maintenant non seulement résout à une chaîne, mais à l' string | number | symbol (ref). Si vous voulez continuer à résoudre les cordes, l'utilisation de cette mise en place:

const nameof = <T>(name: Extract<keyof T, string>): string => name;

Answer 2

Je pense que nous avons souvent besoin de plus: pour obtenir les noms de propriété de classe lors de l'exécution avec la validation au moment de la compilation. Ceci est une fonctionnalité vraiment utile:

 export type valueOf<T> = T[keyof T];
export function nameOf<T, V extends T[keyof T]>(f: (x: T) => V): valueOf<{ [K in keyof T]: T[K] extends V ? K : never }>;
export function nameOf(f: (x: any) => any): keyof any {
    var p = new Proxy({}, {
        get: (target, key) => key
    })
    return f(p);
}
 

Exemple d'utilisation (pas de chaînes!):

 if (update.key !== nameOf((_: SomeClass) => _.someProperty)) {
   // ...                               
}