Strojopisem členy soukromé

JavaScript nepodporuje soukromé proměnné.

function MyClass() {
    var myPrivateVar = 3;

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

Strojopisem by to být vyjádřeno jako tak:

class MyClass {

    doSomething: () => number;

    constructor() {
        var myPrivateVar = 3;

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

UPRAVIT

Tento přístup by měl být používán pouze zřídka , pokud je to nezbytně nutné. Například pokud potřebujete dočasně mezipaměti heslo.

Tam jsou náklady na výkonnostní použití tohoto vzoru (irelevantní Javascript nebo na psacím stroji) a měl by být použit, pokud to nezbytně nutné pouze.

Jakmile podpora WeakMap je ve větší míře k dispozici je zajímavá technika je podrobně popsáno v příkladu č.3 zde .

Umožňuje soukromých dat a eliminuje náklady na výkonnostní Jason Evans například tím, že údaje, které mají být přístupné z metod prototypu namísto pouhého metody instance.

Propojený MDN WeakMap strana vypíše podpora prohlížeče Chrome na 36, ​​Firefox 6.0, Internet Explorer 11, Opera 23 a 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)();
    }
  }
}

Díky Sean Feldman za odkaz na oficiální diskuse na toto téma - viz jeho odpověď na tento odkaz.

Čtu diskuse on spojené s, a tady je shrnutí klíčových bodů:

• Tip: soukromé nemovitosti v konstruktoru
  • Problémy: nelze přistupovat z prototypových funkcí
• Tip: Soukromé metody konstruktoru
  • Problémy: stejné jako s vlastnostmi, navíc ztratíte výhodu výkonu vytvořit funkci jednou za třídu v prototypu; místo toho vytvořit kopii funkce pro každou instanci
• Tip: přidat často používaný k abstraktnímu přístupu nemovitostí a prosazovat viditelnost
  • Problémy: major výkon nad hlavou; Strojopis je určen pro velké aplikace
• Návrh: psacím stroji již obtéká definice konstruktoru a metody prototyp v uzávěru; dát soukromé metody a vlastnosti zde
  • Problémy s uvedením soukromé vlastnosti v tomto uzávěru: stanou statické proměnné; není ani jeden na stupni
  • Problémy s uvedením vlastní metody v tomto uzávěru: nemají přístup k thisbez nějakého druhu řešení
• Tip: automaticky mandl soukromé názvy proměnných
  • protiargumenty: to je pojmenování, není jazyk konstrukt. Mandl sami
• Tip: komentovat soukromé metody se @privatetak minifiers, které uznávají, že poznámky mohou účinně minify názvy metod
  • Žádné významné protiargumenty na tenhle

Celkové protiargumenty k přidání podpory viditelnost v emitovaného kód:

• Problém je, že samo o sobě JavaScript nemá modifikátory viditelnosti - to není strojopisem problémem
• je již zavedený model v komunitě JavaScriptu: předpona soukromé vlastnosti a metody s podtržítkem, který říká, „postupovat na vlastní nebezpečí“
• Při strojopisem návrháři řekl, že opravdu soukromé vlastnosti a metody nejsou „možné“, které znamená „není možné v našich konstrukčních omezeních“, konkrétně:
  • Emitované JS je idiomatická
  • Často používaný je minimální
  • Žádná dodatečná režie v porovnání s běžným JS OOP

Strojopisem soukromé funkce jsou přístupné pouze uvnitř třídy. Jako

A při pokusu o přístup k soukromé člen ukáže chybu. Zde je příklad:

Poznámka: Bude to v pohodě s javascript a obě funkce jsou přístupné zvenčí.

Uvědomujeme si, že se jedná o starší diskuse, ale to by mohlo být ještě užitečné podělit o své řešení problému z údajně soukromých proměnných a metod ve strojopisu „prosakuje“ ven do veřejné rozhraní kompilované třídy JavaScriptu.

Pro mě je tato otázka je čistě kosmetická, to znamená, že je to všechno o vizuální nepořádek, když je proměnná instance pohledu v Devtools. My fix je skupina soukromých prohlášení spolu uvnitř jiné třídy, která je pak instance v hlavní třídě a je přiřazen k některé private(ale stále veřejně viditelné v JS) proměnné s názvem, jako je __(dvojité podtržení).

Příklad:

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

Je-li myClassse například zobrazit v Devtools místo vidět všechny své „soukromé“ členů smíchané s opravdu ty veřejnosti (což může být velmi vizuálně chaotický správně refactored reálném kódu) je vidíte přehledně rozděleny uvnitř zhroucené __vlastnosti:

Mnoho lidí tvrdí, že to není možné z důvodu omezení v JavaScriptu. Řekl bych, že je to omezení, kreativitu vývojářům JavaScriptu.

Jsem rozvoj knihovny právě teď, která umožňuje soukromé a chráněné dědičná členy tříd, stejně jako rozhraní, atd. Nazývá ClassJS. Podívejte se sem na GitHub .