Warum kann ich auf private TypeScript-Mitglieder zugreifen, wenn dies nicht möglich sein sollte?

Ich betrachte die Implementierung privater Mitglieder in TypeScript und finde es etwas verwirrend. Intellisense erlaubt keinen Zugriff auf private Mitglieder, aber in reinem JavaScript ist alles vorhanden. Dies lässt mich denken, dass TS private Mitglieder nicht korrekt implementiert. Irgendwelche Gedanken?

class Test{
  private member: any = "private member";
}
alert(new Test().member);

Genau wie bei der Typprüfung wird die Privatsphäre der Mitglieder nur innerhalb des Compilers durchgesetzt.

Eine private Eigenschaft wird als reguläre Eigenschaft implementiert, und Code außerhalb der Klasse darf nicht darauf zugreifen.

Um etwas innerhalb der Klasse wirklich privat zu machen, kann es kein Mitglied der Klasse sein. Es ist eine lokale Variable, die in einem Funktionsbereich innerhalb des Codes erstellt wird, der das Objekt erstellt. Das würde bedeuten, dass Sie nicht wie ein Mitglied der Klasse darauf zugreifen können, dh wenn Sie das thisSchlüsselwort verwenden.

JavaScript unterstützt private Variablen.

function MyClass() {
    var myPrivateVar = 3;

    this.doSomething = function() {
        return myPrivateVar++;        
    }
}

In TypeScript würde dies folgendermaßen ausgedrückt:

class MyClass {

    doSomething: () => number;

    constructor() {
        var myPrivateVar = 3;

        this.doSomething = function () {
            return myPrivateVar++;
        }
    }
}

BEARBEITEN

Dieser Ansatz sollte nur sparsam angewendet werden, wenn dies unbedingt erforderlich ist. Zum Beispiel, wenn Sie ein Passwort vorübergehend zwischenspeichern müssen.

Die Verwendung dieses Musters verursacht Leistungskosten (unabhängig von Javascript oder Typescript) und sollte nur verwendet werden, wenn dies unbedingt erforderlich ist.

Sobald die Unterstützung für WeakMap weiter verbreitet ist , gibt es eine interessante Technik , die in Beispiel # 3 detailliert hier .

Es ermöglicht private Daten UND vermeidet die Leistungskosten des Beispiels von Jason Evans, indem auf die Daten über Prototypmethoden anstatt nur über Instanzmethoden zugegriffen werden kann.

Auf der verknüpften MDN WeakMap-Seite wird die Browserunterstützung für Chrome 36, Firefox 6.0, IE 11, Opera 23 und Safari 7.1 aufgeführt.

let _counter = new WeakMap();
let _action = new WeakMap();
class Countdown {
  constructor(counter, action) {
    _counter.set(this, counter);
    _action.set(this, action);
  }
  decrement() {
    let counter = _counter.get(this);
    if (counter < 1) return;
    counter--;
    _counter.set(this, counter);
    if (counter === 0) {
      _action.get(this)();
    }
  }
}

Da TypeScript 3.8 veröffentlicht wird, können Sie ein privates Feld deklarieren, auf das außerhalb der enthaltenen Klasse nicht zugegriffen oder das sogar erkannt werden kann .

class Person {
    #name: string

    constructor(name: string) {
        this.#name = name;
    }

    greet() {
        console.log(`Hello, my name is ${this.#name}!`);
    }
}

let jeremy = new Person("Jeremy Bearimy");

jeremy.#name
//     ~~~~~
// Property '#name' is not accessible outside class 'Person'
// because it has a private identifier.

Private Felder beginnen mit #Zeichen

Bitte beachten Sie, dass diese privaten Felder etwas anderes sind als Felder, die mit einem privateSchlüsselwort markiert sind

Ref. https://devblogs.microsoft.com/typescript/announcing-typescript-3-8-beta/

Vielen Dank an Sean Feldman für den Link zur offiziellen Diskussion zu diesem Thema - siehe seine Antwort für den Link.

Ich habe die Diskussion gelesen, mit der er verlinkt hat, und hier ist eine Zusammenfassung der wichtigsten Punkte:

• Vorschlag: Privateigenschaften im Konstruktor
  • Probleme: Zugriff von Prototypfunktionen nicht möglich
• Vorschlag: Private Methoden im Konstruktor
  • Probleme: Wie bei Eigenschaften, und Sie verlieren den Leistungsvorteil, eine Funktion einmal pro Klasse im Prototyp zu erstellen. Stattdessen erstellen Sie für jede Instanz eine Kopie der Funktion
• Vorschlag: Fügen Sie dem abstrakten Eigenschaftszugriff eine Boilerplate hinzu und erzwingen Sie die Sichtbarkeit
  • Probleme: großer Leistungsaufwand; TypeScript wurde für große Anwendungen entwickelt
• Vorschlag: TypeScript schließt die Konstruktor- und Prototypmethodendefinitionen bereits in einen Abschluss ein. dort private Methoden und Eigenschaften platzieren
  • Probleme beim Einfügen privater Immobilien in diesen Abschluss: Sie werden zu statischen Variablen. Es gibt keine pro Instanz
  • Probleme beim Einfügen privater Methoden in diesen Abschluss: Sie haben keinen Zugriff thisohne eine Problemumgehung
