Array.forEach args type error

[chenyulun]

🔎 Search Terms

export interface TypeA {
  name: string
}

export interface TypeB extends TypeA {
  unit: string
}

const xxx: { a: TypeB[], b: TypeA[] } = {
  a: [],
  b: [],
};
(['a', 'b'] as const).forEach((key) => {
  const yyy = xxx[key]

  yyy.forEach((item) => { // (parameter) item: TypeA

    if('unit' in item) {
      console.log(item.unit) // (property) unit: unknown
    }
  })
})

🕗 Version & Regression Information

• This changed between versions ______ and _______
• This changed in commit or PR _______
• This is the behavior in every version I tried, and I reviewed the FAQ for entries about _________
• I was unable to test this on prior versions because _______

mkdir test-ts5.5
cd $_
pnpm init
pnpm add typescript

package.json

{
  "name": "test-ts5.5",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "typescript": "^5.5.4"
  }
}

⏯ Playground Link

No response

💻 Code

export interface TypeA {
  name: string
}

// export interface TypeB extends TypeA {
 export interface TypeB {
  name: string
  unit: string
}

const xxx: { a: TypeB[], b: TypeA[] } = {
  a: [],
  b: [],
};
(['a', 'b'] as const).forEach((key) => {
  const yyy = xxx[key]

  yyy.forEach((item) => {
    if('unit' in item) {
      console.log(item.unit)
    }
  })
})

🙁 Actual behavior

item type Only TypeA

🙂 Expected behavior

item type sould be TypeA | TypeB

Additional information about the issue

I have not idea

[MartinJohns]

Duplicate of #55201.

[chenyulun]

@RyanCavanaugh

but item.unit type be unknown,

Expected behavior

item.unit type be string,

[MartinJohns]

Objects are not sealed. It's possible that your TypeA values have a unit property that is not a string, that's why checking for a property using the in operator results in unknown.

[chenyulun]

Objects are not sealed. It's possible that your TypeA values have a unit property that is not a string, that's why checking for a property using the in operator results in unknown.

So there is a problem with item's type recognition
But it was marked as non-defective in another issue

[chenyulun]

How should I write best practices for the following code

export interface TypeA {
  name: string;
}

export interface TypeB {
  name: string;
  unit: string;
}
let unit: string; 
const testObject: { a: TypeB[], b: TypeA[] } = {
  a: [],
  b: [],
};
(['a', 'b'] as const).forEach((key) => {
  const ObjectValue = testObject[key]

  ObjectValue.forEach((item) => {
    if('unit' in item) {
      unit = item.unit // error ts(2322)
    }
  })
})

[chenyulun]

export interface TypeA {
  name: string;
  // age: number;
}

export interface TypeB {
  name: string;
  unit: string;
}
type TypeTest = TypeA[] | TypeB[]
// type TypeTest = string[] | boolean[];




type Item = TypeTest extends Array<infer R> ? R : never // as  type Item = TypeA
// because this?
type IsBExtendsA = TypeB extends TypeA ? 'true' : 'false' // 'true'

[MartinJohns]

So there is a problem with item's type recognition

No, it's working as intended. There is no defect.

[chenyulun]

export interface TypeA {
  name: string;
  // age: number;
}

export interface TypeB {
  name: string;
  unit: string;
}
type TypeTest = TypeA[] | TypeB[]
// type TypeTest = string[] | boolean[];




type Item = TypeTest extends Array<infer R> ? R : never // as  type Item = TypeA
// because this?
type IsBExtendsA = TypeB extends TypeA ? 'true' : 'false' // 'true'

Although the logic is fine, the extends judgment in real use scenarios doesn't make sense, and this may involve too much underlying design.

[chenyulun]

So there is a problem with item's type recognition

No, it's working as intended. There is no defect.

But he realistically lost the type of unit as string，Is there a better way to practice this situation？

[MartinJohns]

As mentioned in the other issue, it's due to subtype reduction. Look it up, there are many issues about it. It's working as intended.

You can either explicitly check if unit is a string by doing 'unit' in item && typeof item.unit === 'string' or just use a type assertion item.unit as string. But again, objects are not sealed. Values of TypeA are permitted to have a unit property at runtime, which may not be typed string. This adjustment of your code demonstrates it:

interface TypeA {
  name: string;
}

interface TypeB {
  name: string;
  unit: string;
}
let unit: string; 
const testObject: { a: TypeB[], b: TypeA[] } = {
  a: [],
  b: [],
};


// The value is compatible with TypeA, so it can be pushed to the TypeA array.
const value = { name: 'example', unit: 12345 };
testObject.b.push(value);


(['a', 'b'] as const).forEach((key) => {
  const ObjectValue = testObject[key]

  ObjectValue.forEach((item) => {
    if('unit' in item) {
      console.log(item.unit)
      unit = item.unit // error ts(2322)
    }
  })
})