El manuscrito - la separación de código de salida

Question

estoy tratando de máquina y me resulta muy útil.

Tengo una bastante grande proyecto y yo estaba considerando la posibilidad de reescritura utilizando el manuscrito.El principal problema aquí es la siguiente:

archivo A. ts:

class A extends B {
    // A stuff
}

el archivo B. ts:

class B {
    // B stuff
}

Si puedo compilar A. ts con este comando:

tsc --out compiledA.js A.ts

Voy a obtener el error del compilador causa de la que no sabe cómo la amenaza de la "B" después de que se extiende.

Así, una "solución" sería incluido en A. ts (como primera línea de código):

/// <reference path="./B.ts" />

Compilar de nuevo A. ts con el mismo comando

tsc --out compiledA.js A.ts

El resultado será compiledA.js contiene tanto B. ts y A. ts código.( lo cual puede ser muy agradable )

En mi caso, sólo tengo que compilar el A. ts código en la compiledA.js archivo y no quiero que el B. ts cosas para estar ahí.

De hecho, lo que yo quiero es:

• tsc-por A. js A. ts => compilar sólo la A. ts cosas
• tsc-por B. js B. ts => compilar sólo el B. ts cosas

Puedo hacerlo por la eliminación de la "extiende" la palabra clave, pero haciendo que me perderá la mayor parte de la transcripción de la bondad.

Alguien puede kanika mí si hay una manera de hacer esto ?

Answer 1

Después de una investigación, descubrí que el problema se introdujo por el argumento --outh en el compilador.

@Silent__ Piedra Solución funciona bien si desea lidiar con los módulos.Si no lo es necesario, deberá usar la declaración REQUIERNA (ver la pregunta) y luego compilar el archivo "main.ts" sin el argumento --out

Answer 2

EDITAR: Como Andrea señala, si se omite el --out el parámetro que va a obtener el comportamiento esperado, es decir,ninguna combinación de archivos de origen.Voy a dejar esta solución alternativa a continuación en caso que puede ayudar a alguien.

---

Yo creo que usted tendrá que usar el módulo externo de la sintaxis (CommonJS o AMD) para hacer esto.

Usando tu ejemplo:

una.ts

import B = module("b")

class A extends B.B {
    // A stuff
}

b.ts

export class B {
    // B stuff
}

Compilar con tsc --out compiledA.js A.ts.

Esto se traduce en a.js la importación de b.js el uso de la CommonJS sistema.Los archivos resultantes este aspecto:

una.ts

var __extends = this.__extends || function (d, b) {
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
}
var B = require("./b")
var A = (function (_super) {
    __extends(A, _super);
    function A() {
        _super.apply(this, arguments);

    }
    return A;
})(B.B);

b.ts

var B = (function () {
    function B() { }
    return B;
})();
exports.B = B;