Gépelt saját tagjai

JavaScript nem támogatja saját változókat.

function MyClass() {
    var myPrivateVar = 3;

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

Géppel ez kifejezhető úgy, mint:

class MyClass {

    doSomething: () => number;

    constructor() {
        var myPrivateVar = 3;

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

EDIT

Ez a megközelítés csak akkor kell használni takarékosan ahol feltétlenül szükséges. Például, ha szüksége van a cache jelszó átmenetileg.

Vannak teljesítmény költségek felhasználásával ezt a mintát (lényegtelen a JavaScriptet, vagy géppel), és csak akkor kell alkalmazni, ha feltétlenül szükséges.

Miután támogatása WeakMap szélesebb körben is elérhető egy érdekes technika példában részletezett # 3 Itt .

Ez lehetővé teszi a személyes adatokat és elkerüli a teljesítmény költségeit Jason Evans például lehetővé téve, hogy az adatok elérhetők prototípus módszerek helyett csak metódusai.

A linkelt MDN WeakMap az oldalon böngésző támogatja a Chrome 36, Firefox 6.0, IE 11, Opera 23, 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)();
    }
  }
}

Köszönet Sean Feldman a linket a hivatalos vita ebben a kérdésben - lásd a választ a link.

Olvastam a vitát ő kapcsolódik, és itt egy összefoglaló a legfontosabb pontok:

• Javaslat: saját tulajdonságok kivitelező
  • problémák: nem tudja elérni prototípus funkciók
• Javaslat: saját módszerek kivitelező
  • problémák: ugyanaz, mint a tulajdonságokkal, és akkor elveszíti a teljesítmény javára létrehozása funkció egyszer osztály a prototípus; ehelyett létrehoz egy másolatot a funkció minden egyes példánya
• Javaslat: add boilerplate absztrakt tulajdon hozzáférés és érvényesíteni láthatóság
  • problémák: nagy teljesítmény fölött; Géppel tervezték a nagy alkalmazások
• Javaslat: gépiratot már pakolások a kivitelező és a prototípus módszer definícióit egy lezárás; tegye saját módszereit és tulajdonságait ott
  • problémák üzembe magántulajdonoknak hogy lezárás: válnak statikus változók nincs egy per fokon
  • problémák üzembe saját módszerek, hogy a bezárásra: nem férnek hozzá thisanélkül, valamilyen megoldás
• Javaslat: automatikusan hozzáadja a saját változó nevét
  • ellenérvet: ez egy elnevezési, nem egy nyelvi konstrukció. Mángorló magad
• Javaslat: Annotate saját módszereket @privateúgy minifiers hogy elismerik, hogy kommentár hatékonyan minify a módszer neve
  • Nincs szignifikáns ellenérvet, hogy ez az egy

Összességében ellenérvet, hogy hozzá láthatóság támogatást kibocsátott kód:

• A probléma az, hogy a JavaScript önmagában nincs láthatósági módosítók - ez nem géppel probléma
• van már bevált minta a JavaScript közösség: előtagot saját tulajdonságok és módszerek egy aláhúzás, amely azt mondja: „folytassa a saját felelősségére”
• amikor gépelt tervezők azt mondta, hogy valóban saját tulajdonságok és módszerek nem „lehetséges”, akkor azt jelenti, hogy „nem lehet a mi tervezési korlátokat”, konkrétan:
  • A kibocsátott JS köznyelvi
  • Boilerplate minimális
  • Nincs további rezsi, mint a normál JS OOP

Géppel Egyéni funkciók csak elérhető az osztályon belül. Mint

És akkor megjelenik egy hibaüzenet, amikor megpróbál hozzáférni egy privát tagja. Itt egy példa:

Megjegyzés: Minden rendben lesz a javascript és a két funkció hozzáférhető kívülről.

Tudom, hogy ez egy régebbi vita, de még mindig hasznos lehet megosztani a megoldást arra a problémára, hogy a feltételezetten saját változók és módszerek egy géppel „szivárog” ki a nyilvános interfész a lefordított JavaScript osztályban.

Számomra ez a kérdés pusztán kozmetikai, azaz minden, ami a vizuális zűrzavar, amikor egy példány változó nézve DevTools. Én fix, hogy csoportos privát nyilatkozatok együttesen belül egy másik osztály, amelyet aztán futtatását az a fő osztály és hozzárendelt private(de még mindig nyilvánosan látható JS) változó egy nevet, mint __(dupla aláhúzás).

Példa:

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

Ha a myClasspéldány nézve DevTools, ahelyett, hogy minden „magán” tagjai keverednek valóban államiaknak (ami tud nagyon vizuálisan rendetlen Megfelelően refactored valós kód) látja őket szépen csoportosítva belül összeesett __tulajdonság:

Sokan állítják, hogy ez nem lehetséges, mert a korlátozások a JavaScript. Azt mondanám, hogy ez korlátozások JavaScript fejlesztői kreativitás.

Én fejlődő könyvtár most, amely lehetővé teszi a magán- és a védett örökölhető tagjai osztályok, valamint a felületek, stb nevű ClassJS. Ellenőrizze, hogy ki itt a GitHub .