Pass generics to JSX elements in TypeScript (2023)

TypeScript 2.9 added the ability to specify type arguments for generic JSX elements. This means that we can now write the following component in a TSX file:

occupation The image() { // ... give back(<select<string> options={targets} bravura={target} after the change={define goal}/>);}

To understand why generic JSX elements are useful (and why we usually don't need to write the type argument explicitly), let's create the aboveselectcomponent and iterate over its static types. Here we go!

#Step #1: Implementselectin JavaScript/JSX

Let's go ahead and implement a reusableselectreacting component. Our component needs to render natively<select>item with a lot<Option>Kinder:

we want this to happenoptionsas an accessory toselectcomponent and the currently selectedbravurait is aafter the changeCall back. Here is the code for the component shown in the screenshot above:

occupation The image() { Constantly Goals =[{Bravura: "es3", Hashtag: "ECMAScript 3"},{Bravura: "es5", Hashtag: "ECMAScript 5"},{Bravura: "es2015", Hashtag: "ECMAScript 2015"},{Bravura: "yo2016", Hashtag: "ECMAScript 2016"},{Bravura: "es2017", Hashtag: "ECMAScript 2017"},{Bravura: "es2018", Hashtag: "ECMAScript 2018"},{Bravura: "es2019", Hashtag: "ECMAScript 2019"},]; Constantly[Meta,set a goal]= useState("es2019"); give back(<select options={targets} bravura={target} after the change={define goal}/>);}

How could we implement thisselectComponent in plain JavaScript and JSX? Here's a first try:

occupation select(Accessories) { occupation handleOnChange(e) { accessories.after the change(mi.current target.bravura);} give back(<select bravura={accessories.bravura}after the change={controlarcâmbio}>{accessories.options.Map(Possibility=>(<possibility key={possibility.bravura}bravura={possibility.bravura}>{possibility.Hashtag}</possibility>))}</select>);}

Our component accepts props and returns a<select>element containing all options specified byoptionsSupport, support. We also define a functionhandleOnChangewhich is called every time the selected value changes; turn onafter the changeCallback with the selected value.

This component works as expected! Now let's write statically in TypeScript and TSX.

#Step #2: Implementselectde TypeScript/TSX

We'll start by creating a type that models a single option. let's call itpossibilityand define two properties, one for the underlying value and one for the label we want to display:

he writes possibility ={bravura: line;Hashtag: line;};

That was easy enough. Next, let's specify a type for the accessory.selectComponent. we need oneoptionssupport using thosepossibilitytype we just created, abravuraprop to the currently selected value and aafter the changeCallback to be called each time the selected value changes:

he writes accessories ={options: possibility[];bravura: line; after the change:(Bravura: line)=> Archive;};

Finally we will dieaccessoriesand add a type annotation to the parametermiourhandleOnChangeOccupation:

occupation select(Accessories: accessories) { occupation handleOnChange(mi: To react.form event<HTMLSelectElement>) { accessories.after the change(mi.current target.bravura);} give back(<select bravura={accessories.bravura}after the change={controlarcâmbio}>{accessories.options.Map(Possibility=>(<possibility key={possibility.bravura}bravura={possibility.bravura}>{possibility.Hashtag}</possibility>))}</select>);}

We now have a fully statically typed React component. Currently all options must specify a value of typeline, a constraint that can be too restrictive in a real-world application. (Or it might not be! In that case, we can stop there.)

#Step 3: Supported Numeric Option Values

While using string values ​​is a common usage, it's certainly not the only one! we can want thoseselectComponent to also accept numerical option values:

occupation The image() { Constantly Goals =[{Bravura: 3, Hashtag: "ECMAScript 3"},{Bravura: 5, Hashtag: "ECMAScript 5"},{Bravura: 2015, Hashtag: "ECMAScript 2015"},{Bravura: 2016, Hashtag: "ECMAScript 2016"},{Bravura: 2017, Hashtag: "ECMAScript 2017"},{Bravura: 2018, Hashtag: "ECMAScript 2018"},{Bravura: 2019, Hashtag: "ECMAScript 2019"},]; Constantly[Meta,set a goal]= useState(2019); give back(<select options={targets} bravura={target} after the change={define goal}/>);}

Note that I replaced the string values ​​with numerical values, including the initial value passed to theuseStatehook.

Before updating the types to ourselectcomponent, we've added support for non-string option values ​​to ourhandleOnChangeOccupation. Currently it only works correctly when working with string values.e.Target.Actualis always a string, even if we specify numerical values ​​for our options.

Fortunately, the solution is pretty short. instead of readinge.Target.Actualand deliver itafter the changeCallback directly, we can get the index of the selected option through thee.current target.selected indexProperty. So we can choose ouroptionsArray at that index and callafter the changewith its value:

occupation select(Accessories: accessories) { occupation handleOnChange(mi: To react.form event<HTMLSelectElement>) { Constantly{index selected}= mi.current target; Constantly selected option = accessories.options[selected index]; accessories.after the change(selected option.bravura);} give back(<select bravura={accessories.bravura}after the change={controlarcâmbio}>{accessories.options.Map(Possibility=>(<possibility key={possibility.bravura}bravura={possibility.bravura}>{possibility.Hashtag}</possibility>))}</select>);}

This approach works because we represent a person<Option>element for each element notoptionsArray, keeps its order and doesn't add more<Option>Elements.

Now that we have determined the implementation of ourselectcomponent, let's fix their types. We are currently getting some kind of error because we are makingMeta(which is inferred as typenumber) While thebravuraprop (which must be of typeline).

Let's change the nature ofbravuraProperty oflineonestring | numberto also support numeric values:

he writes option value = line | number;he writes possibility ={bravura: option value;Hashtag: line;};he writes accessories ={options: possibility[];bravura: option value; after the change:(Bravura: option value)=> Archive;};

Notice that I introduced a type alias calledoption valueso we don't need to repeat the union typestring | numberat several points.

unfortunately ouraccessoriesthe type is not right. Our option values ​​are now written asstring | number, but it also means that ourafter the changeCallback receives a value of typestring | number. This type does not model the behavior of theselectcorrect component:

• If we pass option values ​​of typeline, to dieafter the changeCallback receives a value of typeline.
• If we pass option values ​​of typenumber, to dieafter the changeCallback receives a value of typenumber.

In other words, we lose type information along the way. This is problematic when we want to use the parameter, for example if we want to callset a goalfunction returned by ouruseStateHook:

• when we calluseStatewith an initial value of"es2019", which is a string, infers TypeScriptMetabe friendlyline.
• when we calluseStatewith an initial value of2019, which is a number that TypeScript infersMetabe friendlynumber.

In any case, a value of typestring | numberis not assignablelineI am notnumber. Therefore, TypeScript throws a type error for theafter the changesupport ourselectElement:

Number type cannot be assigned to SetStateAction type'.

So how do we properly write our React component? The answer isgeneric.

#Step 4 - Using Generics for Precise Accessory Types

Instead of using the typestring | numberLet's use a generic type everywhereTby the values ​​of our options. let's do ouroptionsWrite generically by adding a list of type parameters. Then we use the typeTFor himbravuraProperty:

he writes option value = line | number;he writes possibility<T expanded option value>={bravura: T;Hashtag: line;};

Note that we restrict the type parameterTto expand ouroption valuehe writes. In other words, we can specify any type for the generic type.Tto which it will be assignedstring | number. This one contains…

• To dielinehe writes,
• To dienumberhe writes,
• NoneString-Literaltyp,
• Nonenumeric literal type,
• To dienever write, j
• any combination of the above.

Now that thepossibilitytype is generic, we must provide a type argument when using it tooptionssupport in ouraccessorieshe writes. This, in turn, means that we must actaccessoriesalso generic. Again, let's introduce a generic type parameterTand use it forbravurajafter the changeAccessories:

he writes accessories<T expanded option value>={options: possibility<T>[];bravura: T; after the change:(Bravura: T)=> Archive;};

now thisaccessoriesis a generic type, we need to provide a type argument for the type parameterTif you useaccessoriesinside ourselectComponent. We have to repeat that tooExpand option valueRestriction so we can passToneAccessories<T>- they are turtles down:

occupation select<T expanded option value> (accessories: accessories<T>) { occupation handleOnChange(mi: To react.form event<HTMLSelectElement>) { Constantly{index selected}= mi.current target; Constantly selected option = accessories.options[selected index]; accessories.after the change(selected option.bravura);} give back(<select bravura={accessories.bravura}after the change={controlarcâmbio}>{accessories.options.Map(Possibility=>(<possibility key={possibility.bravura}bravura={possibility.bravura}>{possibility.Hashtag}</possibility>))}</select>);}

we are successfulselecta generic functional component. in itself. This is where TypeScript 2.9 comes in! We can specify a generic type when creating<Select>JSX Element:

occupation The image() { Constantly Goals =[{Bravura: "es3", Hashtag: "ECMAScript 3"},{Bravura: "es5", Hashtag: "ECMAScript 5"},{Bravura: "es2015", Hashtag: "ECMAScript 2015"},{Bravura: "yo2016", Hashtag: "ECMAScript 2016"},{Bravura: "es2017", Hashtag: "ECMAScript 2017"},{Bravura: "es2018", Hashtag: "ECMAScript 2018"},{Bravura: "es2019", Hashtag: "ECMAScript 2019"},]; Constantly[Meta,set a goal]= useState("es2019"); give back(<select<string> options={targets} bravura={target} after the change={define goal}/>);}

Of course, the syntax looks a little strange at first. However, upon reflection, it's consistent with how we've specified generic arguments elsewhere in TypeScript.

Now that we've done itselectcomponent and bothaccessoriesjpossibilitygeneric types, our program type checks seamlessly: no more type errors whether we use strings, numbers, or both for our option values.

Note that we don't need to explicitly specify the generic type argument in the JSX element here. TypeScript can infer this for us! Looking at the type ofbravuraProperties of objects in ourGoalsarray, TypeScript understands that we use values ​​of typelinein this example.

Because TypeScript can infer type contextuallylinefor we can change<Select<Sequence>single again<Select. Here is the complete working example:

he writes option value = line | number;he writes possibility<T expanded option value>={bravura: T;Hashtag: line;};he writes accessories<T expanded option value>={options: possibility<T>[];bravura: T; after the change:(Bravura: T)=> Archive;};occupation select<T expanded option value> (accessories: accessories<T>) { occupation handleOnChange(mi: To react.form event<HTMLSelectElement>) { Constantly{index selected}= mi.current target; Constantly selected option = accessories.options[selected index]; accessories.after the change(selected option.bravura);} give back(<select bravura={accessories.bravura}after the change={controlarcâmbio}>{accessories.options.Map(Possibility=>(<possibility key={possibility.bravura}bravura={possibility.bravura}>{possibility.Hashtag}</possibility>))}</select>);}occupation The image() { Constantly Goals =[{Bravura: "es3", Hashtag: "ECMAScript 3"},{Bravura: "es5", Hashtag: "ECMAScript 5"},{Bravura: "es2015", Hashtag: "ECMAScript 2015"},{Bravura: "yo2016", Hashtag: "ECMAScript 2016"},{Bravura: "es2017", Hashtag: "ECMAScript 2017"},{Bravura: "es2018", Hashtag: "ECMAScript 2018"},{Bravura: "es2019", Hashtag: "ECMAScript 2019"},]; Constantly[Meta,set a goal]= useState("es2019"); give back(<select options={targets} bravura={target} after the change={define goal}/>);}

And let's go! a static typeselectComponent in React using generic type arguments for JSX elements.