TypeScriptで、ジェネリックを使用したclassを作成したい

Question

前提

TypeScriptで勉強中です。
classを定義したいのですが、思うように挙動しません。

実現したいこと

ジェネリックを使用した、型付きのclassを作成したい。

classをnewした時に、入る引数としてはオブジェクト("key, valueはどの型か、またいくつ入るのかは、newを宣言するまで不明確)を想定しています。
例えば,,,

const obj1 = { a: '01', b: '02' } // key, valueはどの型か、またいくつ入るのかは、newを宣言するまで不明確という想定。 
const wrappedObj1 = new ObjectWrapper(obj1)

また、classの中にsetter, getterを定義したいのですが、どのように型を定義すればよいかわからず、詰まってしまいました。

該当のソースコード (発生している問題・エラーメッセージ)

class ObjectWrapper<T> {
  /***
   * 引数のオブジェクトのコピーを this._objに設定
   */
  constructor(private _obj: T) {}

  /**
   * this._objのコピーを返却
   * @return Object
   */
  get obj(): T {
    return { ...this._obj }
  }

  /**
   * this._obj[key] に valを設定。keyがthis._objに存在しない場合、falseを返却
   * @param key オブジェクトのキー
   * @param val オブジェクトの値
   */
  set(key: keyof typeof T, val: keyof typeof T): boolean { // error: 'T' only refers to a type, but is being used as a value here.
    let result: boolean = false

    Object.keys(this._obj).forEach((e) => {
      if (e === key) {
        this._obj[key] = val // error: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'unknown'.
  No index signature with a parameter of type 'string' was found on type 'unknown'
        result = true
        return
      }
    })

    return result
  }

  /**
   * 指定したキーの値のコピーを返却
   * 指定のキーが存在しない場合 undefinedを返却
   * @param key オブジェクトのキー
   */
  get(key: keyof typeof T): T { // error: 'T' only refers to a type, but is being used as a value here.
    let result: T = undefined // Type 'undefined' is not assignable to type 'T'.
  'T' could be instantiated with an arbitrary type which could be unrelated to 'undefined'.

    Object.entries(this._obj).find((val) => {
      if (val[0] === key) {
        return (result = val[1])
      }
    })

    return result
  }

  /**
   * 指定した値を持つkeyの配列を返却。該当のものがなければ空の配列を返却。
   */
  findKeys(val: T): T {
    const result: T[] = Object.keys(this._obj).filter((key) => { // Type 'string[]' is not assignable to type 'T[]'.
  Type 'string' is not assignable to type 'T'.
    'T' could be instantiated with an arbitrary type which could be unrelated to 'string'.
      return this._obj[key] === val
    })

    return result // Type 'T[]' is not assignable to type 'T'.
  'T' could be instantiated with an arbitrary type which could be unrelated to 'T[]'.
  }
}

試したこと

classの引数が不明確な場合は、ジェネリックを使用したほうが良いというとこまではたどり着いたのですが、そこから先がわからなくなってしまいました。
よろしくお願いいたします。

補足情報（FW/ツールのバージョンなど）

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es2020",
    "outDir": "dist",
    "sourceMap": true,
    "strict": true
  },
  "include": ["src"],
  "exclude": ["node_modules"]
}

Answer 1

とりあえず突貫工事で動くようにはしました。しかし、前提の部分を変えてしまっているような気もするので不備があったらご指摘ください。

class ObjectWrapper<T extends Record<PropertyKey, U>, U> {
  /***
   * 引数のオブジェクトのコピーを this._objに設定
   */
  constructor(private _obj: T) {}

  /**
   * this._objのコピーを返却
   * @return Object
   */
  get obj(): T {
    return { ...this._obj };
  }

  /**
   * this._obj[key] に valを設定。keyがthis._objに存在しない場合、falseを返却
   * @param key オブジェクトのキー
   * @param val オブジェクトの値
   */
  set(key: keyof T, val: T[keyof T]): boolean {
    // error: 'T' only refers to a type, but is being used as a value here.
    let result = false;

    Object.keys(this._obj).forEach((e) => {
      if (e === key) {
        this._obj[key] = val; // error: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type 'unknown'. No index signature with a parameter of type 'string' was found on type 'unknown'
        result = true;
        return;
      }
    });

    return result;
  }

  /**
   * 指定したキーの値のコピーを返却
   * 指定のキーが存在しない場合 undefinedを返却
   * @param key オブジェクトのキー
   */
  get(key: keyof T): U | undefined {
    // error: 'T' only refers to a type, but is being used as a value here.

    const result = Object.entries(this._obj).find((val) => {
      return val[0] === key;
    });

    return result ? (result[1] as U) : undefined;
  }

  /**
   * 指定した値を持つkeyの配列を返却。該当のものがなければ空の配列を返却。
   */
  findKeys(val: U): string[] {
    const result = Object.keys(this._obj).filter((key) => {
      // Type 'string[]' is not assignable to type 'T[]'. Type 'string' is not assignable to type 'T'. 'T' could be instantiated with an arbitrary type which could be unrelated to 'string'.
      return this._obj[key] === val;
    });

    return result; // Type 'T[]' is not assignable to type 'T'. 'T' could be instantiated with an arbitrary type which could be unrelated to 'T[]'.
  }
}


const obj = new ObjectWrapper<Record<string,number>, number>({ a: 1, b: 2, c: 1 });

console.log(obj.get('a'));
// 1

console.log(obj.get('c'));
// 1

console.log(obj.findKeys(1));
// ["a", "c"] 

console.log(obj.set('a', 0));
// true

console.log(obj.get('a'));
// 0

console.log(obj.set('d', 2));
//false

Comments

[kon2300]

ありがとうございます！
T[keyof T]
このような書き方もあるんですね！
技術書を読んでもなかなか理解できず、詰まっていたところでした。
ありがとうございます！