Typoskript private Mitglieder

JavaScript tut private Variablen unterstützen.

function MyClass() {
    var myPrivateVar = 3;

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

In Typoskript würde dies wie so ausgedrückt werden:

class MyClass {

    doSomething: () => number;

    constructor() {
        var myPrivateVar = 3;

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

BEARBEITEN

Dieser Ansatz sollte nur verwendet werden , sparsam , wo es unbedingt notwendig ist. Zum Beispiel , wenn Sie ein Kennwort vorübergehend zwischenspeichern müssen.

Es gibt Leistungskosten mit diesem Muster (irrelevant von Javascript oder Typoskript) und sollten nur verwendet werden, wenn unbedingt notwendig.

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

Es ermöglicht die privaten Daten und vermeidet die Leistungskosten von Jason Evans Beispiel durch die Daten so dass anstelle von nur Instanzmethoden von Prototyp Methoden zugänglich sein.

Die verknüpfte MDN WeakMap Seite zeigt den Browser-Unterstützung bei Chrome 36, Firefox 6.0, IE 11, Opera 23 und Safari 7.1.

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)();
    }
  }
}

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

Ich lese die Diskussion , die er im Zusammenhang mit, und hier ist eine Zusammenfassung der wichtigsten Punkte:

• Vorschlag: Private Immobilien - Konstruktor
  • Probleme: kann nicht von Prototyp - Funktionen zugreifen
• Vorschlag: private Methoden in Konstruktor
  • Probleme: gleiche wie mit Eigenschaften, plus Sie verlieren den Performance - Vorteil eine Funktion einmal pro Klasse in dem Prototyp zu schaffen; stattdessen Sie für jede Instanz eine Kopie der Funktion erstellen
• Vorschlag: füge vorformulierten auf abstrakte Eigenschaft Zugang und Sichtbarkeit erzwingen
  • Probleme: Hauptleistungsaufwand; Typoskript ist für große Anwendungen
• Vorschlag: Typoskript bereits wickelt den Konstruktor und Prototyp Methodendefinitionen in einem Verschluss; setzen private Methoden und Eigenschaften dort
  • Probleme mit privaten Eigenschaften in diesem Verschluss setzen: sie werden statische Variablen; gibt es nicht eine pro Instanz
  • Probleme mit in diesem Verschluss private Methoden setzen: sie haben keinen Zugang zu , thisohne irgendeine Art von Problem zu umgehen
• Vorschlag: automatisch die privaten Variablennamen mangle
  • Gegenargumente: das ist eine Namenskonvention, kein Sprachkonstrukt. Mangle es selbst
• Vorschlag: Anmerken private Methoden mit @privateso minifiers, die diese Anmerkung erkennen kann effektiv die Methode Namen minify
  • Keine signifikanten Gegenargumente zu diesem

Gesamtgegenargumente Sichtbarkeits Unterstützung in emittiertes Code hinzufügen:

• das Problem ist, dass JavaScript selbst nicht Sichtbarkeitsmodifizierer hat - das ist nicht das Problem Typoskript
• gibt es bereits ein etabliertes Muster in der JavaScript-Community: prefix private Eigenschaften und Methoden mit einem Unterstrich, die „gehen auf eigene Gefahr“, sagen
• wenn Typoskript Designer sagten, dass wirklich private Eigenschaften und Methoden sind nicht „möglich“, meinte sie „nicht möglich, unter unserer Designeinschränkung“, insbesondere:
  • Das emittierte JS ist idiomatische
  • Vorformulierten ist minimal
  • Kein zusätzlicher Aufwand im Vergleich zu normalen JS OOP

In Typoskript sind private Funktionen nur innerhalb der Klasse zugänglich. Mögen

Und es wird eine Fehlermeldung angezeigt, wenn Sie versuchen, einen privaten Member zuzugreifen. Hier ist das Beispiel:

Hinweis: Es wird gut mit Javascript und beide Funktion ist außen zugänglich.

Ich weiß, dies ist eine ältere Diskussion, aber es könnte noch nützlich sein, meine Lösung für das Problem der angeblich privaten Variablen und Methoden in einem Typoskript zu teilen in die öffentliche Schnittstelle der kompilierten JavaScript-Klasse „undicht“.

Für mich ist dieses Thema rein kosmetischer Natur, dh es ist alles über die visuelle Unordnung ist , wenn eine Instanz - Variable in DevTools betrachtet. Meine Lösung ist , zu einer Gruppe privater Erklärungen zusammen in einer anderen Klasse , die dann in der Hauptklasse instanziiert und zugeordnet zu einem private(aber immer noch öffentlich sichtbar in JS) Variable mit einem Namen wie __(Doppelstrich).

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 myClasssich beispielsweise in DevTools betrachtet, statt dessen alles sehende „private“ Mitglieder vermischte mit wahrhaft öffentlichen diejenigen (die in richtig Refactoring realen Code optisch sehr unordentlich erhalten kann) man sieht sie ordentlich in der kollabierten gruppiert __Eigenschaft:

Viele Leute behaupten, dies aufgrund von Einschränkungen in JavaScript nicht möglich ist. Ich würde sagen, es ist Beschränkungen in der JavaScript-Entwickler Kreativität.

Ich entwickle eine Bibliothek jetzt , dass erlaubt private und geschützte vererbbar Mitglieder von Klassen sowie Schnittstellen usw. genannt ClassJS. Check it out hier auf GitHub .