Jak se explicitně nastavit novou vlastnost na `window` na stroji?

Aby to dynamický, stačí použít:

(<any>window).MyNamespace

Nebo...

stačí napsat:

window['MyNamespace']

a jste zvyklý dostat chybu kompilace a funguje to stejně jako psaní window.MyNamespace

Používání TSX? Žádný z dalších odpovědí pracovali pro mě.

Tady je to, co jsem udělal:

(window as any).MyNamespace

Akceptovanou odpověď je to, co jsem používal, ale s strojopisem 0,9. * To již funguje. Nová definice Windowrozhraní Zdá se, že zcela nahradí vestavěný definice namísto rozšiřovat ji.

Vzal jsem si dělat toto místo:

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

declare var window: MyWindow;

UPDATE: S strojopisem 0.9.5 přijímaný odpověď je opět v provozu.

Pokud budete potřebovat prodloužit windowobjekt s vlastní typ, který vyžaduje použití importmůžete použít následující postup:

window.d.ts

import MyInterface from './MyInterface';

declare global {
    interface Window {
        propName: MyInterface
    }
}

Viz ‚Globální Zvětšení‘ v ‚Prohlášení Sloučení‘ části příručky: https://www.typescriptlang.org/docs/handbook/declaration-merging.html#global-augmentation

Global jsou „zlí“ :) Myslím, že nejlepší způsob, jak mít i přenositelnost je:

První exportu rozhraní: (např ./custom.window.ts)

export interface CustomWindow extends Window {
    customAttribute: any;
}

Druhý importu

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

Třetí cast globální okno var s CustomWindow

declare let window: CustomWindow;

Tímto způsobem nemáte také červenou čáru v jiném vývojovém prostředí, pokud používáte s neexistujícími atributy okna objektu, takže na konci pokusu:

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

Testováno s strojopisem 2.4.x

Zde je návod, jak to udělat, pokud používáte strojopisem Definition správce !

npm install typings --global

Vytvořit typings/custom/window.d.ts:

interface Window {
  MyNamespace: any;
}

declare var window: Window;

Nainstalovat vlastní psaní:

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

Hotovo, použijte ji ! Strojopisem nebudou stěžovat už:

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

Nepotřebuju, aby to velmi často, jediný případ, měl jsem byl při používání Redux Devtools s middleware.

Prostě jsem udělal:

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

Nebo byste mohli udělat:

let myWindow = window as any;

a pak myWindow.myProp = 'my value';

Většina ostatních odpovědí nejsou dokonalé.

• Některé z nich prostě potlačit typu závěr pro obchod.
• Někteří z ostatních se stará jen o globální proměnné jako jmenný prostor, ale ne jako rozhraní / třída

Také jsem se setkat s podobným problémem dnes ráno. Snažil jsem se tolik „řešení“ na SO, ale žádný z nich vyrobit žádnou chybu typu absolutně a umožnit spuštění typu skákání v IDE (webstorm nebo vscode).

A konečně, odtud

https://github.com/Microsoft/TypeScript/issues/3180#issuecomment-102523512

Jsem najít rozumné řešení pro připevnění typizací pro globální proměnné, který působí jako rozhraní / třídu a názvů obou .

Příklad je níže:

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

declare interface MyNamespace {
    somemethod?()
}

declare namespace MyNamespace {
    // ...
}

Nyní se výše uvedený kód sloučí typizací z názvů MyNamespacea rozhraní MyNamespacedo globální proměnné myNamespace(vlastnost okna).

Pokud používáte úhlové CLI je to opravdu jednoduché (testováno na CLI RC.0):

src / polyfills.ts

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

my-custom-utils.ts

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

Já používám IntelliJ, takže jsem potřeboval změnit následující nastavení v IDE před moje nové polyfills vyzvednout:

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

Pro ty, kteří chtějí nastavit vypočítaný nebo dynamické vlastnosti na windowobjekt, zjistíte, že není možné s declare globalmetodou. K objasnění tohoto případu užití

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

Možná se pokusíte udělat něco takového

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

Výše uvedené bude chyba ačkoli. Je to proto, že na psacím stroji, rozhraní nefungují dobře hrát s vypočítanými vlastnostmi a bude hodit chybu, jako je

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

Chcete-li tento postup obejít, můžete jít s naznačují, odlévání windowdo <any>takže si můžete udělat

(window as any)[DynamicObject.key]

Udělat vlastní rozhraní rozšiřuje okno a přidat své vlastní vlastnosti jako volitelné.

Potom nechte customWindow, které používají vlastní rozhraní, ale oceňují s původním oknem.

Je pracoval s typescript@3.1.3.

interface ICustomWindow extends Window {
  MyNamespace?: any
}

const customWindow:ICustomWindow = window;

customWindow.MyNamespace = customWindow.MyNamespace {} 

Chtěl jsem dnes použít v úhlové (6) knihovny a trvalo mi nějaký čas, aby si to do práce, jak se očekávalo.

K tomu, aby mé knihovně používat přísliby jsem musel použít d.tspřístavby k souboru, který deklaruje nové vlastnosti objektu globální.

Takže nakonec, soubor skončil s něčím jako:

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

Po vytvoření, nezapomeňte ji vystavit ve vašem public_api.ts.

Že to udělal pro mě. Snad to pomůže.

Pro porovnání (to je správná odpověď):

Uvnitř .d.tssouboru definice

type MyGlobalFunctionType = (name: string) => void

Pracujete-li v prohlížeči, přidání členů do okna kontextu prohlížeče obnovením rozhraní Window:

interface Window {
  myGlobalFunction: MyGlobalFunctionType
}

Stejná myšlenka na NodeJS:

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

Nyní můžete deklarovat kořenový proměnnou (která bude skutečně žít na okno nebo celosvětový)

declare const myGlobalFunction: MyGlobalFunctionType;

Pak v pravidelném .tssouboru, ale importován jako vedlejší efekt, ve skutečnosti ji realizovat:

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

A nakonec ji použít jinde v codebase, buď:

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

myGlobalFunction("Kevin");

Pokud používáte strojopisu 3.x, můžete být schopni vynechat declare globalroli v další odpovědi a místo toho stačí použít:

interface Window {
  someValue: string
  another: boolean
}

Tato pracoval se mnou, když použití strojopisu 3.3, WebPack a TSLint.

TYPESCRIPT neprovádí typecheck na vlastnosti strun.

window["newProperty"] = customObj;

V ideálním případě by měly zabránit globální proměnné scénář. I to někdy používají k ladění objektu v konzole prohlížeče.

Za prvé je nutné deklarovat objektu okna v aktuálním oboru.
Vzhledem k tomu, strojopisem chtěli znát typ objektu.
Vzhledem k tomu, okna Objekt je definováno jinde nemůžete ho předefinovat.
Ale můžete jej deklarovat takto: -

declare var window: any;

To nebude obnovovat objektu okna, nebo to nebude vytvářet další proměnnou s názvem window.
To znamená, že okno je definován někde jinde a vy prostě odkazování v současném rozsahu.

Pak se můžete obrátit na vašeho MyNamespace objekt jednoduše: -

window.MyNamespace

A teď strojopisem nebude stěžovat.

Po nalezení odpovědí kolem sebe, myslím, že tato strana by mohla být užitečná. https://www.typescriptlang.org/docs/handbook/declaration-merging.html#global-augmentation Nejste si jisti, o historii prohlášení slučování, ale to vysvětluje, proč se vkládá mohl pracovat.

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

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