從非屬性中提取 Typescript 對象屬性

Question

我正在嘗試從一個較大的對象生成兩個對象，以查看該屬性是否列在給定的通用類型中。

意思是如果我給出類似的東西：

{
   name: "John",
   enabled: false,
   lastName: "Doe",
   age: 33
}

類型是：

type User = {
   name: string;
   lastName: string;
   age: number 
}

函數的結果將是 (Non In Type, InType) 的格式

[
   {
      enabled: false
   }, 
   {
      name: "John",
      lastName: "Doe",
      age: 33
   }
]

這是我到目前為止所嘗試的：

type GenericType<T> = Partial<T> & {
[record: string]: unknown
}

// Values are known properites of T
const sortProperties = <T>(values: string[], orginalObject: GenericType<T>){

   const validPropertieis: Partial<T> = {};
   const inValidProperties: Record<string, unknown> = {};

   Object.keys(orginalObject).forEach((key) => {
      if(values.includes(key){
         // No index signature with parameter type 'string' was found on type Partial<T>
         validPropertieis[key] = values[key];
      }
      else {
          inValidProperties[key] = values[key];
      }

   return [inValidProperties, validProperties];

}

Answer 1

編輯：

這是一個解決方案：

// The valid properties we want
const arr = ['hi', 'test', 'abc'] as const;

const obj = {
    hi: 'foo',
    test: 420,
    abc: 'bar',
    // Oops, extra property
    oops: 123,
};

const validateProperties = <A extends ReadonlyArray<string>, T extends Record<string, unknown>>(values: A, object: T) => {
    return Object.keys(object).reduce((acc, key) => {
        if (!values.includes(key)) acc[0] = { ...acc[0], [key]: object[key] };
        else acc[1] = { ...acc[1], [key]: object[key] };

        return acc;
    }, [] as unknown as [Omit<T, A[number]>, Pick<T, A[number]>]);
};

const test = validateProperties(arr, obj);

您的 IDE 將在嘗試訪問它們時自動填充屬性。 唯一需要注意的是string[]必須是const或字符串元組，以便 TypeScript 可以推斷文字類型。

Answer 2

根據您提供的描述，我會建議這樣的解決方案：

type Expand<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
type SortReturnType<K extends string, T> = [Expand<Omit<T, K>>, Expand<Pick<T, K & keyof T>>]

const sortProperties = <
  K extends string, 
  T
>(v1: K[], v2: T): Expand<SortReturnType<K, T>> => {

   const validProperties: Partial<T> = {};
   const inValidProperties: Partial<T> = {};

   Object.keys(v2).forEach((key) => {
      if (v1.includes(key as any)) {
        validProperties[key as keyof T] = v2[key as keyof T]
      } else {
        inValidProperties[key as keyof T] = v2[key as keyof T];
      }
   })

   return [inValidProperties, validProperties] as SortReturnType<K, T>;
}

讓我們看看它是否有效。

const result = sortProperties(["name", "lastName", "age"], {
  name: "abc",
  lastName: "abc",
  enabled: true,
  age: 0
})
// const result: [{
//     enabled: boolean;
// }, {
//     name: string;
//     lastName: string;
//     age: number;
// }]

看起來對我來說很好。 讓我知道這是否符合您的要求。

操場

Answer 3

另一個嘗試：

type User = {
  name: string;
  lastName: string;
  age: number;
};

const testUser = {
    name: "John",
    enabled: false,
    lastName: "Doe",
    age: 33,
  },
  userTypeKeys = ["name", "lastName", "age"];

function sortProperties<T>(values: string[], object: T) {
  const validProperties: Partial<T> = {},
    invalidProperties: Record<string, unknown> = {};

  Object.keys(object).forEach((key: string) => {
    if (values.includes(key)) {
      validProperties[key as keyof T] = object[key as keyof T];
    } else {
      invalidProperties[key] = object[key as keyof T];
    }
  });

  return [invalidProperties, validProperties];
}

const properties = sortProperties(userTypeKeys, testUser);

// logs [ { enabled: false }, { name: 'John', lastName: 'Doe', age: 33 } ]
console.log(properties);