Editor's note:This guide to using TypeScript with React was last updated on August 2, 2022 and includes an overview of the benefits of TypeScript with React and information about .tsx files.

In this tutorial, you'll learn everything you need to know about using TypeScript in your React projects. You'll also learn why you should use TypeScript in React, how to install and configure TypeScript, and how to use TypeScript interfaces with React components.

We cover the following with examples:

• What is Respond?
• What is TypeScript?
  • A JavaScript superset
• Is React better than TypeScript?
  • Variable and error checks
  • Readable, understandable code
  • Interfaces
  • Better support for JSX
  • IDE support
  • Support for existing React projects
  • Community
• Understanding .tsx files in Typescript
  • Difference between .ts and .tsx in TypeScript
• Install and configure TypeScript
• How does TypeScript compile React code?
• Configure webpack for React and TypeScript
• Add npm scripts
• Create the index.tsx file
• Create React components in TypeScript
• Using TypeScript interfaces with React components

What is Respond?

Created by Facebook and originally open sourced in 2013, React has become one of the most popular libraries in the frontend world today. React is easily extensible and can include features such as routing patterns and state management with libraries such asRedux. React is minimal in its footprint, but can be adapted for almost any project.

For more information about High-Level React, see the officialAnswer documentation.

What is TypeScript?

TypScriptis a free and open source programming language developed and maintained by Microsoft. It is a strict superset of JavaScript that optionally adds static typing and class-based, object-oriented programming to the language.

A JavaScript superset

JavaScript was originally created as a client-side language, but over time developers realized that JavaScript could be used server-side, especially with the invention of the v8 engine.

JavaScript can quickly become complex and sometimes cannot take full advantage of the capabilities of an object-oriented programming language. TypeScript was born to bridge this gap and become an alternative for enterprise level development.

TypeScript emits JavaScript when compiled and is a household name in the JavaScript world these days. Even pure JavaScript applications provide onetypetype definition for TypeScript developers.

Is React better than TypeScript?

TypeScript can be useful to React developers in many ways. Below are just a few benefits of using TypeScript in React:

Variable and error checks

TypeScript provides variable checks by checking the data type assigned to statically defined variables. This generally reduces the chance of assigning the wrong types to our variables.

TypeScript also performs compile-time checks that help flag errors such as incorrect parameter assignments, syntax errors, and more. This is great because it reduces the chance of calling the wrong function or accidentally omitting a variable declaration.

Readable, understandable code

The key to TypeScript is that it is a statically typed script. Programming languages ​​can be statically or dynamically typed - the difference is when the type checking takes place. Static language variables are checked by type.

Interfaces

TypeScript allows you to define complex type definitions in the form of interfaces. This is useful when you have a complex type that you want to use in your application, such as an object that contains other properties. This results in tight controls, reducing the number of potential errors you can create without.

Better support for JSX

JSX stands for JavaScript XML. It allows us to write HTML code directly in the React project. Using TypeScript with React provides better IntelliSense and code completion for JSX.

IDE support

TypeScript is also very useful when using IDEs like Visual Studio, Visual Studio Code, Atom, Webstorm, Eclipse, and more. These allow for better auto-completion and snippet generation, speeding up development.

Support for existing React projects

TypeScript allows you to incrementally adapt its use to your existing projects. You can also configure the TypeScript compiler for this use case. Find a list of TypeScript compilers on the officialTypeScript documentation.

Community

Finally, TypeScript is an open source language supported by Microsoft. It is widely loved and used by millions of developers around the world. Because it's so widely used, it's easy to find support and answers to your questions if you get stuck learning or using TypeScript.

Understanding.tsxfiles in TypeScript

His introduction.tsxin TypeScript, several versions came after TypeScript v1.0. According to the release notes for TypeScript v1.6 true.tsxExtension has been introduced, the new extension is designed to do two things:

• Enable JSX in TypeScript files
• Make it newifoperator the standard way of casting

His introduction.tsxit also led to three additional things:

• JavaScript bundles like webpack, ESBuild and others can perform various plugins.tsxarchives
• Test runners like Jest can only run for a different test environment.tsxarchives
• New language support from code editors

