Generic in function doesn't check argument type in Typescript

Question

I'm expecting that typescript will throw an error because I'm passing the wrong number of elements in EntryPoints, but it doesn't happen.

function createContext<T>(defaultValue: T): T[] {
  return [defaultValue]
}

interface EntryPoints {
  parentSelector: string;
}
interface SomeType {
  entryPoints: EntryPoints[];
}
const defaultData = {
  entryPoints: [{
    parentSelector: '',
    foo: 1 // <-- expecting error here
  }]
}
createContext<SomeType>(defaultData)

Same code without generic works as expected

function createContext<T>(defaultValue: T): T[] {
  return [defaultValue]
}

interface EntryPoints {
  parentSelector: string;
}
interface SomeType {
  entryPoints: EntryPoints[];
}
const defaultData: SomeType = {
  entryPoints: [{
    parentSelector: '',
    foo: 1 // <-- throwing error here
  }]
}
createContext(defaultData)

Playground

skovy · Accepted Answer · 2019-09-12 03:27:49Z

2

You're running into an object freshness issue so the additional key is allowed.

If you explicitly pass the object it will be properly typed checked:

function createContext<T>(defaultValue: T): T[] {
  return [defaultValue];
}

interface EntryPoints {
  parentSelector: string;
}

interface SomeType {
  entryPoints: EntryPoints[];
}

createContext<SomeType>({
  entryPoints: [
    {
      parentSelector: "",
      foo: 1 // <-- errors as expected here
    }
  ]
});

TypeScript Playground

edited Sep 12, 2019 at 3:27

answered Sep 12, 2019 at 3:18

skovy

5,6502 gold badges23 silver badges34 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Shaun Luttin Over a year ago

This isn't type widening. Type widening is a different thing.

Shaun Luttin · Accepted Answer · 2019-09-12 04:03:27Z

What you're experiencing is the difference between

type checking at the point of assigning a literal to a type and
type checking at the point of assigning a variable to a type.

Consider that we have two types. One of them has one more property than the other has.

type Foo = {
  foo: string;
};

type FooBar = {
  foo: string;
  bar: string;
};

When assigning an object literal to a type, additional properties are NOT allowed.

// Object literal may only specify known properties,
// and 'bar' does not exist in type 'Foo'.
const foo: Foo = {
  foo: "foo",
  bar: "bar" // <---- bar is not allowed on Foo.
};

When assigning a variable to a type, additional properties are allowed.

const fooBar: FooBar = {
  foo: "foo",
  bar: "bar" // <---- bar is going to be allowed on Foo
};

const foo: Foo = fooBar; // <---- see, no error

It is okay to assign fooBar to foo because fooBar is a variable not an object literal and can therefore include unknown properties.

Collectives™ on Stack Overflow

Generic in function doesn't check argument type in Typescript

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related