2

我正在使用 TypeScript 0.9 和 Dojo 1.8。

尝试将以下 dojo 代码转换为 Typescript，但不是很成功。它使用 dojo.declare 创建一个类。还使用 this.inherited(arguments) 调用超类方法。有人可以帮我用 d.ts 文件转换它。

// Define class A
var A = declare(null, {
    myMethod: function(){
        console.log("Hello!");
    }
});

// Define class B
var B = declare(A, {
    myMethod: function(){
        // Call A's myMethod
        this.inherited(arguments); // arguments provided to A's myMethod
        console.log("World!");
    }
});

多重继承的一个更复杂的情况是：

define(["dojo/_base/declare",
    "dijit/_Widget",
    "dijit/_TemplatedMixin",
    "dijit/_WidgetsInTemplateMixin".
    "text!/some.html"],
    function (dojo_declare, _Widget, _TemplateMixin, _WidgetsInTemplateMixin,  template) {
        var mod =
        {

            templateString: template,
            constructor: function () {
            },
            postCreate: function () {
                // do something here....
                this.inherited(arguments);
            }
        };

        return dojo_declare("sample", [_Widget, _TemplateMixin, _WidgetsInTemplateMixin], mod);
    });
4

4 回答 4

0

我相信你尽可能接近。您可以在 .d.ts 文件中手动编写接口并将类型分配给构造的实例，但是由于 dojo 继承与 typescript 继承不兼容，因此您无法到达您想去的地方。似乎要让它工作，我们必须能够告知 typescript 我们所说的“扩展”是什么意思，例如，一个编译器指令说 objectmodel=dojo。

于 2013-06-29T14:03:32.397 回答
0

如果您尝试为现有的 JavaScript 代码创建声明文件，您需要这样的内容：

declare class A {
    myMethod(): void;
}

declare class B extends A {}

要将代码转换为 TypeScript，您需要这样的东西：

class A {
    myMethod(): void {
        console.log("Hello!");
    }
}

class B extends A {
    myMethod(): void {
        super.myMethod();
        console.log("World!");
    }
}

不同之处在于一个包括实现，另一个只是签名。

在我自己将一些 dojo 代码转换为 TypeScript 之后，我可以告诉您标准 TypeScript 类可以使用 dojo.declare 类进行扩展，但您不能使用 TypeScript 类扩展 dojo.declare 类。Dojo 做了很多有趣的事情，只有它知道如何处理。

于 2013-06-28T18:30:30.030 回答
0

在 dojojs 中declare，函数是创建类的一种解决方法，因此接下来的代码：

// Define class A
var A = declare(null, {
    myMethod: function(){
        console.log("Hello!");
    }
});

// Define class B
var B = declare(A, {
    myMethod: function(){
        // Call A's myMethod
        this.inherited(arguments); // arguments provided to A's myMethod
        console.log("World!");
    }
});

应该相当于：

// Define class A
class A {
    myMethod() {
        console.log("Hello!");
    }
}

// Define class B
class B extends A {
    myMethod() {
        // Call A's myMethod
        super.myMethod(); // arguments provided to A's myMethod
        console.log("World!");
    }
});

对于第二个示例中显示的多重继承，Typescript 本身并不支持它。这意味着您应该使用辅助函数来执行此操作。例如代码：

define(["dojo/_base/declare",
    "dijit/_Widget",
    "dijit/_TemplatedMixin",
    "dijit/_WidgetsInTemplateMixin".
    "text!/some.html"],
    function (dojo_declare, _Widget, _TemplateMixin, _WidgetsInTemplateMixin,  template) {
        var mod =
        {

            templateString: template,
            constructor: function () {
            },
            postCreate: function () {
                // do something here....
                this.inherited(arguments);
            }
        };

        return dojo_declare("sample", [_Widget, _TemplateMixin, _WidgetsInTemplateMixin], mod);
});

你可以做：

import declare = require("dojo/_base/declare");
import _Widget = require("dijit/_Widget");
import _TemplateMixin = require("dijit/_TemplatedMixin");
import _WidgetsInTemplateMixin = require("dijit/_WidgetsInTemplateMixin");
import template = require("text!/some.html");

// Most likely you should extend _Widget since it is the one which contains  
// the method `postCreate`
class Sample extends _Widget implements _TemplateMixin, _WidgetsInTemplateMixin {

  templateString: string = template;

  constructor() {}

  postCreate() {
    // do something here....
    super.postCreate(arguments);
  }

  // here you should put the overridden methods from the `implements` statement
  buildRendering: Function;
  destroyRendering: Function;
  getCachedTemplate: Function;
  //...
}

// This line is possibly wrong
applyMixins (Sample, [_TemplateMixin, _WidgetsInTemplateMixin]);
</pre>

函数applyMixins应该如下所示：

function applyMixins(derivedCtor: any, baseCtors: any[]) {
    baseCtors.forEach(baseCtor => {
        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
             if (name !== 'constructor') {
                derivedCtor.prototype[name] = baseCtor.prototype[name];
            }
        });
    });
}

PD：declareTypescript 中的关键字是用于创建定义文件（*.d.ts）而不是用于声明类。如果你想公开任何类、函数或变量，你应该在它们前面加上关键字export。

于 2016-07-07T03:13:24.413 回答
0

嘿，我希望派对还不算太晚。

使用 dojo 和 typescript 需要您拥有 dojo 的类型定义文件，以便您可以使用 typescript 提供的出色类型检查。

要获得这些，您可以使用 npm install @types/dojo 参考https://www.npmjs.com/package/@types/dojo

有了这个，您将能够访问道场类型。

import * as dojoDeclare from "dojo/_base/declare";

然后你可以继续使用声明。

let dojoBootstrapProgressBar = dojoDeclare("BootstrapProgressBar.widget.BootstrapProgressBar", [_WidgetBase], (function(Source: any) {
let result: any = {};
for (let i in Source.prototype) {
    if (i !== "constructor" && Source.prototype.hasOwnProperty(i)) {
        result[i] = Source.prototype[i];
    }
}
return result;
} (BootstrapProgressBar)));

export = BootstrapProgressBar;
于 2016-10-28T08:23:15.137 回答