TypeScriptの型システム
なぜTypeScriptを使うのか?について説明したとき、TypeScriptの型システムの主な機能を取り上げました。下記は、改めて説明する必要がない、いくつかのキーポイントです:
  • TypeScriptの型システムは使うかどうか選べるものとして設計されているので、あなたが書いたJavaScriptはTypeScriptでもあります
  • TypeScriptは型エラーがあってもJavaScriptの生成をブロックしないので、徐々にJSをTSに更新していくことができます
では、TypeScript型システムの構文から始めましょう。これにより、コード内でこれらのアノテーションをすぐに使用して、その利点を確認することができます。これは後で詳細を掘り下げる準備にもなります。

基本アノテーション

前述のように、:TypeAnnotation構文を使って型アノテーションを書きます。型宣言空間で使用可能なものは、型アノテーションとして使用できます。
次の例は、変数、関数パラメータ、および関数戻り値の型アノテーションを示しています。
1
var num: number = 123;
2
function identity(num: number): number {
3
return num;
4
}
Copied!

プリミティブ型(Primitive Types)

JavaScriptプリミティブ型は、TypeScript型システムでカバーしています。これは、以下に示すように stringnumberbooleanを意味します:
1
var num: number;
2
var str: string;
3
var bool: boolean;
4
5
num = 123;
6
num = 123.456;
7
num = '123'; // Error
8
9
str = '123';
10
str = 123; // Error
11
12
bool = true;
13
bool = false;
14
bool = 'false'; // Error
Copied!

配列(Arrays)

TypeScriptは、配列に専用の構文を提供し、コードにアノテーションを付けて文書化するのを容易にします。構文は、基本的に[]を有効な型アノテーションに後置します(例えば :boolean[])。これは通常行う配列操作を安全に行うことを可能にし、誤った型のメンバを割り当てるなどのエラーからあなたを守ります。これは以下のとおりです:
1
var boolArray: boolean[];
2
3
boolArray = [true, false];
4
console.log(boolArray[0]); // true
5
console.log(boolArray.length); // 2
6
boolArray[1] = true;
7
boolArray = [false, false];
8
9
boolArray[0] = 'false'; // Error!
10
boolArray = 'false'; // Error!
11
boolArray = [true, 'false']; // Error!
Copied!

インターフェース(Interfaces)

インターフェースは、複数の型アノテーションを単一の名前付きアノテーションに合成するための、TypeScriptにおける主要な方法です。次の例を考えてみましょう。
1
interface Name {
2
first: string;
3
second: string;
4
}
5
6
var name: Name;
7
name = {
8
first: 'John',
9
second: 'Doe'
10
};
11
12
name = { // Error : `second` is missing
13
first: 'John'
14
};
15
name = { // Error : `second` is the wrong type
16
first: 'John',
17
second: 1337
18
};
Copied!
ここでは、アノテーションをfirst: string + second: stringという新しいアノテーションNameにまとめて、個々のメンバの型チェックを行っています。インターフェースはTypeScriptで大きなパワーを持っているので、別途専用のセクションでその利点をどのように活かすかを説明します。

インライン型アノテーション(Inline Type Annotation)

新しいinterfaceを作成するのではなく、構造:{/* Structure */}を使ってインラインで必要なものにアノテーションを付けることができます。前の例を、インライン型で再掲します:
1
var name: {
2
first: string;
3
second: string;
4
};
5
name = {
6
first: 'John',
7
second: 'Doe'
8
};
9
10
name = { // Error : `second` is missing
11
first: 'John'
12
};
13
name = { // Error : `second` is the wrong type
14
first: 'John',
15
second: 1337
16
};
Copied!
インライン型は、1回だけ使うようなアノテーションを素早く提供するのに最適です。それは(良くないかもしれない)型名を考える手間を省きます。しかし、同じ型アノテーションを複数回インラインで入れている場合は、それをインターフェース(またはこのセクションの後半で説明するtype alias)にリファクタリングすることを検討することをお勧めします。

特殊な型

上記でカバーしたプリミティブ型以外にも、TypeScriptでは特別な意味を持ついくつかの型があります。これらはanynullundefinedvoidです。

any

any型は、TypeScript型システムにおいて特別なものです。これは、型システムからの脱出口を与えて、コンパイラに失せるよう指示します。anyは型システムのすべての型と互換性があります。つまり、any型の変数には何でも代入できるし、その変数を何にでも代入できるということです。以下に例を示します:
1
var power: any;
2
3
// Takes any and all types
4
power = '123';
5
power = 123;
6
7
// Is compatible with all types
8
var num: number;
9
power = num;
10
num = power;
Copied!
JavaScriptコードをTypeScriptに移植する場合、最初はanyと友達になります。しかし、型安全性を確保することはあなた次第であるため、この友情を真剣に受け止めてはいけません。これを使うことは、基本的に、コンパイラに意味のある静的解析を行わないように指示することです。

nullundefined

strictNullChecksフラグ(このフラグについては、後で扱います)によって扱いが変わります。strictNullChecksfalseの場合、nullundefinedのJavaScriptリテラルは、型システムにおいてはany型と同じようなものとして扱われます。これらのリテラルは他の型に代入することができます。以下に例を示します:
1
var num: number;
2
var str: string;
3
4
// These literals can be assigned to anything
5
num = null;
6
str = undefined;
Copied!

:void

関数に戻り値の型がないことを示すには:voidを使います:
1
function log(message): void {
2
console.log(message);
3
}
Copied!

ジェネリックス(Generics)