• Vorschlag: Die privaten Variablennamen werden automatisch entstellt
  • Gegenargumente: Das ist eine Namenskonvention, kein Sprachkonstrukt. Zerfleische es selbst
• Vorschlag: Kommentieren Sie private Methoden mit @privatesolchen Minifizierern, die erkennen, dass durch Annotation die Methodennamen effektiv minimiert werden können
  • Keine wesentlichen Gegenargumente zu diesem

Allgemeine Gegenargumente zum Hinzufügen von Sichtbarkeitsunterstützung in ausgegebenem Code:

• Das Problem ist, dass JavaScript selbst keine Sichtbarkeitsmodifikatoren hat - dies ist nicht das Problem von TypeScript
• In der JavaScript-Community gibt es bereits ein etabliertes Muster: Stellen Sie privaten Eigenschaften und Methoden einen Unterstrich voran, der besagt: "Fahren Sie auf eigenes Risiko fort."
• Wenn TypeScript-Designer sagten, dass wirklich private Eigenschaften und Methoden nicht "möglich" sind, meinten sie "unter unseren Designbeschränkungen nicht möglich", insbesondere:
  • Das emittierte JS ist idiomatisch
  • Boilerplate ist minimal
  • Kein zusätzlicher Overhead im Vergleich zu normalem JS OOP

In TypeScript sind private Funktionen nur innerhalb der Klasse verfügbar. Mögen

Und es wird ein Fehler angezeigt, wenn Sie versuchen, auf ein privates Mitglied zuzugreifen. Hier ist das Beispiel:

Hinweis: Mit Javascript ist es in Ordnung und beide Funktionen sind außerhalb zugänglich.

Mir ist klar, dass dies eine ältere Diskussion ist, aber es könnte immer noch nützlich sein, meine Lösung für das Problem der angeblich privaten Variablen und Methoden in einem TypeScript zu teilen, das in die öffentliche Schnittstelle der kompilierten JavaScript-Klasse "eindringt".

Für mich ist dieses Problem rein kosmetischer Natur, dh es geht nur um die visuelle Unordnung, wenn eine Instanzvariable in DevTools angezeigt wird. Mein Fix besteht darin, private Deklarationen in einer anderen Klasse zu gruppieren, die dann in der Hauptklasse instanziiert und einer private(in JS noch öffentlich sichtbaren) Variablen mit einem Namen wie __(doppelter Unterstrich) zugewiesen wird .

Beispiel:

class Privates {
    readonly DEFAULT_MULTIPLIER = 2;
    foo: number;
    bar: number;

    someMethod = (multiplier: number = this.DEFAULT_MULTIPLIER) => {
        return multiplier * (this.foo + this.bar);
    }

    private _class: MyClass;

    constructor(_class: MyClass) {
        this._class = _class;
    }
}

export class MyClass {
    private __: Privates = new Privates(this);

    constructor(foo: number, bar: number, baz: number) {
        // assign private property values...
        this.__.foo = foo;
        this.__.bar = bar;

        // assign public property values...
        this.baz = baz;
    }

    baz: number;

    print = () => {
        console.log(`foo=${this.__.foo}, bar=${this.__.bar}`);
        console.log(`someMethod returns ${this.__.someMethod()}`);
    }
}

let myClass = new MyClass(1, 2, 3);

Wenn die myClassInstanz in DevTools angezeigt wird, werden nicht alle "privaten" Mitglieder mit wirklich öffentlichen Mitgliedern vermischt (was in korrekt überarbeitetem Code im wirklichen Leben sehr unübersichtlich werden kann), sondern ordentlich in der reduzierten __Eigenschaft gruppiert :

Hier ist ein wiederverwendbarer Ansatz zum Hinzufügen geeigneter privater Eigenschaften:

/**
 * Implements proper private properties.
 */
export class Private<K extends object, V> {

    private propMap = new WeakMap<K, V>();

    get(obj: K): V {
        return this.propMap.get(obj)!;
    }

    set(obj: K, val: V) {
        this.propMap.set(obj, val);
    }
}

Angenommen, Sie haben Clientirgendwo eine Klasse , die zwei private Eigenschaften benötigt:

• prop1: string
• prop2: number

Im Folgenden wird beschrieben, wie Sie es implementieren:

// our private properties:
interface ClientPrivate {
    prop1: string;
    prop2: number;
}

// private properties for all Client instances:
const pp = new Private<Client, ClientPrivate>();

class Client {
    constructor() {
        pp.set(this, {
            prop1: 'hello',
            prop2: 123
        });
    }

    someMethod() {
        const privateProps = pp.get(this);

        const prop1 = privateProps.prop1;
        const prop2 = privateProps.prop2;
    }
}

Und wenn Sie nur ein einzelnes Privateigentum benötigen, wird es noch einfacher, da Sie ClientPrivatein diesem Fall keine definieren müssten .

Es ist erwähnenswert, dass die Klasse zum größten Teil Privatenur eine gut lesbare Signatur bietet, während die direkte Verwendung WeakMapdies nicht tut.