Tapuscrit. Comment obtenir de l'objet nom de la propriété à partir de sa valeur?

Je suis en train d'écrire un texte dactylographié de classe pour l'utilisation avec immuable la carte

class NavigableObject<T> {
    constructor(private obj: T, private path: string[] = []) { }

    To<R>(p: (x: T) => R): NavigableObject<R> {
        return new NavigableObject<R>(p(this.obj),
                       this.path.concat(this.getPropName(p(this.obj))));
    }

    getPath() {
        return this.path;
    }

    private getPropName(value) {
        for (var item in this.obj) {
            if (this.obj[item] === value) {
                return item;
            }
        }
    }
}

let test = {
    a: {
        a1: 1,
        a2: 1
    },
    b: {
        b1: 1,
        b2: 2
    }
}

let navigableTest = new NavigableObject(test);

navigableTest.To(m => m.b).To(m => m.b2).getPath(); //= ["b", "b2"]

navigableTest.To(m => m.a).To(m => m.a2).getPath(); //= ["a", "a1"] <-- I selected a2, tho

Il y a un problème avec getPropName méthode. Lorsque obj a deux propriétés avec la même valeur, seule la première sera mis en correspondance.

Personne ne sait comment contourner ce problème?

Que voulez-vous arriver? Un tableau de clés? Une erreur de la non-unicité? Quoi?
Un objet de touches doit être unique. Pouvez-vous donner un exemple de comment/pourquoi vous auriez un objet avec plus de touche du même nom?
Je veux dire, un objet possède deux propriétés avec la même valeur (pas même clé).
Je veux obtenir un typage fort lors de la sélection des propriétés et ensuite de retour à chemin-complet pour une utilisation avec un immuables de la carte.

OriginalL'auteur Hoang Hiep | 2016-05-05

Vous pouvez utiliser cette façon d'obtenir le nom de la propriété:

class NavigableObject<T> {
    constructor(private obj: T, private path: string[] = []) { }

    To<R>(p: (x: T) => R): NavigableObject<R> {
        return new NavigableObject<R>(p(this.obj),
                       this.path.concat(this.getPropName(p)));
    }

    getPath() {
        return this.path;
    }

    private static propertyRegEx = /\.([^\.;]+);?\s*\}$/;

    private getPropName(propertyFunction: Function) {
        return NavigableObject.propertyRegEx.exec(propertyFunction.toString())[1];
    }
}

let test = {
    a: {
        a1: 1,
        a2: 1
    },
    b: {
        b1: 1,
        b2: 2
    }
}

let navigableTest = new NavigableObject(test);

navigableTest.To(m => m.b).To(m => m.b2).getPath(); //= ["b", "b2"]

navigableTest.To(m => m.a).To(m => m.a2).getPath(); //= ["a", "a2"]

OriginalL'auteur David Sherret

2

Il n'y a rien de facile, vous pouvez le faire ici avec votre interrogation approche. C'est ambigu la propriété de qui vous achetez, donc il n'y a pas de moyen facile pour obtenir le droit chemin. Ce n'est pas que votre code est "mal", maintenant en tant que tel, c'est juste qu'il y a deux réponses correctes, et il a une façon arbitraire.

Vous pouvez modifier les règles sur les touches de il prend, mais il n'existe pas de règles censées qui sera fiable de vous obtenir le droit de réponse unique. Vous pouvez aussi retourner toutes les réponses possibles, et ont l'ambiguïté d'un chemin, mais il ne semble pas qu'est-ce que vous cherchez.

Il y a peut être une option en faire des choses folles comme l'analyse de la fonction fournie avec Esprima ou même des expressions régulières pour travailler sur les propriétés qui sont saisis, mais il est généralement va être une mauvaise idée. Qui est susceptible d'être complexe et fragile, peu fiables, sauf si vous pouvez garantir la forme exacte de la code vous allez être fourni dans To(), et courir assez lentement.

Si vous ne voulez pas être en mesure de sélectionner les propriétés de ce type et de connaître le chemin d'accès utilisé pour certains, vous devrez donner votre To fonction de la clé de la propriété, et pas seulement une fonction permettant d'obtenir la valeur qu'il détient. C'est moins élégant API, mais c'est la seule façon sensée que vous allez obtenir le comportement que vous cherchez:
```
class NavigableObject<T> {
    constructor(private obj: T, private path: string[] = []) { }

    To<R>(p: string): NavigableObject<R> {
        return new NavigableObject<R>(this.obj[p],
                       this.path.concat(p));
    }

    getPath() {
        return this.path;
    }
}

let test = {
    a: {
        a1: 1,
        a2: 1
    },
    b: {
        b1: 1,
        b2: 2
    }
}

let navigableTest = new NavigableObject(test);

navigableTest.To('b').To('b2').getPath();

navigableTest.To('a').To('a2').getPath();
```
Dans l'avenir, il pourrait être possible de le faire avec le type de sécurité à la Machine, mais pas maintenant. Cette PR est à la recherche dans exactement ces questions, mais c'est encore en discussion et pourtant, jusqu'à il y a un certain temps jusqu'à ce qu'il a mis en œuvre. Notez qu'il est encore en proposant la chaîne basée sur l'approche à partir de l'exemple ci-dessus, c'est juste le type de système vérifiera que les constantes de chaîne sont valables propriété des noms pour les types utilisés.

OriginalL'auteur Tim Perry

L'avenir est ici. Comme par Tim Perry lien, Tapuscrit a maintenant ajouté keyof, qui est une grande fonctionnalité pour obtenir les propriétés d'une classe.

D'utilisation, comme par le Tapuscrit la documentation:

interface Person {
    name: string;
    age: number;
    location: string;
}

type K1 = keyof Person; //"name" | "age" | "location"
type K2 = keyof Person[];  //"length" | "push" | "pop" | "concat" | ...
type K3 = keyof { [x: string]: Person };  //string

OriginalL'auteur Jack Koppa

Ne pas mettre fin à la pour la sur la première valeur trouvée, et retourne un tableau de noms avec des valeurs correspondantes. Je vous laisse le propblem de la façon de gérer de multiples noms.

private getPropName (value) {
    var items = [];
    for (var item in this.obj) {
        if (this.obj[item] === value)
            items.push (item);
    return items;
}

OriginalL'auteur HBP

Vous devez vous connecter pour publier un commentaire.