如何在 TypeScript 中为模块声明变量？

Question

I have two files: index.ts and A.ts

A.ts :

export default class {
    do() {
        console.log(someVar);
    }
}

index.ts :

import A from './A';

function printIt(param) {
    let someVar = param;
    let a = new A();
    a.do();
}

printIt('wow'); // Console output: wow
printIt('123'); // Console output: 123

Is it real to declare someVar for A.ts from index.ts without wrapping A class?

I know that Node.JS wrappes all modules in (function (exports, require, module, __filename, __dirname, process, global) { } : How to change the Node.js module wrapper?

I tried to make a custom require function and pass my var like an argument. But I don't understand how can I make own require function in TypScript. Are there any ideas?

Answer 1

What are you trying to do? The seperation for module is on purpose, so the scope of everything remains.

Next, you have a typo: it should probably be let a = new A(); not let a = new A; .

But why dont you just pass the variable as an argument to the constructor of your A class?

export default class {
    someVar: string;
    constructor(someVar) {
      this.someVar = someVar;
    }
    do() {
        console.log(this.someVar);
    }
}

now you can just do

function printIt(param) {
    let someVar = param;
    let a = new A(someVar);
    a.do();
}

Answer 2

The scope of variables depends on where they are defined, not where they are called. this is on purpose, so you do not accidentally call on variables you did not know about being in the same scope as your function's invocation.

You must explicitly tell the code you want to pass this new variable into it, either just like Lux showed, or through passing it to the function like:

export default class {
     do(someVar) {
         console.log(someVar);
     }
}
function printIt(param) {
   let someVar = param;
   let a = new A();
   a.do(someVar);
}

what you're trying to do is akin to having everything be a global variable. if you MUST do this (you shouldn't), there is one way you can.

export default class {
     do() {
         console.log(global.someVar);
     }
}
function printIt(param) {
   global.someVar = param;
   let a = new A();
   a.do();
}

There's many reasons why you do not want to do global variables, here are some

Edits after clarification:

So the "this" keyword inside of a module refers to the module's global scope, so I tried the following snippet:

 // modA.js const moduleContext = this class ExportedClass { printer() { console.log(moduleContext.someVar) } } module.exports = { ExportedClass } //modB.js let A = require("./modA") A.someVar = "hello world" let obj = new A.ExportedClass() obj.printer()

and it seems the context was removed, the same thing with ES6 imports using mjs files, what did Work however is this:

 //modA.js function printer() { console.log(this.someVar) } module.exports = { printer } //modB.js let A = require("./modA") A.someVar = "hello world" A.printer()

it seems moduleContext points to the old module context object, and the new imported module has a different context object.

This still seems like a bad idea though, you're better off structuring your code so that you export a constructing function, that takes whatever needs to be "global" for that scope, and sets it inside.