Array.forEach args type error about typescript HOT 10 CLOSED

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)
    }
  })
})

from typescript.

Duplicate of #55201.

from typescript.

@RyanCavanaugh

but item.unit type be unknown,

Expected behavior

item.unit type be string,

from typescript.

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.

from typescript.

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

from typescript.

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)
    }
  })
})

from typescript.

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'

from typescript.

So there is a problem with item's type recognition

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

from typescript.

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.

from typescript.

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？

from typescript.