深入理解TypeScript中动态导入命名空间变量的机制与实践

// my_file.ts
export interface CustomType {
    propertyOne: string;
    propertyTwo: number;
}

export const MyThing: CustomType = {
    propertyOne: "name",
    propertyTwo: 2
};

export const AnotherThing: CustomType = {
    propertyOne: "Another",
    propertyTwo: 3
};

// main.ts
import * as allthings from "./my_file"; // 假设路径正确

function doStuff() {
   let currentThing = allthings['MyThing']; // 成功，因为'MyThing'是字面量
   let name = 'MyThing';
   let currentThing2 = allthings[name]; // 报错！
}

// main.ts
import * as allthings from "./my_file";

function doStuffWithConstKey() {
   const name = 'MyThing'; // 'name' 的类型被推断为 'MyThing' 字面量类型
   let currentThing = allthings[name]; // 成功，TypeScript知道'MyThing'是一个有效键
   console.log(currentThing);
}

function doStuffWithConstAssertion() {
   let anotherName = 'AnotherThing' as const; // 'anotherName' 的类型被断言为 'AnotherThing' 字面量类型
   let anotherThing = allthings[anotherName]; // 成功
   console.log(anotherThing);
}

doStuffWithConstKey();
doStuffWithConstAssertion();

// my_file.ts
export interface CustomType {
  propertyOne: string;
  propertyTwo: number;
}

export const allExportedThings = { // 将所有导出项组织在一个对象中
  MyThing: {
    propertyOne: "name",
    propertyTwo: 2
  },
  AnotherThing: {
    propertyOne: "Another",
    propertyTwo: 3
  }
} satisfies Record<string, CustomType>; // 使用 satisfies 确保所有属性符合 CustomType

// main.ts
import { allExportedThings, CustomType } from "./my_file";

// 定义一个类型，它是 allExportedThings 对象所有键的联合类型
type AllThingsKeys = keyof typeof allExportedThings;

function getThingByKey(key: AllThingsKeys): CustomType {
    return allExportedThings[key];
}

// 动态使用
let dynamicKey: AllThingsKeys = 'MyThing'; // 或者从其他逻辑动态生成
let myThingInstance = getThingByKey(dynamicKey);
console.log(myThingInstance); // { propertyOne: 'name', propertyTwo: 2 }

dynamicKey = 'AnotherThing';
let anotherThingInstance = getThingByKey(dynamicKey);
console.log(anotherThingInstance); // { propertyOne: 'Another', propertyTwo: 3 }

// 尝试使用不存在的键会报错
// let invalidKey: AllThingsKeys = 'NonExistentThing'; // 编译错误

// my_file.ts
export interface CustomType {
  propertyOne: string;
  propertyTwo: number;
}

// 使用 satisfies 确保 allExportedThings 的所有属性都符合 CustomType
// 同时保留了 'MyThing' 和 'AnotherThing' 作为精确的键类型
export const allExportedThings = {
  MyThing: {
    propertyOne: "name",
    propertyTwo: 2
  },
  AnotherThing: {
    propertyOne: "Another",
    propertyTwo: 3
  }
} satisfies Record<string, CustomType>; // 确保所有属性是 CustomType

// main.ts
import { allExportedThings, CustomType } from "./my_file";

type AllThingsKeys = keyof typeof allExportedThings; // 类型为 'MyThing' | 'AnotherThing'

function getValueFromAllThings(key: AllThingsKeys): CustomType {
    return allExportedThings[key];
}

const key1: AllThingsKeys = 'MyThing';
const value1 = getValueFromAllThings(key1);
console.log(value1);

const key2: AllThingsKeys = 'AnotherThing';
const value2 = getValueFromAllThings(key2);
console.log(value2);