React

セットアップ

    ファイル拡張子.tsx(.tsの代わりに)を使用してください。
    tsconfig.jsoncompilerOptions"jsx" : "react"を使ってください。
    JSXとReactの定義をあなたのプロジェクトにインストールします:(npm i -D @types/react @types/react-dom)。
    reactを.tsxファイルにインポートします(import React from "react"となります)。
ReactとTypeScriptのプロジェクトをセットアップする一番簡単な方法は、Create React Appを使うことです。このツールはReactチームから提供されているツールです。公式にTypeScriptのテンプレートが提供されています。Create React Appを使うには、$ npm i -g create-react-appというコマンドでローカルPCにグローバルにインストールできます。そうすれば、Reactの公式Webサイトに書かれているように$ npx create-react-app my-app --template typescriptというコマンドで、最初からTypeScriptを利用可能なプロジェクトを簡単に作成できます。

HTMLタグ vs Component

Reactは、HTMLタグ(文字列)または、React Component(クラス)を表示できます。これらのJavaScriptへのコンパイル結果は同じではありません(例えば、、React.createElement('div')React.createElement(MyComponent)のJavaScriptのコンパイル結果に同じではありません)。どちらとして扱われるかは、最初の文字のケース(大文字小文字)です。fooはHTMLタグとして扱われます。そして、Fooはコンポーネントとして扱われます。

型チェック(Type Checking)

HTMLタグ

HTMLタグfooの型はJSX.IntrinsicElements.fooです。これらの主要な型は、セットアップの一部としてインストールした型定義ファイルreact-jsx.d.tsの中で、予め定義されています。下記にその中に含まれる型定義のサンプルを示します。
1
declare module JSX {
2
interface IntrinsicElements {
3
a: React.HTMLAttributes;
4
abbr: React.HTMLAttributes;
5
div: React.HTMLAttributes;
6
span: React.HTMLAttributes;
7
8
/// などなど
9
}
10
}
Copied!

Functionコンポーネント(Functional Components)

単にReact.FCインターフェースを使ってステートレスなFunctionコンポーネントを定義することができます。React.FCは単に、React.FunctionComponentの短いバージョンです。
1
type Props = {
2
foo: string;
3
}
4
const MyComponent: React.FC<Props> = (props) => {
5
return <span>{props.foo}</span>
6
}
7
8
<MyComponent foo="bar" />
Copied!

クラスコンポーネント(Class Components)

コンポーネントは、propsプロパティに基づいて型チェックされます。コンポーネントは、JSXが、どのように変換されるか、ということを考慮して型チェックされます。例えばJSXのタグの属性は、コンポーネントのpropsの一部である必要があります。
Reactのステートフルなコンポーネントを作成するには、クラスを使用します。型定義ファイルreact.d.tsは、React.Component<Props,State>クラスを定義しています。このクラスを、コンポーネントを作成するときに継承します。このクラスは、そのコンポーネント独自のPropsStateの型をジェネリクスとして設定できるようになっています。これを以下の例で示します(下記の例では、Stateには空のオブジェクト型を設定しています):
1
type Props = {
2
foo: string;
3
}
4
class MyComponent extends React.Component<Props, {}> {
5
render() {
6
return <span>{this.props.foo}</span>
7
}
8
}
9
10
<MyComponent foo="bar" />
Copied!

React JSX のヒント: レンダリング可能なインターフェース

ReactはJSXstringをレンダリングすることができます。これらはすべてReact.ReactNode型に統合されていますので、レンダリング可能なものを受け入れる場合などに使用してください。
1
type Props = {
2
header: React.ReactNode;
3
body: React.ReactNode;
4
}
5
class MyComponent extends React.Component<Props, {}> {
6
render() {
7
return <div>
8
{this.props.header}
9
{this.props.body}
10
</div>;
11
}
12
}
13
14
<MyComponent header="これはヘッダーです" body="これはボディです" />
Copied!

React JSX のヒント:コンポーネントのインスタンスを受け入れる

Reactの型定義ファイルは、React.ReactElement<T>という型を提供しています。これを、<T/>クラスコンポーネントのインスタンスを保持できる型アノテーションに利用できます。例えば以下の通りです:
1
class MyAwesomeComponent extends React.Component {
2
render() {
3
return <div>こんにちは</div>;
4
}
5
}
6
7
const foo: React.ReactElement<MyAwesomeComponent> = <MyAwesomeComponent />; // Okay
8
const bar: React.ReactElement<MyAwesomeComponent> = <NotMyAwesomeComponent />; // Error!
Copied!
もちろん、これを関数の引数や、コンポーネントのPropsの型として使用することもできます。

React JSXのヒント: propsを受け取り、JSXでレンダリングできるコンポーネントを受け入れる