Difference between.tsIn.tsxin TypeScript

His introduction.tsxThe file extension caused the need for clarification. Many developers wanted to know the difference between the new file extension and the already existing one.ts.

The difference is really quite simple! The.tsThe file extension is used when you create functions, classes, reducers, etc. which do not need syntax and JSX components, while.tsxThe file extension is used when you create a React component and use JSX components and syntax.

Install and configure TypeScript

Now that we have had a general overview, let's proceed with the installation. There are two ways to install TypeScript and get started

• Usingnpm
• Usingmake-react-app

To install TypeScript usingnpm, run the following in your terminal:

npm install -g font

Since we've installed TypeScript globally, we need to link it this waynpmknows the location.

To do this, we run:

npm link typographic

Once npm is done, you can verify that TypeScript is installed correctly:

tsc --v // Version 4.7.4

The above will print the version number of the installed TypeScript.

To get started with a project after a successful installation, create a folder where the application will be stored.

Create a new folder:

mkdir typescript-react-project

Change folder to the new folder:

>cd typescript-react-project

Start the project:

npm start

To install TypeScript withmake-react-app, run the following one-liner in your terminal:

npx make-react-app .

The above command creates a simple folder structure for your application, then installs all necessary modules and launches your project for you.

For this tutorial, we will use thenpm startmethod.

How does TypeScript compile React code?

TypeScript always looks for a named filetsconfig.jsonin the project root folder for instructions. When it's thetsconfig.jsonfile, loads the settings defined in the file and uses them to build the project.

A TypeScript project is compiled in one of the following ways:

• With the invocationtscno input files, so the compiler looks for ittsconfig.jsonfile that starts in the current directory and continues up the parent directory chain
• With the invocationtscno input files and a--work(or just-PI) command line option that specifies the path of a directory containing atsconfig.jsonfile or a path to a valid.jsonconfiguration file

When input files are specified on the command line,tsconfig.jsonfiles are ignored.

If you don't have ittsconfig.jsonfile in your root directory, go ahead and create it and add the following code:

{ "compilerOptions": { "outDir": "./dist/", "noImplicitAny": true, "module": "es6", "target": "es5", "jsx": "react", "allowJs" : true, "moduleResolution": "node", }}

The JSON configuration above defines two main sections: thecompilerOptiesInto rule outParameters.

In compiler options, a target ofes6established. This means that the JavaScript engine target is set toes6but it will compile toes5as a target. Note that a key is also mentionedjsx, which is set toReply. This tells TypeScript to compile JSX files as React files. This is similar to runningtsc  --jsx reply. Ofby Directoris the output folder after compilation.

In theto rule outBLOCK,node_modulesdefined for it. TypeScript scans itnode_modulesfolder for each TypeScript file at compile time.

If you're familiar with TypeScript and its configuration, you might be wondering whyParticipationpart is missing. This is because we are going to configurewebpackto take the input files, pass them to TypeScript for compilation, and return a JavaScript script for browsers.

More information about other configuration options can be found atTypeScript documents.

Configure webpack for React and TypeScript

webpackis a tool that allows you to compile JavaScript modules and is also known as a function package.

To start withwebpakket in TypeScript, we need to install webpack and a webpack plugin calledts charger. To do this, run the following command in the terminal:

npm installeer webpack webpack-cli ts-loader

What ists charger? As the name suggests,ts chargeris the TypeScript loader for webpack. Simply put, it's a plugin that makes webpack work well with TypeScript.

Like TypeScript, webpack also checks for a named filewebpack.config.jsfor configuration.

If it doesn't already exist, create a new file namedwebpack.config.jsand add the following code:

const path = require('path'); module.exports = { entry: './src/index.tsx', module: { lines: [ { test: /\.tsx?$/, usage: 'ts-loader ', excludes: /node_modules/, }, ], }, resolve: { extensions: ['.tsx', '.ts', '.js'], }, output: { filename: 'bundle.js', path : path.resolve(__dirname, 'dist '), },};

The above code instructs webpack to enter through it./src/index.tsfile, load and compile all.tsIn.tsxfiles through itts chargerand then run abundle.jsfile in ourdistanceMap.

