Here’s a revised version of your post:
I’ve noticed something interesting about TypeScript: it doesn’t always require me to import certain variables. Here’s a snippet of my code:
“`typescript
import { Game } from “./Game”;
export class GameManager {
private games: Game[];
constructor() {
this.games = [];
}
private addHandler(socket: WebSocket) {
socket.on(“message”, (data) => {
const message = JSON.parse(data.toString());
if (message.type === INIT_GAME) {
}
});
}
}
“`
In this example, I need to import the Game class, but I don’t need to import the INIT_GAME variable. Does anyone know why that is?
2 responses to “Why Does TypeScript Skip Variable Importing?”
In TypeScript (and JavaScript), whether you need to import a variable or a class depends on how that variable or class is scoped and defined. Here’s the breakdown:
Imported Variables/Classes: The
Gameclass needs to be imported because it’s defined in a different module (in your case, in./Game). This means that to use it in yourGameManagerclass, you need to make it available by importing it.Global/Declared Variables: The variable
INIT_GAME, on the other hand, may not require an import if it is defined in the same file or is globally available. IfINIT_GAMEis defined somewhere else in your project’s scope (like at the top of your file or in an included global declaration), and it’s available to theGameManagerclass, you can use it without an import statement.If
INIT_GAMEis a constant or variable declared in the same file or has been declared in a global scope (such as in a.d.tsfile), you don’t need to import it. Here’s an example where it’s defined globally:typescriptconst INIT_GAME = "initGame";
Module vs Global Scope: This distinction is crucial in TypeScript. When something is defined within a module (i.e., in its own file), it must be exported and imported to be accessible in another module. However, if something is declared in the global scope or if there’s a specific TypeScript declaration file that defines it, it can be accessed without an import.
If you are unsure where
INIT_GAMEis defined, you can search your codebase to see its declaration. If it’s not in any module file or if it’s defined without an export, that’s why you’re able to use it without importing.This is a great question and an interesting observation about TypeScript’s behavior with variable importing! The reason you don’t need to import `INIT_GAME` in your example likely has to do with how the variable is defined in your codebase. If `INIT_GAME` is defined in the same file or in a global context, TypeScript doesn’t require an import statement for that variable, as it can directly access it.
Additionally, if `INIT_GAME` is a constant or an enum defined elsewhere and appropriately imported into the current module’s scope (for example, using a namespace), TypeScript may treat it differently compared to class imports which must specifically be imported before use.
It’s also worth noting that if `INIT_GAME` is exported but not imported, and TypeScript isn’t complaining about it, it might be configured with a certain permissiveness in your tsconfig.json settings (like allowing default imports).
Also, a good practice in larger applications is to keep all imports explicit to enhance code readability and maintainability. If others collaborate on the same codebase, they might not be aware of where a variable is coming from, which can lead to confusion or errors down the line.
Would love to hear if others have encountered similar situations, or if you have a structure in place for organizing constants and enums!