React.Component<Props>React.ComponentClass<P> | React.StatelessComponent<P>のように2つの種類のコンポーネントの型を統合しています。なので、Props型を受け取り、JSXを使ってレンダリングする何かを受け入れることができます。
1
const X: React.Component<Props> = foo; // どこかから渡されたコンポーネント
2
3
// XコンポーネントにPropsを渡して表示:
4
<X {...props}/>;
Copied!

React JSXのヒント: ジェネリックコンポーネント

これは、期待どおりに動作します。以下に例を示します:
1
/** ジェネリックコンポーネント */
2
type SelectProps<T> = { items: T[] }
3
class Select<T> extends React.Component<SelectProps<T>, any> { }
4
5
/** 使い方 */
6
const Form = () => <Select<string> items={['a','b']} />;
Copied!

ジェネリック関数

次のようなものがうまくいきます:
1
function foo<T>(x: T): T { return x; }
Copied!
しかし、アロー関数のジェネリック関数を利用しようとすると、構文エラーになります。
1
const foo = <T>(x: T) => x; // ERROR : `T` タグが閉じられていません
Copied!
回避策:ジェネリックのパラメータにextendsを使用すると、コンパイラがジェネリックであることを教えられます。extendsは、ジェネリックの型に制約を付けるためのキーワードです。{}extendsする、ということは、オブジェクトであれば、何でも良い、ということです。なので、単に構文エラーを回避するために、このようにすることができます:
1
const foo = <T extends {}>(x: T) => x;
Copied!

Reactのヒント: 厳密に型付けされたRef

基本的にRefの変数をユニオン型で定義することによって、nullで初期化できます。そして、それをコンポーネントのrefプロパティに渡したコールバック関数で初期化できます。
1
class Example extends React.Component {
2
example() {
3
// ... 何らかの処理
4
}
5
6
render() { return <div>Foo</div> }
7
}
8
9
10
class Use {
11
exampleRef: Example | null = null;
12
13
render() {
14
return <Example ref={exampleRef => this.exampleRef = exampleRef } />
15
}
16
}
Copied!
これは、DOM要素の参照を保持する変数についても同じです。
1
class FocusingInput extends React.Component<{ value: string, onChange: (value: string) => any }, {}>{
2
input: HTMLInputElement | null = null;
3
4
render() {
5
return (
6
<input
7
ref={(input) => this.input = input}
8
value={this.props.value}
9
onChange={(e) => { this.props.onChange(e.target.value) } }
10
/>
11
);
12
}
13
focus() {
14
if (this.input != null) { this.input.focus() }
15
}
16
}
Copied!

型アサーション

既に説明した のように、型アサーションにはas Foo構文を使います。

デフォルトProps

    デフォルト値のあるPropsを持ったステートフルなコンポーネント: Nullアサーション演算子?を使って、デフォルト値のあるPropsを定義できます。このPropsには、(外部からReactの仕組みによって)値が渡されます(これが最も理想的なものとは限りませんが、今思いつく限りでは、シンプルでミニマムなコードです)。
1
class Hello extends React.Component<{
2
/**
3
* @default 'TypeScript'
4
*/
5
compiler?: string,
6
framework: string
7
}> {
8
static defaultProps = {
9
compiler: 'TypeScript'
10
}
11
render() {
12
const compiler = this.props.compiler!;
13
return (
14
<div>
15
<div>{compiler}</div>
16
<div>{this.props.framework}</div>
17
</div>
18
);
19
}
20
}
21
22
ReactDOM.render(
23
<Hello framework="React" />, // TypeScript React
24
document.getElementById("root")
25
);
Copied!
    デフォルトPropsのあるFunctionコンポーネント :シンプルなJavaScriptの構文を活用して、TypeScriptの型システムとうまく組み合わせることをお勧めします。下記はその例です:
1
const Hello: React.FC<{
2
/**
3
* @default 'TypeScript'
4
*/
5
compiler?: string,
6
framework: string
7
}> = ({
8
compiler = 'TypeScript', // デフォルト値のあるProps
9
framework
10
}) => {
11
return (
12
<div>
13
<div>{compiler}</div>
14
<div>{framework}</div>
15
</div>
16
);
17
};
18
19
20
ReactDOM.render(
21
<Hello framework="React" />, // TypeScript React
22
document.getElementById("root")
23
);
Copied!

WebComponentの宣言

もしWebComponentを利用している場合、それはReactの型定義ファイル(@types/react)には定義されていません。しかし、アンビエント宣言(declare)を使って簡単に定義できます。例えば、my-awesome-sliderというWebComponentがあるとします。これは、MyAwesomeSliderPropsを受け取ります。この場合、以下のようになります:
1
declare global {
2
namespace JSX {
3
interface IntrinsicElements {
4
'my-awesome-slider': MyAwesomeSliderProps;
5
}
6
7
interface MyAwesomeSliderProps extends React.Attributes {
8
name: string;
9
}
10
}
11
}
Copied!
最終更新 1yr ago