Typoskript. Wie man Objekt die Eigenschaft name der Wert?

Schreibe ich Typoskript Klasse für die Verwendung mit unveränderlich Karte

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

Gibt es ein problem mit getPropName Methode. Wenn obj hat zwei Eigenschaften mit demselben Wert, die nur die erste Eigenschaft angepasst werden.

Weiß jemand, wie dies zu umgehen?

Was willst du geschehen? Ein array von keys? Ein Fehler für nicht-Eindeutigkeit? Was?
Ein Objekt ist Schlüssel eindeutig sein soll. Können Sie ein Beispiel geben, wie/warum würden Sie haben ein Objekt mit mehr als Schlüssel mit dem gleichen Namen?
Ich meine, ein Objekt hat zwei Eigenschaften mit demselben Wert (nicht Schlüssel).
Ich will starke Typisierung bei der Auswahl von "Eigenschaften" und dann wieder voller-Pfad für die Verwendung mit unveränderlich Landkarte.

InformationsquelleAutor Hoang Hiep | 2016-05-05

Könnten Sie auf diese Weise des Erhaltens der name der Eigenschaft:

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"]

InformationsquelleAutor David Sherret

2

Es gibt nichts einfach Sie können hier mit Ihrer aktuellen Abfrage Ansatz. Es ist mehrdeutig, welche Eigenschaft Sie die Auswahl, also es gibt keine einfache Möglichkeit um den richtigen Weg. Es ist nicht so, dass Ihr code 'falsch' ist nun als solche, es ist nur, dass es zwei mögliche richtige Antworten, und es hob einen willkürlich.

Können Sie die Regeln ändern, auf welche der möglichen Tasten greift, aber es gibt keine sinnvollen Regeln, die sicher bekommen Sie die richtige Antwort. Alternativ können Sie auch wieder alle möglichen Antworten, und haben einen mehrdeutigen Weg, aber es scheint nicht, wie das tut, was Sie suchen.

Möglicherweise gibt es eine option, indem Sie verrückte Dinge tun wie analysieren die Funktion mit Esprima oder sogar mit regulären Ausdrücken arbeiten Sie heraus, welche Eigenschaften sind gepackt, aber es ist allgemein eine schlechte Idee ist. Das ist wahrscheinlich zu kompliziert und fragil, unzuverlässig, sofern Sie garantieren kann, die genaue Form des Codes werden Sie in To(), und ausführen sehr langsam zu.

Wenn Sie tun können möchten und wählen Sie Eigenschaften, wie dies und kennen den Weg, der für bestimmte, haben Sie Ihre To Funktion der Schlüssel der Eigenschaft, nicht nur eine Funktion, um den Wert hält. Es ist eine weniger elegante API, aber es ist der einzig sinnvolle Weg du gehst, um das Verhalten, die Sie suchen:
```
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();
```
In Zukunft könnte es möglich sein, dies zu tun mit der Art Sicherheit in Schriftlicher, aber nicht jetzt. Diese PR sucht nach genau diesen Themen, aber es ist immer noch unter einige Diskussionen noch, so gibt es werde eine Weile dauern, bis es implementiert ist. Beachten Sie, dass es immer noch schlägt die string-basierten Ansatz aus dem Beispiel oben, es ist nur das Typ-system wird überprüfen Sie, dass string-Konstanten sind gültige Namen der Eigenschaft, für die Typen eingesetzt.

InformationsquelleAutor Tim Perry

Hier ist die Zukunft. Als pro Tim Perry link, Typoskript ist nun keyof, die ein großartiges feature für immer die Eigenschaften einer Klasse.

Nutzung, nach dem Typoskript Dokumentation:

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

InformationsquelleAutor Jack Koppa

Nicht kündigen, der auf den ersten gefundenen Wert, und liefert ein array von Namen mit den passenden Werten. Ich verlassen Sie das propblem für den Umgang mit mehreren Namen.

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

InformationsquelleAutor HBP

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.