Typoscript particuliere leden

JavaScript ondersteunt private variabelen.

function MyClass() {
    var myPrivateVar = 3;

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

In Typescript zou dit worden uitgedrukt als volgt:

class MyClass {

    doSomething: () => number;

    constructor() {
        var myPrivateVar = 3;

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

BEWERK

Deze aanpak mag alleen worden gebruikt spaarzaam waar het echt nodig is. Bijvoorbeeld als u een wachtwoord tijdelijk cachen.

Er zijn prestaties kosten voor het gebruik van dit patroon (irrelevant van Javascript of Typescript) en mag alleen indien absoluut noodzakelijk worden gebruikt.

Zodra ondersteuning voor WeakMap is op grotere schaal beschikbaar is er een interessante techniek beschreven in voorbeeld # 3 hier .

Het zorgt voor privé-gegevens en vermijdt de prestaties kosten van Jason Evans bijvoorbeeld door zodat de gegevens toegankelijk vanaf prototype methoden in plaats van slechts bijvoorbeeld methoden.

De gekoppelde MDN WeakMap vindt u een overzicht browser ondersteuning op Chrome 36, Firefox 6.0, IE 11, Opera 23 en 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)();
    }
  }
}

Met dank aan Sean Feldman voor de link naar de officiële discussie over deze kwestie - zie zijn antwoord voor de link.

Ik las het gesprek dat hij in verband met, en hier is een samenvatting van de belangrijkste punten:

• Suggestie: particuliere woningen in constructor
  • problemen: kan geen toegang vanaf prototype functies
• Suggestie: private methoden in constructor
  • problemen: hetzelfde als met eigenschappen, plus je verliest de prestaties voordeel van het creëren van een functie eenmaal per klas in het prototype; in plaats daarvan u een kopie van de functie te creëren voor elk exemplaar
• Suggestie: voeg standaardtekst om abstracte toegang tot eigendom en de handhaving van de zichtbaarheid
  • problemen: grote prestaties overhead; Typescript is ontworpen voor grote toepassingen
• Suggestie: Typescript wraps reeds de constructeur en prototype methode definities in een sluiting; zet private methoden en eigenschappen er
  • problemen met het assembleren van particuliere woningen in dat sluiting: ze worden statische variabelen; Er is niet één per exemplaar
  • problemen met het assembleren van private methoden op dat sluiting: ze geen toegang te hebben thiszonder enige vorm van oplossing
• Suggestie: automatisch mangel de private variabele namen
  • tegenargumenten: dat is een naamgeving, geen taal construct. Mangel het zelf
• Suggestie: Annoteer private methoden @privatezodat minifiers dat annotatie herkennen effectief kan kleineren de methode namen
  • Geen significante tegenargumenten naar deze ene

Gemiddelde tegenargumenten toevoegen zichtbaarheid ondersteuning uitgezonden code:

• het probleem is dat JavaScript zelf niet zichtbaar modifiers - dit is niet typoscript's probleem
• Er is reeds een gevestigde patroon in de JavaScript-gemeenschap: prefix privé-eigenschappen en methoden met een underscore, die zegt "ga verder op eigen risico"
• wanneer Typescript ontwerpers zei dat echt private eigenschappen en methoden zijn niet "mogelijk", betekende dat ze "niet mogelijk is onder ons ontwerp beperkingen", met name:
  • De uitgezonden JS is idiomatisch
  • Boilerplate is minimaal
  • Geen extra overhead in vergelijking met normale JS OOP

Schrijfmachine Private functies zijn alleen toegankelijk in de klas. Net zoals

En het zal een fout tonen wanneer u probeert toegang te krijgen tot een initiatiefwetsvoorstel. Hier is het voorbeeld:

Opmerking: Het komt wel goed met javascript en beide functies zijn toegankelijk buiten.

Ik besef dat dit is een oudere discussie maar het kan nog steeds nuttig zijn om mijn oplossing voor het probleem van de zogenaamde private variabelen en methoden in een schrijfmachine te delen "lekken" uit in de openbare interface van de gecompileerde JavaScript-klasse.

Voor mij is dit probleem is puur cosmetisch, dat wil zeggen het is allemaal over de visuele rommel wanneer een instantie variabele wordt gezien in DevTools. Mijn oplossing is om prive groep verklaringen bij elkaar in een andere klasse die vervolgens wordt geconcretiseerd in de hoofdklasse en toegewezen aan een private(maar nog steeds voor iedereen zichtbaar in JS) variabele met een naam als __(dubbele underscore).

Voorbeeld:

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

Wanneer het myClassbijvoorbeeld wordt gezien in DevTools, in plaats van het zien van al zijn "privé" leden vermengd met echt publiek degenen (die kan erg visueel rommelig in de juiste refactored real-life code) zie je ze netjes gegroepeerd in het ingestorte __pand:

Veel mensen beweren dat dit niet mogelijk is als gevolg van beperkingen in JavaScript. Ik zou zeggen dat het beperkingen in creativiteit JavaScript-ontwikkelaars.

Ik ben het ontwikkelen van een bibliotheek nu dat staat privé en beschermd erfelijke leden van de klassen, evenals interfaces, etc. genoemd ClassJS. Bekijk het hier op GitHub .