Estoy mirando implementación de los miembros privados a máquina de escribir, y me parece un poco confuso. IntelliSense no permite al miembro privado de acceso, pero en JavaScript puro, todo está allí. Esto me hace pensar que el ST no implementa los miembros privados correctamente. ¿Alguna idea?
class Test{
private member: any = private member;
}
alert(new Test().member);
Al igual que con la comprobación de tipos, la privacidad de los miembros sólo se aplican dentro del compilador.
Una propiedad privada se implementa como una característica regular, y el código fuera de la clase no se le permite acceder a él.
Para hacer algo verdaderamente privado dentro de la clase, no puede ser un miembro de la clase, sería una variable local creado dentro de un ámbito de la función en el código que crea el objeto. Eso significaría que no se puede acceder a ella como un miembro de la clase, es decir, utilizando la thispalabra clave.
JavaScript es compatible con las variables privadas.
function MyClass() {
var myPrivateVar = 3;
this.doSomething = function() {
return myPrivateVar++;
}
}
A máquina de escribir esto se expresa de este modo:
class MyClass {
doSomething: () => number;
constructor() {
var myPrivateVar = 3;
this.doSomething = function () {
return myPrivateVar++;
}
}
}
EDITAR
Este enfoque sólo debe utilizarse MODERACIÓN en que sea absolutamente necesario. Por ejemplo, si usted necesita para almacenar en caché una contraseña temporal.
Hay costos de rendimiento en el uso de este patrón (irrelevantes de Javascript o imprenta) y sólo deben utilizarse cuando sea absolutamente necesario.
Una vez que el apoyo a WeakMap es más ampliamente disponible no es una técnica interesante detalla en el ejemplo # 3 aquí .
Se permite que los datos privados y evita los costos de funcionamiento de ejemplo Jason Evans al permitir que los datos sean accesibles a partir de métodos de prototipo en lugar de los métodos de instancia solamente.
La página aparece el apoyo del navegador ligado MDN WeakMap en Chrome 36, Firefox 6.0, Internet Explorer 11, Opera 23, y 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)();
}
}
}
Gracias a Sean Feldman por el enlace a la discusión oficial sobre este tema - ver su respuesta para el enlace.
He leído la discusión se vincula a, y aquí está un resumen de los puntos clave:
thissin algún tipo de solución@privatelo minifiers que reconocen que la anotación puede minify efectivamente los nombres de los métodos
En general argumentos en contra de la adición de soporte visibilidad en código emitido:
A máquina de escribir funciones privadas sólo son accesibles dentro de la clase. Me gusta
Y se mostrará un error al intentar acceder a un miembro privado. Aquí está el ejemplo:
Nota: Será bien con javascript y tanto la función son accesibles desde fuera.
Comprendo que esto es un debate antiguo, pero aún podría ser útil para compartir mi solución al problema de las variables supuestamente privados y métodos en un texto mecanografiado "fuga" hacia fuera en la interfaz pública de la clase de JavaScript compilado.
Para mí este tema es puramente cosmética, es decir, se trata de la confusión visual cuando una variable de instancia se ve en DevTools. Mi solución es agrupar las declaraciones privadas dentro de otra clase que se crea una instancia luego en la clase principal y se asigna a un private(pero todavía visibles públicamente en JS) variable con un nombre como __(subrayado doble).
Ejemplo:
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);
Cuando el myClassejemplo se ve en DevTools, en lugar de ver todos sus miembros "privadas" entremezclados con los verdaderamente públicos (que puede llegar a estar muy desordenado visualmente en el código de la vida real adecuadamente refactorizado) se les ve perfectamente agrupados dentro de la colapsada __propiedad:
Muchas personas afirman que esto no es posible debido a las limitaciones en JavaScript. Yo diría que es la creatividad limitaciones en los desarrolladores de JavaScript.
Estoy desarrollando una biblioteca en este momento que permite a los miembros heredables privados y protegidos de las clases, así como las interfaces, etc. ClassJS llamada. Compruébelo usted mismo aquí en GitHub .