Question

通常我使用语法

module Palmare.Controllers {   
    export class layerPosizioni {

要定义类的模块名称并在typescript级别处理为命名空间，但这样我就无法在单个模块级别定义依赖项，而且我必须添加应用程序模块级别

var appModule = angular.module('myApp', ['ui.bootstrap','ngGrid','ngSanitize']);

我必须在那里添加所有的家属是否可以避免这种情况并将依赖项放在模块级别？

目前我在一个命名空间中声明了一些角度控制器，我需要在它们中使用ui.bootstrap，当我打开程序的其他部分时我不需要声明这种依赖关系，所以我想要在需要时声明这种依赖。

Answer 1

注意：我刚刚开始使用打字稿，但是我会试一试因为看起来很幸运得到答案

@any：，随时纠正我或给出更好的答案

ts模块中的

是一种抽象，可能意味着不同的东西取决于它的使用方式。

但它总是一个模块

在internal / external / ext-amd / ext-commonjs中根据框架

，还可以不同地获取/提供/解析依赖关系

除此之外，（AFAIK）ts没有专门针对角度情景进行观察因此，如果您想使用模块级依赖项你将需要使用某种“要求”。

在Nodejs或requirejs中（最有可能） ...或者提供require函数以满足ext依赖性的任何东西这也意味着你还需要提供角度模块并用它自己调整角度。

可以在

中观察到beahviour

// aModule.ts
module myModule {
export class clazz{
    constructor(myDep) {
         // Content
        }
    }
}

使用cmd编译：tsc aModule.ts 注意：无开关

//then in aModule.js
var myModule;
(function (myModule) {
    var clazz = (function () {
        function clazz(myDep) {
            // Content
        }
        return clazz;
    })();
    myModule.clazz = clazz;
})(myModule || (myModule = {}));

或使用cmd编译：tsc -m amd 你有sModule.js 注意：没有变化

var myModule;
    (function (myModule) {
        var clazz = (function () {
            function clazz(myDep) {
                // Content
            }
            return clazz;
        })();
        myModule.clazz = clazz;
    })(myModule || (myModule = {}));

但是如果aModule.ts你添加了导出关键字

    export module myModule {
        export class clazz{
            constructor(myDep) {            
             // Content
            }
        }
    }

用cmd: tsc -m amd编译时

你得到sModule.js 但现在该模块依赖于＆＃34;要求＆＃34;和＆＃34;出口＆＃34;

define(["require", "exports"], function(require, exports) {
    (function (myModule) {
        var clazz = (function () {
            function clazz(myDep) {
                // Content
            }
            return clazz;
        })();
        myModule.clazz = clazz;
    })(exports.myModule || (exports.myModule = {}));
    var myModule = exports.myModule;
});

但是如果... aModule.ts 告诉我们使用全局

的Typescript

/// <reference path='../typings/underscore/underscore.d.ts' />
declare var _:UnderscoreStatic;
export module myModule {
    export class clazz{
        collection:any[];
        findWhere(what){
            return _.findWhere(this.collection, what);
        }
        constructor(myDep) {        
             // Content          
        }
    }
}

然后作为Js：我们得到一个具有外部依赖的模块注意它也可以在没有-m编译开关的情况下完成就你声明var而言，你总是可以期待全局和打字稿将毫不犹豫地兑现

define(["require", "exports"], function(require, exports) {
    (function (myModule) {
        var clazz = (function () {
            function clazz(myDep) {
                // Content
            }
            clazz.prototype.findWhere = function (what) {
        //Warning: Must be a Global!
                return _.findWhere(this.collection, what);
            };
            return clazz;
        })();
        myModule.clazz = clazz;
    })(exports.myModule || (exports.myModule = {}));
    var myModule = exports.myModule;
});

但作为一种真正的依赖，我们可以说出来我们需要对我们的模块进行外部依赖注意：没有声明，但需要

var _:UnderscoreStatic = require('underscore');
export module myModule {
    export class clazz{
        collection:any[];
        findWhere(what){
            return _.findWhere(this.collection, what);
        }
        constructor(myDep) {        
             // Content          
        }
    }
}

然后作为JS，我们要求在模块内部依赖＆＃39;

define(["require", "exports"], function(require, exports) {
    var _ = require('underscore');
    (function (myModule) {
        var clazz = (function () {
            function clazz(myDep) {
                // Content
            }
            clazz.prototype.findWhere = function (what) {
                return _.findWhere(this.collection, what);
            };
            return clazz;
        })();
        myModule.clazz = clazz;
    })(exports.myModule || (exports.myModule = {}));
    var myModule = exports.myModule;
});

//NOTE!!!!: Beacuse of asynchronous evil black magic involved 
// require wont find the dependency 
// this, will most certainly,  Not work 
// as it seems TS should be transpiling (Or I dont know the magical swicth)
// define('require','exports', 'underscore' , (require,exports,_)=> { /*code...*/})
// instead of what it did, 
// and you will need to type it your self
// which is not a biggy , because <almost>any valid JS is valid TS;
// so as TS:

/// <reference path='require.d.ts' /> 
define("require","exports","underscore", (require,exports,_:UnderscoreStatic)=> {
    /* now we can use _ if we got it right on requirejs config.path and shim*/  
});

注意：如果我们使用＆＃39; -m commonjs＆＃39;代替它仍将使用require但现在取决于节点而不是requirejs 正如你所看到的那样，它有所不同

var _ = require('underscore');
(function (myModule) {
    var clazz = (function () {
        function clazz(myDep) {
            // Content
        }
        clazz.prototype.findWhere = function (what) {
            return _.findWhere(this.collection, what);
        };
        return clazz;
    })();
    myModule.clazz = clazz;
})(exports.myModule || (exports.myModule = {}));
var myModule = exports.myModule;

Answer 2

您可以从打字稿模块中导出controller，service，factory等方法。

module app.controller {

    var controllerModule = angular.module('app.controller', []);

    export var controller = controllerModule.controller;
}

然后在您的控制器文件中：

module app.controller {

    export class SomeController {

        static $inject = ['$q'];
        contructor(private $q: ng.IQService) {}
        . . .
    }

    controller('SomeController', SomeController);
}

因此，在我们的控制器文件中，我们调用导出的控制器方法向Angulars IoC容器注册。

如何在TypeScript中的模块级别定义依赖项

2 个答案: