如何根据Typescript中的接口新建对象？

Question

I have an interface like this:

interface Response {
    items: {
        productId: string;
        productName: string;
        price: number;
    }[]
}

interface APIResponse {
    items: {
        productId: string;
        productName: string;
        price: number;
        factoryId: string,
        status: number,
        category: number,
        priority: number
    }[]
}

now I have a function return Response :

async function list(): promise<Response> {
    // data.htw.cart.list return APIResponse
    const rv = await data.htw.cart.list(postJson)
    return rv
}

However, data.htw.cart.list return APIResponse , I just need Response , I get too much data.

every time I need to do this:

return {
  items: rv.items.map(item => {
    return {
      productId: item.productId,
      productName: item.productName,
      price: item.price
    }
  })
}

I want to have a tool to remove some data in APIResponse which make APIResponse becomes Response ?

Two things to point out:

1. APIResponse always include Response
2. key name in Response which includes is the same as in APIResponse

Answer 1

I think the cleanest way would be to create the appropriate relations between your types.

interface Item {
  productId: string
  productName: string
  price: number
}

interface APIItem extends Item {
  factoryId: string,
  status: number,
  category: number,
  priority: number
}

interface Response {
  items: Item[]
}

interface APIResponse extends Response {
  items: APIItem[]
}

// APIResponse is now assignable to Response
let response: Response = ...;
let apiResponse: APIResponse = ...;
response = apiResponse;

// APIItem[] is now also assignable to Item[], but you only loose 
// the type information, the fields will be there actually
const apiItems: APIItem[] = [...];
const items: Item[] = apiItems;

So this helps to make the compiler understand how your types are related to each other.

If you want to "physically" remove the excess fields, then the best you can do is the .map what you posted in your question. You can also use a js library (eg.: lodash/pluck ) - but then you defeat the purpose of having statically checked types...