Crea una variable global en TypeScript

En JavaScript, puedo hacer esto:

 something = 'testing';

Y luego en otro archivo:

 if (something === 'testing')

y se habrá somethingdefinido (siempre que se hayan llamado en el orden correcto).

Parece que no puedo averiguar cómo hacer eso en TypeScript.

Esto es lo que he probado.

En un archivo .d.ts:

interface Window { something: string; }

Luego, en mi archivo main.ts:

 window.something = 'testing';

luego en otro archivo:

 if (window.something  === 'testing')

Y esto funciona. Pero quiero poder perder una window.parte y somethingser global. ¿Hay alguna forma de hacer eso en TypeScript?

(En caso de que alguien esté interesado, realmente estoy tratando de configurar mi registro para mi aplicación. Quiero poder llamar log.Debugdesde cualquier archivo sin tener que importar y crear objetos).

Bien, probablemente esto sea aún más feo que lo que hiciste, pero de todos modos ...

^{pero yo hago lo mismo entonces ...}

Lo que puede hacer para hacerlo en TypeScript puro, es usar la evalfunción así:

declare var something: string;
eval("something = 'testing';")

Y luego podrás hacer

if (something === 'testing')

Esto no es más que un truco para forzar la ejecución de la instrucción sin que TypeScript se niegue a compilar, y nosotros declare varpara que TypeScript compile el resto del código.

Dentro de un .d.tsarchivo de definición

type MyGlobalFunctionType = (name: string) => void

Si trabaja en el navegador, agrega miembros al contexto de la ventana del navegador:

interface Window {
  myGlobalFunction: MyGlobalFunctionType
}

Misma idea para NodeJS:

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

Ahora declara la variable raíz (que realmente vivirá en la ventana o global)

declare const myGlobalFunction: MyGlobalFunctionType;

Luego, en un .tsarchivo normal , pero importado como efecto secundario, realmente lo implementa:

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

Y finalmente úselo en otra parte del código base, con:

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

myGlobalFunction("Kevin");

global Este es el futuro.

Primero, los archivos TypeScript tienen dos tipos de scopes

alcance global

Si su archivo no tiene ninguna línea importoexport , este archivo se ejecutará en el alcance global de que todas las declaraciones en él sean visibles fuera de este archivo.

Entonces crearíamos variables globales como esta:

// xx.d.ts
declare var age: number

// or 
// xx.ts
// with or without declare keyword
var age: number

// other.ts
globalThis.age = 18 // no error

Toda la magia viene de var. Reemplazar varcon leto constno funcionará.

alcance del módulo

Si su archivo tiene alguna línea importoexport , este archivo se ejecutará dentro de su propio alcance que necesitamos extender globalmente mediante la combinación de declaraciones .

// xx[.d].ts
declare global {
  var age: number;
}

// other.ts
globalThis.age = 18 // no error

Puede ver más sobre el módulo en los documentos oficiales.

Así es como lo he solucionado:

Pasos:

1. Declarado un espacio de nombres global, por ejemplo, custom.d.ts como se muestra a continuación:

declare global {
    namespace NodeJS {
        interface Global {
            Config: {}
        }
    }
}
export default global;

2. Asigne el archivo creado anteriormente en "tsconfig.json" como se muestra a continuación:

"typeRoots": ["src/types/custom.d.ts" ]

3. Obtenga la variable global creada anteriormente en cualquiera de los archivos de la siguiente manera:

console.log(global.config)

Nota:

1. versión mecanografiada: "3.0.1".

2. En mi caso, el requisito era establecer la variable global antes de iniciar la aplicación y la variable debería acceder a través de los objetos dependientes para que podamos obtener las propiedades de configuración necesarias.

¡Espero que esto ayude!

Gracias

Encontré una forma que funciona si uso JavaScript combinado con TypeScript.

logging.d.ts:

declare var log: log4javascript.Logger;

declaración de registro. js :

log = null;

initalize-app.ts

import './log-declaration.js';

// Call stuff to actually setup log.  
// Similar to this:
log = functionToSetupLog();

Esto lo coloca en el ámbito global y TypeScript lo sabe. Entonces puedo usarlo en todos mis archivos.

NOTA: Creo que esto solo funciona porque tengo la allowJsopción TypeScript configurada como verdadera.

Si alguien publica una solución pura de TypeScript, la aceptaré.

estoy usando solo esto

import {globalVar} from "./globals";
declare let window:any;
window.globalVar = globalVar;

Pasé un par de horas para encontrar la manera adecuada de hacerlo. En mi caso, estoy tratando de definir la variable "log" global, por lo que los pasos fueron:

1) configure su tsconfig.jsonpara incluir sus tipos definidos ( src/typescarpeta, node_modules - depende de usted):

...other stuff...
"paths": {
  "*": ["node_modules/*", "src/types/*"]
}

2) cree un archivo src/types/global.d.tscon el siguiente contenido (¡ sin importaciones! - esto es importante), siéntase libre de cambiar anypara que coincida con sus necesidades + use la windowinterfaz en lugar de NodeJSsi está trabajando con el navegador:

/**
 * IMPORTANT - do not use imports in this file!
 * It will break global definition.
 */
declare namespace NodeJS {
    export interface Global {
        log: any;
    }
}

declare var log: any;

3) ahora finalmente puede usar / implementar logdonde sea necesario:

// in one file
global.log = someCoolLogger();
// in another file
log.info('hello world');
// or if its a variable
global.log = 'INFO'

Necesitaba hacer lodash global para usar un archivo .js existente que no podía cambiar, solo requerir.

Descubrí que esto funcionó:

import * as lodash from 'lodash';

(global as any)._ = lodash;

Como complemento a la respuesta de Dima V, esto es lo que hice para que esto funcionara para mí.

// First declare the window global outside the class

declare let window: any;

// Inside the required class method

let globVarName = window.globVarName;

Esto funciona para mí, como se describe en este hilo :

declare let something: string;
something = 'foo';