Additionnpmscenarios

After setting everything up so far, it wouldn't make sense if you could just run a command likenpm does magicwhen you want to make a package? Yes it would be. So open itpacked.jsonfile in the project root and update itscenariosunit with:

"scripts": { "magie": "webpack"}

Creating itindex.tsxduration

Once all the above configurations are done, it's time to create our project's main entry point file, but before we do that we need to install the following:

npm install react-dom @types/react @types/react-dom

Then create a new foldersrcand then a file insrccalled folderindex.tsxat the root and add the following code:

import * as React from "react", import * as ReactDOM from "react-dom", ReactDOM.render(
Hello, welcome to React and TypeScript
, document.getElementById( "wortel"));

Above is a simple React configuration, except it uses TypeScript. Run the following command in your terminal to compile the file:

npm does magic

A build directory containing a file calledbundle.jsMade.

Does this newly created package work as expected? Create a new oneindex.htmlfile showing the new version to find out:

If you double click on theindex.htmlfile to open it in a browser, you will see:

Create React components in TypeScript

Now that we're comfortable with the basics of writing React in TypeScript, let's take a look at how to create React components, as this is an essential part of developing our app.

In the already createdsrcfolder, we add a folder namedcomponents. This is the folder that contains every React component we create. In thecomponentsfolder, proceed to create a new file namedFirstComponent.tsxand add the following code:

import * as React from "react"; allow Logo ="https://logrocket-assets.io/static/home-hero-c97849b227a3d3015730e3371a76a7f0.svg"; export standaardklasse FirstComponent breidt {{{Component under}> React. { RETURN (
 
A simple react component example using Typescript
 
  
 
This item displays the Logrocket logo.
 
For more information about Logrocket, visit https://logrocket.com
 
) }}

The code block above is a simple React component that returns a logo and some text.

To make this new component accessible to React, we need to import and use the component in baseindex.tsxfile. Update itindex.tsxfile in:

import * as React from "react", import * as ReactDOM from "react-dom", import FirstComponent from './components/FirstComponent'ReactDOM.render(
 
Hello, welcome to React and TypeScript
  
, document.getElementById("root"));

If you look at the code block above, you can see that the differences are in lines 3 and 7, where you inserted and rendered the new element, respectively.

If you thenpm does magiccommand and go to your browser, you will see:

Using TypeScript interfaces with React components

One of the key principles of TypeScript is that type checking focuses on the form values ​​take. This is also known as duck typing or structural subtyping.

In TypeScript, interfaces serve the role of naming these types and are a powerful way to define conventions within your code and conventions with code outside of your project.

Create a file to see how to use interfaces with react componentsUser interface.tsin thesrcfolder and add the following code:

export standard interface Username: string; age: number; address: string; dob: Date?}

The code block above defines a simple UI, which is passed as props to a new element. Because this interface is strongly typed, note that you cannot pass an integer for the name key, since the value is a string.

Create a new part in uscomponentscalled folderUserComponent.tsxand add the following code:

import * as React from "react"; import UserInterface from '../UserInterface'export standaardklasse UserComponent breidt React.Component{constructor (props: UserInterface){ super(props);}render() { return (
 
Custom item
Hello,{this.props.name} 
Are you{this.props.age} years old 
You live in:{this.props.address} 
You were born:{this.props.dob.toDateString()} 
) }}

The code block above is self-explanatory. TheUser environmentpreviously created has been imported and passed as its propsCustom item. In the constructor we checked that the passed props are of type UserInterface and in the render function the data is displayed on our page.

After our creationCustom item, update deindex.tsxduration:

import * as React from "react", import * as ReactDOM from "react-dom", import FirstComponent from './components/FirstComponent' import UserComponent from './components/UserComponent'ReactDOM.render(
 
Hello, welcome to React and TypeScript
   
, document.getElementById("root"));

Clean up nownpm does magic, go to your browser and see the updated changes. Must see:

conclusion

In this tutorial, we showed you how to use TypeScript with React. We also looked at the configuration modewebpackmetts chargerto compile the TypeScript files and ship a final version.

The code base for this tutorial is available to play with hereGitHub.