コンピュータサイエンスの多くのアルゴリズムとデータ構造は、オブジェクトの実際の型に依存しません。しかし、それでも、あなたは、さまざまな変数の間で制約を適用したいと考えているでしょう。単純なおもちゃの例は、項目のリストを取り、逆順にした項目のリストを返す関数です。ここでの制約は、関数に渡されるものと関数によって返されるものの間の制約です。
1
function reverse<T>(items: T[]): T[] {
2
var toreturn = [];
3
for (let i = items.length - 1; i >= 0; i--) {
4
toreturn.push(items[i]);
5
}
6
return toreturn;
7
}
8
9
var sample = [1, 2, 3];
10
var reversed = reverse(sample);
11
console.log(reversed); // 3,2,1
12
13
// Safety!
14
reversed[0] = '1'; // Error!
15
reversed = ['1', '2']; // Error!
16
17
reversed[0] = 1; // Okay
18
reversed = [1, 2]; // Okay
Copied!
ここでは、reverse関数は何らかの型Tの配列(items: T[])を受け取り(reverse<T>の型パラメータに注目)、T型の配列を返します(: T[]に注目)。 reverse関数は、同じ型の項目を返すので、reversed変数もnumber[]型であることがTypeScriptに分かるため、型の安全性が得られます。同様にstring[]の配列をreverse関数に渡すと、返される結果もstring[]の配列になり、以下に示すような型安全性が得られます:
1
var strArr = ['1', '2'];
2
var reversedStrs = reverse(strArr);
3
4
reversedStrs = [1, 2]; // Error!
Copied!
実際、JavaScript配列には既に.reverse関数があり、TypeScriptはジェネリックを使ってその構造を定義しています:
1
interface Array<T> {
2
reverse(): T[];
3
// ...
4
}
Copied!
これは、以下のように任意の配列で .reverseを呼び出すときに型の安全性を得られることを意味します:
1
var numArr = [1, 2];
2
var reversedNums = numArr.reverse();
3
4
reversedNums = ['1', '2']; // Error!
Copied!
後で、アンビエント宣言(Ambient Declarations)の節でlib.d.tsを説明するときに、Array<T>インターフェースについてもっと議論します。

ユニオン型(Union Type)

JavaScriptでは、プロパティを複数の型のうちの1つにしたいことがよくあります(例:stringまたはnumber)。そういった場合、ユニオン型(型アノテーションの|を使いstring|numberのように書く)が便利です。よくある使用例として、単一のオブジェクトまたはオブジェクトの配列をとることができる関数があげられます。
1
function formatCommandline(command: string[]|string) {
2
var line = '';
3
if (typeof command === 'string') {
4
line = command.trim();
5
} else {
6
line = command.join(' ').trim();
7
}
8
9
// Do stuff with line: string
10
}
Copied!

交差型(Intersection Type)

オブジェクト拡張(extend)はJavaScriptで非常に一般的なパターンです。ここでは2つのオブジェクトを取得し、これらのオブジェクトの両方の機能を持つ新しいオブジェクトを作成します。交差型では、以下に示すようにこのパターンを安全な方法で使用できます。
1
function extend<T, U>(first: T, second: U): T & U {
2
return { ...first, ...second };
3
}
4
5
const x = extend({ a: "hello" }, { b: 42 });
6
7
// x now has both `a` and `b`
8
const a = x.a;
9
const b = x.b;
Copied!

タプル型

JavaScriptには、第一級のタプルのサポートがありません。人々は、一般にタプルとして配列を使用します。これはまさにTypeScriptの型システムがサポートしているものです。タプルは、: [typeofmember1, typeofmember2]といったようにアノテーションを付けることができます。タプルには、任意の数のメンバを含めることができます。タプルの例:
1
var nameNumber: [string, number];
2
3
// Okay
4
nameNumber = ['Jenny', 8675309];
5
6
// Error!
7
nameNumber = ['Jenny', '867-5309'];
Copied!
これをTypeScriptの分解(Destructuring)のサポートと組み合わせると、タプルは、その実態は配列であるとはいえ、かなり第一級であるように感じられます:
1
var nameNumber: [string, number];
2
nameNumber = ['Jenny', 8675309];
3
4
var [name, num] = nameNumber;
Copied!

型エイリアス(Type Alias)

TypeScriptは、複数の場所で使用したい型アノテーションの名前を提供するための便利な構文を提供します。エイリアスは type SomeName = someValidTypeAnnotation構文を使用して作成できます。例:
1
type StrOrNum = string|number;
2
3
// Usage: just like any other notation
4
var sample: StrOrNum;
5
sample = 123;
6
sample = '123';
7
8
// Just checking
9
sample = true; // Error!
Copied!
interfaceとは違って、型エイリアスは文字通りどんな型アノテーションにも与えることができます(ユニオン型や交差型のようなものに便利です)。構文に慣れ親しむための例をいくつか次に示します。
1
type Text = string | { text: string };
2
type Coordinates = [number, number];
3
type Callback = (data: string) => void;
Copied!
ヒント:型アノテーションの階層を持つ必要がある場合は、interfaceを使います。インターフェースはimplementsextendsで使うことができます
ヒント:型エイリアスは、比較的単純なオブジェクト構造(Coordinates(座標)のような)にセマンティックな名前を付けるために使いましょう。また、ユニオン型や交差型にセマンティックな名前を付けたい場合に用いるのもよいでしょう。

まとめ

これで、ほとんどのJavaScriptコードに型アノテーションを付けることができるようになりました。これで、TypeScriptの型システムで使用可能なすべての機能の詳細を説明できます。