typescript - 你如何在 TypeScript 的“window”上显式设置一个新属性？

Question

我通过显式设置属性为我的对象设置全局命名空间window。

window.MyNamespace = window.MyNamespace || {};

TypeScript 强调MyNamespace并抱怨：

“窗口”类型的值上不存在属性“MyNamespace”任何“

MyNamespace我可以通过声明为环境变量并删除显式性来使代码工作，window但我不想这样做。

declare var MyNamespace: any;

MyNamespace = MyNamespace || {};

我怎样才能window留在那里并让 TypeScript 开心呢？

作为旁注，我发现 TypeScript 抱怨特别有趣，因为它告诉我那window是any绝对可以包含任何东西的类型。

score 1128 · Accepted Answer

我刚刚在另一个 Stack Overflow question's answer中找到了答案。

declare global {
    interface Window { MyNamespace: any; }
}

window.MyNamespace = window.MyNamespace || {};

基本上，您需要扩展现有window接口来告诉它您的新属性。

score 515 · Accepted Answer

要保持动态，只需使用：

(<any>window).MyNamespace

请注意，这可能不适用于 TSX，因为编译器可能认为<any>是 TSX 元素。查看此答案以了解与 TSX 兼容的类型断言。

score 267 · Accepted Answer

使用 Svelte 还是 TSX？其他答案都不适合我。

这是我所做的：

(window as any).MyNamespace

score 223 · Accepted Answer

从 TypeScript ^3.4.3 开始，此解决方案不再有效

或者...

你可以输入：

window['MyNamespace']

而且您不会收到编译错误，它的工作方式与输入相同window.MyNamespace。

score 110 · Accepted Answer

全局变量是“邪恶的” :) 我认为获得可移植性的最佳方法是：

首先你导出界面：（例如，./custom.window.ts）

export interface CustomWindow extends Window {
    customAttribute: any;
}

二、你进口

import {CustomWindow} from './custom.window.ts';

三、用CustomWindow强制转换全局变量window：

declare let window: CustomWindow;

这样，如果您将它与窗口对象的现有属性一起使用，则在不同的 IDE 中也没有红线，所以最后尝试：

window.customAttribute = 'works';
window.location.href = '/works';

使用 TypeScript 2.4.x 和最新版本进行测试！

score 81 · Accepted Answer

接受的答案是我以前使用的答案，但是使用 TypeScript 0.9.* 它不再有效。接口的新定义Window似乎完全取代了内置定义，而不是对其进行扩充。

我已经开始这样做了：

interface MyWindow extends Window {
    myFunction(): void;
}

declare var window: MyWindow;

更新：使用 TypeScript 0.9.5，接受的答案再次起作用。

score 79 · Accepted Answer

对于那些使用Angular CLI的人来说，这很简单：

文件src/polyfills.ts

declare global {
  interface Window {
    myCustomFn: () => void;
  }
}

文件my-custom-utils.ts

window.myCustomFn = function () {
  ...
};

如果您使用的是IntelliJ IDEA，您还需要在 IDE 中更改以下设置，然后才能使用新的polyfill：

> File
> Settings
> Languages & Frameworks
> TypeScript
> check 'Use TypeScript Service'.

score 59 · Accepted Answer

如果需要window使用需要使用的自定义类型来扩展对象import，可以使用以下方法：

窗口.d.ts

import MyInterface from './MyInterface';

declare global {
    interface Window {
        propName: MyInterface
    }
}

请参阅手册的“声明合并”部分中的全局增强。

score 44 · Accepted Answer

大多数其他答案并不完美。

其中一些只是抑制了 show 的类型推断。
其他一些只关心全局变量作为命名空间，而不是接口/类

今天早上我也遇到了类似的问题。我在 Stack Overflow 上尝试了很多“解决方案”，但没有一个绝对不会产生类型错误，并且在 IDE（WebStorm或Visual Studio Code）中启用了触发类型跳转。

最后，来自允许将模块定义声明为全局变量 #3180

我找到了一个合理的解决方案来为作为接口/类和命名空间的全局变量附加类型。

示例如下：

// typings.d.ts
declare interface Window {
    myNamespace?: MyNamespace & typeof MyNamespace
}

declare interface MyNamespace {
    somemethod?()
}

declare namespace MyNamespace {
    // ...
}

上面的代码将命名空间MyNamespace和接口的类型MyNamespace合并到全局变量myNamespace（window的属性）中。

score 40 · Accepted Answer

创建一个名为的文件global.d.ts，例如，/src/@types/global.d.ts然后定义一个接口，如：

interface Window {
  myLib: any
}

参考：全球 .d.ts

score 35 · Accepted Answer

我不需要经常这样做。我遇到的唯一情况是使用Redux DevTools和中间件。

我只是做了：

const composeEnhancers = (window as any).__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;

或者你可以这样做：

let myWindow = window as any;

进而myWindow.myProp = 'my value';

score 19 · Accepted Answer

在找到答案后，我认为此页面可能会有所帮助：

全局增强

我不确定声明合并的历史，但它解释了为什么以下可以工作。

declare global {
    interface Window { MyNamespace: any; }
}

window.MyNamespace = window.MyNamespace || {};

score 16 · Accepted Answer

TypeScript 不对字符串属性执行类型检查。

window["newProperty"] = customObj;

理想情况下，应该避免全局变量场景。我有时用它来调试浏览器控制台中的对象。

score 16 · Accepted Answer

从 3.4 版开始，TypeScript 已支持globalThis. 请参阅globalThis 的类型检查。

从上面的链接：

// in a global file:
var abc = 100;
// Refers to 'abc' from above.
globalThis.abc = 200;
window.abc = 300; // window object can also be used.

操场

“全局”文件是没有任何导入/导出语句的文件。所以声明var abc;可以写成.d.ts。

