nodejs - typescript version

Variables globales mecanografiadas

Question

¿Existe una manera conveniente de tener variables globales accesibles dentro de los módulos, sin errores de compilación, es decir, CANVAS_WIDTH se usa a continuación?

 export class Bullet {
x: number = 22;
y: number = 22;
constructor (speed: number) {
this.xVelocity = speed;
}
inBounds() {
return this.x >= 0 && this.x <= CANVAS_WIDTH &&
this.y >= 0 && this.y <= CANVAS_HEIGHT;
};
}
}

Answer 1

Debe definir esas propiedades como estáticas, luego puede acceder a ellas fácilmente de esta manera,

export class Game {
static canvas: JQuery;
static CANVAS_WIDTH: number;
static CANVAS_HEIGHT: number;
bullet: Bullet;
constructor(canvasElem: JQuery) {
Game.canvas = canvasElem;
Game.CANVAS_WIDTH = Game.canvas.width();
Game.CANVAS_HEIGHT = Game.canvas.height();
}
}
export class Bullet {
x: number = 22;
y: number = 22;
public inBounds() {
// accessing static properties
return this.x >= 0 && this.x <= Game.CANVAS_WIDTH && this.y >= 0 && this.y <= Game.CANVAS_HEIGHT;
}
}

Esto compila a:

define(["require", "exports"], function(require, exports) {
var Game = (function () {
function Game(canvasElem) {
Game.canvas = canvasElem;
Game.CANVAS_WIDTH = Game.canvas.width();
Game.CANVAS_HEIGHT = Game.canvas.height();
}
return Game;
})();
exports.Game = Game;
var Bullet = (function () {
function Bullet() {
this.x = 22;
this.y = 22;
}
Bullet.prototype.inBounds = function () {
// accessing static properties
return this.x >= 0 && this.x <= Game.CANVAS_WIDTH && this.y >= 0 && this.y <= Game.CANVAS_HEIGHT;
};
return Bullet;
})();
exports.Bullet = Bullet;
});
//# sourceMappingURL=dhdh.js.map

Answer 2

Este es un ejemplo artificial, pero en lugar de tratar de ir al alcance global, puede usar el alcance del módulo para encerrar una variable que se usará de varias clases.

module MyModule {
var x: number = 5;
export class FirstClass {
doSomething() {
x = 10;
}
}
export class SecondClass {
showSomething() {
alert(x.toString());
}
}
}
var a = new MyModule.FirstClass();
a.doSomething();
var b = new MyModule.SecondClass();
b.showSomething();

Aquí se aplican todas las reglas habituales sobre varias cosas que utilizan la misma variable: no desea imponer un orden particular de eventos en el código de llamada.

Compila a:

var MyModule;
(function (MyModule) {
var x = 5;
var FirstClass = (function () {
function FirstClass() {
}
FirstClass.prototype.doSomething = function () {
x = 10;
};
return FirstClass;
})();
MyModule.FirstClass = FirstClass;
var SecondClass = (function () {
function SecondClass() {
}
SecondClass.prototype.showSomething = function () {
alert(x.toString());
};
return SecondClass;
})();
MyModule.SecondClass = SecondClass;
})(MyModule || (MyModule = {}));
var a = new MyModule.FirstClass();
a.doSomething();
var b = new MyModule.SecondClass();
b.showSomething();