U tweetove putem weba ili aplikacija drugih proizvođača možete dodati podatke o lokaciji, kao što su grad ili točna lokacija. Povijest lokacija tweetova uvijek možete izbrisati. Saznajte više
While last #TypeScriptTuesday we looked at #TypeScript Generics Basics, today we continue where we left off, by taking a closer look at type argument inference, pitfalls and workarounds. We will take a look at a simplified version of #redux-toolkit's `createAction` function.
pic.twitter.com/0pWmT8v88C
Here, we call this function three ways: 1. With explicit type arguments. Everything is fine. 2. With inferred type arguments. P cannot be inferred, because it does not relate to any method argument. 3. With one explicit type argument. But why is the second argument not inferred?pic.twitter.com/RUU42EpCmZ
This is because #TypeScript cannot mix explicit and inferred type arguments.
There is a PR for that at https://github.com/microsoft/TypeScript/pull/26349 …, but there is still discussion on what syntax to use.
Let's just assume that this is impossible and try to work around it.
One possible solution would be to wrap it in yet another function, let's call this "Type Argument Currying". Here `createAction` infers `T` and `withPayload` is called with `number` explicitly. But this requires a change in our existing runtime code, and it is a bit weird to use.pic.twitter.com/hCAHxBXic0
So what did we do in #redux-toolkit?
Actually, our `createAction` function can take an optional second `prepare` argument to modify the payload beforehand.
Here we just create a helper fn that captures a type and returns a `prepare` function that just passes the payload through.pic.twitter.com/vjBGW8ssEd
![type PrepareAction<P> = (...args: any[] ) => { payload: P };
function createAction<P, T = string>(type: T, prepare?: PrepareAction<P>): ActionCreator<P, T> {
return (payload: P) => ({
type,
payload
});
}
function withPayloadType<T>() {
return (t: T) => ({ payload: t });
}
const incrementAction = createAction("increment" as const, withPayloadType<number>());](https://pbs.twimg.com/media/EOQ6HCXXUAYaEIi.jpg)
So, you now know two way to combine explicit and inferred type arguments - and that's it for today. Next week, you will learn how you can add restrictions to your type parameters. After all, right now you could pass any object as `T` parameter, and we don't want that.
@phry nice content why you don't publish it on a small blog post?
I might do a small blog post after each completed topic, but right now I like this format. There's no "changing the medium", so more people see the actual contents and the restrictions of tweets make it quite interesting as I have to think about what I *really* want to talk about
Twitter je možda preopterećen ili ima kratkotrajnih poteškoća u radu. Pokušajte ponovno ili potražite dodatne informacije u odjeljku Status Twittera.