score 15 · Accepted Answer

使用 create-react-app v3.3 我发现实现这一点的最简单方法是扩展Window自动生成的类型react-app-env.d.ts：

interface Window {
    MyNamespace: any;
}

score 14 · Accepted Answer

如果您使用的是TypeScript 定义管理器，请按照以下步骤操作！

npm install typings --global

创建typings/custom/window.d.ts：

interface Window {
  MyNamespace: any;
}

declare var window: Window;

安装您的自定义类型：

typings install file:typings/custom/window.d.ts --save --global

完毕！用它！TypeScript 不会再抱怨了：

window.MyNamespace = window.MyNamespace || {};

score 14 · Accepted Answer

如果您使用的是 TypeScript 3.x，则可以省略declare global其他答案中的部分，而只需使用：

interface Window {
  someValue: string
  another: boolean
}

在使用 TypeScript 3.3、Webpack和TSLint时，这对我有用。

score 13 · Accepted Answer

使用

window["MyNamespace"] = window["MyNamespace"] || {};

应该没问题，因为它使用的是字符串属性，但是如果你真的想要一个单独的窗口并组织你的代码，你可以扩展窗口对象：

interface MyNamespacedWindow extends Window {
    MyNamespace: object;
}

declare var window: MyNamespacedWindow;

score 10 · Accepted Answer

首先，您需要在当前范围内声明窗口对象。因为 TypeScript 想知道对象的类型。由于窗口对象是在其他地方定义的，因此您不能重新定义它。

但是你可以声明如下：

declare var window: any;

这不会重新定义 window 对象，也不会创建另一个具有 name 的变量window。这意味着窗口是在其他地方定义的，您只是在当前范围内引用它。

然后您可以简单地通过以下方式引用您的 MyNamespace 对象：

window.MyNamespace

window或者您可以简单地通过以下方式在对象上设置新属性：

window.MyNamespace = MyObject

现在 TypeScript 不会抱怨了。

score 9 · Accepted Answer

供参考（这是正确答案）：

在.d.ts定义文件中

type MyGlobalFunctionType = (name: string) => void

如果您在浏览器中工作，您可以通过重新打开 Window 的界面将成员添加到浏览器的窗口上下文中：

interface Window {
  myGlobalFunction: MyGlobalFunctionType
}

Node.js 的想法相同：

declare module NodeJS {
  interface Global {
    myGlobalFunction: MyGlobalFunctionType
  }
}

现在您声明根变量（实际上将存在于窗口或全局上）：

declare const myGlobalFunction: MyGlobalFunctionType;

然后在一个常规.ts文件中，但作为副作用导入，您实际上实现了它：

global/* or window */.myGlobalFunction = function (name: string) {
  console.log("Hey !", name);
};

最后在代码库的其他地方使用它，其中之一是：

global/* or window */.myGlobalFunction("Kevin");

myGlobalFunction("Kevin");

score 7 · Accepted Answer

创建一个扩展 Window 的自定义接口，并将您的自定义属性添加为可选。

然后，让 customWindow 使用自定义界面，但重视与原始窗口。

它适用于 TypeScript 3.1.3。

interface ICustomWindow extends Window {
  MyNamespace?: any
}

const customWindow:ICustomWindow = window;

customWindow.MyNamespace = customWindow.MyNamespace {}

score 6 · Accepted Answer

对于那些想要在window对象上设置计算或动态属性的人，您会发现使用该方法是不可能的declare global。澄清这个用例

window[DynamicObject.key] // Element implicitly has an 'any' type because type Window has no index signature

你可能会尝试做这样的事情

declare global {
  interface Window {
    [DyanmicObject.key]: string; // error RIP
  }
}

以上会出错。这是因为在 TypeScript 中，接口不能很好地处理计算属性，并且会抛出类似的错误

A computed property name in an interface must directly refer to a built-in symbol

为了解决这个问题，你可以接受casting windowto的建议，<any>这样你就可以做到

(window as any)[DynamicObject.key]

score 2 · Accepted Answer

我今天想在 Angular (6) 库中使用它，我花了一段时间才让它按预期工作。

为了让我的库使用声明，我必须使用d.ts文件的扩展名来声明全局对象的新属性。

所以最后，该文件最终得到如下内容：

/path-to-angular-workspace/angular-workspace/projects/angular-library/src/globals.d.ts

一旦创建，不要忘记在你的public_api.ts.

那是为我做的。

score 2 · Accepted Answer

完整和简短的答案

1-将`typeRoots`属性添加到`tsconfig.json`：

{
  "compilerOptions": {
    ...
    "typeRoots": ["src/@types", "node_modules/@types"]
    ...
  }
}

2- 扩展`Window`型

// file: src/@types/global.d.ts

declare global {
    interface Window { customProperty: <type>; }
}

score 2 · Accepted Answer

2

(window as { test: string } & Window & typeof globalThis).test = `Hello World`;

于 2022-01-16T07:47:20.917 回答

score 2 · Accepted Answer

// In typings.d.ts(is Global)
export declare global {
    interface Window {
        __PUBLIC__: string;
    }
}

score 0 · Accepted Answer

TypeScript 会阻止在未分配具有所需属性或已分配给的类型的情况下访问对象any，因此您可以使用可选链接：

window?.MyNamespace =  'value'

score 0 · Accepted Answer

0

我使用没有声明。我的示例如下所示：

于 2022-02-09T10:21:03.883 回答

typescript - 你如何在 TypeScript 的“window”上显式设置一个新属性？

28 回答 28

完整和简短的答案

1-将typeRoots属性添加到tsconfig.json：

2- 扩展Window型

Related

Reference

1-将`typeRoots`属性添加到`tsconfig.json`：

2- 扩展`Window`型