TypeScript初心者向け：型推論を徹底解説！効果的な使い方と実践例

TypeScriptの型推論は、プログラミング初心者にとって特に役立つ機能の一つです。型推論とは、プログラマが明示的に型を指定しなくても、コンパイラがコードから型を自動的に判断してくれる仕組みです。この機能によって、コードの読みやすさや記述量が改善され、ミスを防ぐことができます。本記事では、TypeScript初心者向けに、型推論の基本的な概念から、変数や関数での具体的な使い方、よくある誤解までを徹底的に解説し、実践的に理解できるようにサポートします。

型推論とは何か

型推論とは、プログラマが明示的に型を指定しなくても、TypeScriptのコンパイラがコードの内容を解析し、適切な型を自動的に割り当てる仕組みです。これは、JavaScriptの柔軟さと静的型付けの安全性を両立するために導入された強力な機能です。

型推論の利便性

型推論の最大の利点は、コードが簡潔になり、開発者が型を明示的に記述する手間を省けることです。また、コードの保守性が向上し、エラーが発生する前に発見できる可能性が高まります。TypeScriptの型推論は非常に賢く、変数や関数の戻り値、オブジェクトのプロパティなどに対して自動的に型を判断してくれます。

TypeScriptが推論するタイミング

型推論は、以下のような場面で発生します：

• 変数や定数の初期化時
• 関数のパラメータや戻り値
• 配列やオブジェクトの操作時
  これらの場面で適切な型を自動的に推論することで、コードの安全性を高めることができます。

TypeScriptの型推論の基本ルール

TypeScriptの型推論は、シンプルで直感的なルールに基づいて動作します。開発者が明示的に型を指定しなくても、コンパイラがコードの内容を解析し、適切な型を自動的に割り当てることでコードを強力にサポートします。ここでは、型推論がどのように行われるか、基本的なルールを見ていきます。

変数に対する型推論

TypeScriptは、変数が初期化されたときに、その値から自動的に型を推論します。例えば、次のように数値を代入した場合、コンパイラはその変数の型を number と推論します。

let age = 25;  // TypeScriptはageをnumber型と推論

このように、値を基にして型を推論するため、変数に対して型を明示的に指定する必要がなくなります。

関数に対する型推論

関数でも同様に、引数や戻り値の型が明示されていなくても、TypeScriptはその実装を基に型を推論します。例えば、次の関数では、戻り値が number であると自動的に推論されます。

function add(a: number, b: number) {
  return a + b;  // 戻り値はnumber型と推論
}

このように、TypeScriptは関数の実装に基づいて、引数や戻り値の型を推論します。

初期化時の型が基準

型推論は主に、変数や関数が最初に定義される際の初期化値を基に行われます。初期化後に別の型の値を代入しようとすると、コンパイルエラーが発生します。

let message = "Hello";  // TypeScriptはmessageをstring型と推論
message = 42;  // エラー: number型をstring型に代入できない

このように、型推論はプログラムの初期状態を基準にしており、一貫性を保つための助けとなります。

変数宣言と型推論の例

TypeScriptの型推論は、特に変数宣言時にその威力を発揮します。プログラマが型を明示的に指定しなくても、TypeScriptが自動的に最適な型を割り当ててくれるため、コードをよりシンプルに保つことができます。ここでは、変数宣言における型推論の具体例を見ていきます。

数値型の推論

変数に数値を代入すると、TypeScriptはその変数を自動的に number 型と推論します。以下の例では、price という変数が初期化時に数値を持つため、コンパイラはこの変数を number 型と判断します。

let price = 1500;  // priceはnumber型と推論される

ここで price に対して文字列などの他の型を代入しようとすると、エラーが発生します。

price = "高すぎる";  // エラー: string型をnumber型に代入できない

文字列型の推論

同様に、文字列を代入する変数には、string 型が推論されます。次の例では、name という変数が文字列で初期化され、TypeScriptが自動的に string 型と推論します。

let name = "TypeScript";  // nameはstring型と推論される

name に数値などを代入すると、エラーが出るため、型の一貫性を保つことができます。

name = 123;  // エラー: number型をstring型に代入できない

配列の型推論

TypeScriptは、配列に対しても自動的に型推論を行います。例えば、次の例では数値の配列が宣言されており、TypeScriptはこの配列を number[] 型と推論します。

let scores = [85, 90, 78];  // scoresはnumber[]型と推論される

もし配列に異なる型の要素を追加しようとすると、コンパイルエラーが発生します。

scores.push("100");  // エラー: string型の値をnumber[]型に追加できない

このように、TypeScriptの型推論により、変数や配列の型が自動的に適切に推論され、型の安全性が保証されます。

関数の戻り値と型推論

TypeScriptでは、関数の戻り値にも型推論が適用されます。開発者が明示的に型を指定しなくても、関数の中で実行される処理に基づいて戻り値の型が推論されます。これにより、コードの簡潔さが保たれ、関数の戻り値に関するエラーを防ぐことができます。

戻り値の型推論の基本

TypeScriptは、関数の実装内容に基づいて戻り値の型を推論します。例えば、次の例では関数 sum が引数として number 型の値を受け取り、その合計を返します。戻り値が数値であるため、TypeScriptは自動的にこの関数の戻り値の型を number と推論します。

function sum(a: number, b: number) {
  return a + b;  // 戻り値はnumber型と推論される
}

このように、関数の戻り値に型注釈を明示する必要がなく、TypeScriptが適切な型を自動で判断します。

条件分岐による戻り値の型推論

関数の中で条件分岐がある場合、TypeScriptはすべての戻り値の型を検証して、最も適切な型を推論します。例えば、次の例では multiplyOrReturnString という関数が、条件に応じて数値または文字列を返します。TypeScriptはすべての分岐を解析し、最も一般的な型である string | number （ユニオン型）を戻り値として推論します。

function multiplyOrReturnString(a: number, b: number): number | string {
  if (a * b > 100) {
    return "大きすぎます";
  }
  return a * b;
}

ここでは、a * b が100を超えた場合は文字列が、超えない場合は数値が返されるため、戻り値の型は number | string となります。

明示的な型注釈と推論の併用

関数の戻り値の型を明示的に指定したい場合も、型注釈を利用して明確に定義することができます。しかし、型推論が働く場合、明示的な型注釈は不要です。例えば、次の例では戻り値の型がすでに string と推論されているため、型注釈を省略しても問題ありません。

function greet(name: string) {
  return `Hello, ${name}!`;  // 戻り値はstring型と推論される
}

型注釈は必要に応じて使用し、基本的にはTypeScriptの型推論に任せることで、よりシンプルで安全なコードを書くことができます。

配列やオブジェクトでの型推論

TypeScriptでは、配列やオブジェクトに対しても型推論が自動的に行われます。これにより、複雑なデータ構造でも適切な型を自動で割り当てることができ、開発者が明示的に型を指定する手間を減らすことができます。

配列での型推論

TypeScriptは、配列の初期化時にその要素の型を推論します。例えば、次の例では、numbers という配列が数値で初期化されているため、TypeScriptはこの配列を number[] 型として推論します。

let numbers = [1, 2, 3, 4, 5];  // numbersはnumber[]型と推論される

ここで、配列に文字列や他の型を追加しようとすると、エラーが発生します。

numbers.push("six");  // エラー: string型の値をnumber[]型に追加できない

このように、TypeScriptの型推論により、配列に含まれるすべての要素の型が一貫して number であることが保証されます。

オブジェクトでの型推論

オブジェクトもまた、プロパティの型を基に自動で型が推論されます。次の例では、person というオブジェクトが宣言されており、TypeScriptはそれぞれのプロパティ name と age の型を string と number として推論します。

let person = {
  name: "Alice",
  age: 30
};  // personは{name: string, age: number}型と推論される

プロパティに対して異なる型の値を代入しようとすると、エラーが発生します。

person.age = "thirty";  // エラー: string型をnumber型に代入できない

TypeScriptはオブジェクト全体の構造を把握し、各プロパティの型を適切に推論するため、誤った型の値がプロパティに割り当てられることを防ぎます。

ネストしたオブジェクトの型推論

オブジェクトの中にオブジェクトがネストされている場合でも、TypeScriptはそのネストされたオブジェクトの型を正確に推論します。次の例では、company というオブジェクトが、employees という配列をプロパティとして持っています。この場合、TypeScriptは company の型を自動的に推論し、ネストされたプロパティもすべて型が保証されます。

let company = {
  name: "Tech Co.",
  employees: [
    { name: "John", role: "Engineer" },
    { name: "Jane", role: "Designer" }
  ]
};  // companyは{name: string, employees: {name: string, role: string}[]}型と推論される

このように、TypeScriptはネストされたオブジェクトや配列にも対応して、型の一貫性と安全性を提供します。これにより、より複雑なデータ構造を扱う際も、型の安全性を保ちながら開発を進めることが可能です。

型注釈と型推論の併用方法

TypeScriptでは、型推論に頼るだけでなく、必要に応じて明示的に型注釈を付けることも可能です。型注釈と型推論を上手に併用することで、コードの読みやすさや安全性をさらに高めることができます。ここでは、どのように型注釈と型推論を併用すべきかを解説します。

型推論に頼れるケース

型推論が適切に機能する場面では、特に明示的な型注釈を付ける必要はありません。例えば、変数や関数の戻り値の型が自明な場合には、型推論に任せることでコードをシンプルに保つことができます。

let score = 85;  // scoreはnumber型と推論される

このような場合、型注釈を省略しても問題ありません。TypeScriptが自動的に適切な型を推論してくれるため、開発速度を上げることができます。

型注釈が有効なケース

一方、複雑なロジックや他の開発者が利用するAPIを定義する場合には、型注釈を明示することで、コードの意図をより明確に示すことができます。特に関数の引数や戻り値に関しては、型注釈を使ってより厳密に型を定義することが推奨されます。

function multiply(a: number, b: number): number {
  return a * b;  // 戻り値がnumber型であることを明示
}

この例では、引数 a と b、および戻り値がいずれも number 型であることが明確に示されています。これにより、他の開発者がこの関数を利用する際の誤解を防ぐことができます。

型推論と型注釈のバランス

型推論と型注釈をどのように併用するかは、プロジェクトやコードの規模によって異なります。基本的には、シンプルな場面では型推論に頼り、複雑な処理や外部に公開するAPIでは型注釈を使用することで、コードの可読性と安全性を高めることができます。

例えば、配列やオブジェクトの型が推論されにくい場合は、型注釈を付けて明示的に型を指定することが効果的です。

let numbers: number[] = [1, 2, 3];  // 配列の型を明示的に指定

このように、型推論と型注釈を適切に使い分けることで、コードを柔軟に保ちながらも型の安全性を確保できます。

高度な型推論との併用

TypeScriptは、関数の返り値やジェネリクスを使った複雑な型推論にも対応しています。しかし、これらの高度なケースでは型注釈を利用して、より精密な型定義を行うことが重要です。特に、コードが大規模になると、推論だけに頼ると型の意図が曖昧になることがあるため、型注釈の活用が求められます。

function identity<T>(arg: T): T {
  return arg;  // ジェネリクスを使った型推論と型注釈の併用
}

この例では、ジェネリクスを使って関数の型を柔軟に定義しつつ、型注釈を併用することで、型推論がより効果的に働くようにしています。

any型と型推論の関係

TypeScriptは強力な型推論機能を提供しますが、一方で any 型を使うことで型チェックを無効にすることも可能です。しかし、any 型の使用は型推論の恩恵を無効化するため、できる限り避けるべきです。ここでは、any 型と型推論の関係について詳しく説明し、any 型の使用を避けるための代替手段を紹介します。

any型とは

any 型は、どんな型でも受け入れられる特別な型であり、TypeScriptの型チェックを完全に無視します。例えば、次のコードでは、value 変数にどのような型の値でも代入することが可能です。

let value: any = "Hello";
value = 42;  // エラーは発生しない

any 型は非常に柔軟で便利ですが、これを多用するとTypeScriptの型安全性が失われ、JavaScriptに戻ったような動作になります。any 型を使うことで、型推論は働かなくなり、エラーが発生するリスクが増加します。

any型を使用する問題点

any 型を多用すると、以下のような問題が発生する可能性があります：

• 型安全性の喪失：型チェックが無効化されるため、予期せぬ型のエラーが実行時に発生するリスクがあります。
• 可読性の低下：any 型を使うと、コードの意図が不明確になり、他の開発者がコードを理解するのが難しくなります。
• 推論機能の無効化：any 型を使用すると、TypeScriptの型推論が働かなくなり、コードの安全性や信頼性が低下します。

let value: any = 10;
console.log(value.toUpperCase());  // 実行時エラー: numberに対してtoUpperCase()を呼び出せない

この例では、any 型の変数に数値が入っているにもかかわらず、文字列メソッドが呼び出され、実行時にエラーが発生します。any 型を使わなければ、このようなエラーはコンパイル時に防ぐことができたでしょう。

unknown型の活用

any 型を使いたい場合、代わりに unknown 型を使用することが推奨されます。unknown 型は、どんな型でも受け入れますが、実際に使用する際には型チェックが必要です。これにより、型安全性を保ちながら柔軟なコードを書くことができます。

let value: unknown = "Hello";

if (typeof value === "string") {
  console.log(value.toUpperCase());  // 型チェックを行ってから使用できる
}

このように、unknown 型を使うことで、実際にその値を操作する前に型を明示的に確認することができ、any 型のような予期しないエラーを防げます。

型推論を有効に活用するための工夫

any 型の使用を避けるためには、TypeScriptの型推論に頼るのが効果的です。特に、変数や関数の型を明示的に指定せず、TypeScriptが自動的に型を推論する場面では、any 型を使用する必要はほとんどありません。

let score = 100;  // TypeScriptは自動でnumber型と推論

このように型推論を活用すれば、コードが自動的に型安全となり、any 型を使わずに柔軟なプログラミングが可能です。

TypeScriptコンパイラオプションによる制限

any 型の使用を防ぐために、TypeScriptのコンパイラオプション noImplicitAny を有効にすることが推奨されます。このオプションを設定すると、型が明示されていない変数や関数の引数が any 型と推論されることを防ぎ、より厳密な型チェックを行います。

{
  "compilerOptions": {
    "noImplicitAny": true
  }
}

このオプションを有効にすると、型が明示されていない箇所で any 型が推論されるのを防ぎ、意図しない any 型の使用を避けることができます。

any 型の使用は便利ですが、その代償として型安全性を失うリスクがあります。unknown 型や型推論をうまく活用し、可能な限り any 型を避けることで、より安全でメンテナブルなコードを実現しましょう。

TypeScriptコンパイラオプションでの型推論設定

TypeScriptのコンパイラには、型推論に関連するさまざまなオプションが用意されており、プロジェクトに応じて型チェックの厳密さを調整できます。これらのオプションを理解し、適切に設定することで、コードの品質と安全性を向上させることができます。ここでは、型推論に関連する重要なコンパイラオプションとその効果について説明します。

noImplicitAny

noImplicitAny は、TypeScriptコンパイラに対して、暗黙的に any 型を使用することを禁止するオプションです。このオプションを有効にすると、型注釈が明示されていない変数や引数が自動的に any 型と推論されるのを防ぎ、コンパイル時にエラーが発生します。

{
  "compilerOptions": {
    "noImplicitAny": true
  }
}

このオプションが有効な場合、例えば次のようなコードはエラーとなります。

function log(message) {
  console.log(message);  // エラー: 'message'の型が明示されていないため、any型になる
}

このように、noImplicitAny を有効にすることで、意図しない any 型の使用を防ぎ、コードの安全性を向上させることができます。

strictNullChecks

strictNullChecks オプションを有効にすると、null や undefined がすべての型に暗黙的に含まれることがなくなり、型推論がより厳密になります。この設定により、null や undefined の扱いに注意を払う必要があり、予期しない null エラーを防ぐことができます。

{
  "compilerOptions": {
    "strictNullChecks": true
  }
}

このオプションが有効な場合、次のようなコードではエラーが発生します。

let name: string = null;  // エラー: string型にはnullを代入できない

strictNullChecks を有効にすることで、型推論がより正確になり、null や undefined による実行時エラーを回避できます。

strictFunctionTypes

strictFunctionTypes オプションは、関数型の互換性に対してより厳密なチェックを行います。これにより、型推論がより堅牢になり、関数間での型の互換性に対する厳密なチェックが適用されます。

{
  "compilerOptions": {
    "strictFunctionTypes": true
  }
}

このオプションが有効な場合、次のような関数の代入はエラーになります。

let func: (a: string) => void;
func = (a: number) => {};  // エラー: 関数の型が互換性がない

strictFunctionTypes を有効にすることで、関数の型互換性が厳密に検証され、型推論が一層強化されます。

strictBindCallApply

strictBindCallApply は、bind、call、および apply メソッドに対する厳密な型チェックを強制するオプションです。これにより、関数の引数や戻り値に対する型推論が強化され、不適切な引数や戻り値が使用されることを防ぎます。

{
  "compilerOptions": {
    "strictBindCallApply": true
  }
}

このオプションが有効な場合、次のような不適切な call メソッドの使用はエラーになります。

function greet(name: string) {
  console.log(`Hello, ${name}!`);
}

greet.call(null, 123);  // エラー: number型の引数をstring型のパラメータに渡すことはできない

これにより、関数の呼び出し時の型チェックが厳密化され、意図しないエラーを防ぐことができます。

noImplicitReturns

noImplicitReturns オプションは、関数内で戻り値が不統一な場合に警告を発生させます。このオプションを有効にすることで、すべてのコードパスで戻り値が一貫していることを保証し、予期しない undefined が戻り値となることを防ぎます。

{
  "compilerOptions": {
    "noImplicitReturns": true
  }
}

例えば、次のような関数では警告が発生します。

function checkAge(age: number): string {
  if (age >= 18) {
    return "Adult";
  }
  // elseブロックがなく、戻り値が不明確
}

noImplicitReturns を有効にすることで、すべてのコードパスで適切な戻り値が保証され、意図しない型推論の不一致を防ぐことができます。

コンパイラオプションのまとめ

これらのTypeScriptコンパイラオプションを活用することで、型推論をより厳密かつ正確にし、コードの安全性や信頼性を高めることができます。特に、noImplicitAny や strictNullChecks のようなオプションは、型推論の弱点を補い、より堅牢な型チェックを提供します。プロジェクトの規模や要件に応じて適切なオプションを選択し、型推論の恩恵を最大限に活用しましょう。

よくある型推論に関する誤解

TypeScriptの型推論は非常に便利で強力ですが、誤解や誤った使い方によって予期しない問題を引き起こすことがあります。ここでは、型推論に関して初心者がよく陥りがちな誤解と、その解決策を紹介します。

誤解1: 型推論に完全に依存しても安全

型推論は多くの場面で非常に役立ちますが、すべてのケースで完全に安全ではありません。特に、複雑なデータ構造や関数の戻り値に関しては、明示的に型を指定することが推奨されます。TypeScriptは単純なケースでは正確に型を推論できますが、より複雑なロジックや動的なデータ構造を扱う際には、推論結果が意図しないものになることがあります。

例えば、次のコードでは意図せずに any 型が推論される場合があります。

function process(data) {
  return data * 2;
}

この場合、data の型が推論されずに any 型とみなされ、実行時エラーの原因になります。これを防ぐために、引数に明示的な型を指定すべきです。

function process(data: number) {
  return data * 2;
}

誤解2: any型を使えば問題はすべて解決する

any 型を使うと、型推論が働かなくなるため、一見エラーが回避できるように見えますが、これに依存するとTypeScriptの型チェックのメリットを失ってしまいます。any 型を使うことで、型安全性が失われ、実行時エラーが発生するリスクが増加します。

let data: any = "Hello";
data = 123;  // どんな型も代入できるため、安全性が低下する

このように、any 型を多用すると、実行時に予期しないエラーが発生する可能性が高くなります。any 型の代わりに、適切な型注釈を使うことで、型の安全性を確保しましょう。

誤解3: 推論された型は常に正しい

TypeScriptの型推論は非常に強力ですが、場合によっては推論された型が正しくないことがあります。特に、複雑なオブジェクトや配列の型推論では、開発者の意図と異なる型が推論されることがあるため、明示的に型を指定したほうが安全です。

let person = { name: "Alice", age: "25" };  // ageはnumber型とするつもりがstring型に推論される

このような場合、型推論に頼りすぎず、適切な型を明示することで、意図した通りの型定義を行うことが重要です。

let person: { name: string; age: number } = { name: "Alice", age: 25 };

誤解4: TypeScriptがすべての型エラーをキャッチしてくれる

TypeScriptの型推論と型チェックは非常に強力ですが、あくまでコンパイル時のチェックです。実行時には、TypeScriptの型システムが適用されないため、動的に生成されるデータや外部APIからのレスポンスに対しては注意が必要です。実行時の型チェックが必要な場合は、typeof や instanceof といったJavaScriptの構造的な型チェックを活用するべきです。

function printName(name: any) {
  if (typeof name === "string") {
    console.log(name.toUpperCase());
  } else {
    console.log("Invalid input");
  }
}

このように、実行時に不確実なデータを扱う場合は、適切に型チェックを行う必要があります。

誤解5: オプションパラメータやデフォルト値は型推論でカバーできる

TypeScriptはオプションパラメータやデフォルト値に対しても型推論を行いますが、明示的な型注釈を付けない場合、予期しない型が推論されることがあります。特に、複雑な関数やクラスでは、明示的な型注釈が必要です。

function greet(name = "Guest") {
  return `Hello, ${name}!`;
}

この場合、name の型は自動的に string と推論されますが、もし null や undefined を受け取る場合は、型注釈でその旨を明示する必要があります。

function greet(name: string | null = "Guest") {
  return `Hello, ${name || "Anonymous"}!`;
}

まとめ

TypeScriptの型推論は便利ですが、過信することなく、必要な場面では明示的に型注釈を使用することが重要です。特に、any 型や推論の誤解を避け、適切な型チェックと型安全性を保ちながら開発を進めることで、エラーの少ない堅牢なコードを書くことができます。

型推論を活用した実践的な演習問題

型推論を理解し、実際のプロジェクトで活用するためには、いくつかの演習問題を通して実践することが効果的です。ここでは、TypeScriptの型推論を用いた簡単な演習問題をいくつか紹介します。各問題を解くことで、型推論の仕組みや、どの場面で明示的に型注釈が必要かを学ぶことができます。

演習1: 型推論と変数の型

次のコードでは、TypeScriptが変数に対してどのように型を推論するかを確認します。型推論を活用してエラーを修正してください。

let count = 10;
count = "ten";  // この行でエラーが発生します。なぜでしょうか？

解答のポイント
TypeScriptは count を number 型として推論しているため、string 型の値を代入することはできません。エラーを修正するには、数値型のデータを使い続けるか、もしくは最初から string 型を許容するように型を指定します。

let count = 10;  // このままnumber型で使い続ける
// または
let count: string | number = 10;  // string型も許容する

演習2: 関数の戻り値の型推論

次の関数では、戻り値の型をTypeScriptが推論しています。戻り値が意図した通りに推論されているか確認してください。

function add(a: number, b: number) {
  return a + b;
}
let result = add(5, 10);  // resultの型は何でしょうか？

解答のポイント
TypeScriptは関数の戻り値を number 型と推論します。理由は、a と b がどちらも number 型であり、それらの合計も number 型であるためです。したがって、result も number 型です。

// resultの型はnumberと推論される
let result: number = add(5, 10);

演習3: オブジェクトの型推論

次のコードでは、TypeScriptがオブジェクトの型を自動で推論しますが、意図しない型が推論されている場合があります。オブジェクトの型を確認し、必要に応じて修正してください。

let user = {
  name: "Alice",
  age: 25,
  isActive: true
};
user.age = "twenty-five";  // エラーが発生します。なぜでしょうか？

解答のポイント
TypeScriptは user オブジェクトの age プロパティを number 型と推論しています。そのため、string 型の値を代入しようとするとエラーが発生します。これを修正するには、age プロパティの型を string 型と number 型の両方を許容するように変更します。

let user: { name: string; age: number | string; isActive: boolean } = {
  name: "Alice",
  age: 25,
  isActive: true
};
user.age = "twenty-five";  // 修正後はエラーが発生しない

演習4: 配列の型推論

次のコードでは、TypeScriptが配列の型を推論していますが、追加する値によってエラーが発生します。エラーを修正してください。

let scores = [80, 90, 70];
scores.push("100");  // エラーが発生します。なぜでしょうか？

解答のポイント
TypeScriptは scores 配列を number[] 型と推論しています。そのため、string 型の "100" を追加しようとするとエラーが発生します。修正するには、配列に追加する値も number 型にするか、配列自体を string 型も受け入れるように型定義します。

// 修正方法1: 追加する値をnumberにする
scores.push(100);

// 修正方法2: 配列がstringも受け入れるようにする
let scores: (number | string)[] = [80, 90, 70];
scores.push("100");

演習5: any型の影響を考える

any 型を使ったコードでは、型推論が無効化されます。次のコードで any 型の影響を考え、any 型を使わない方法で修正してください。

let input: any = "Hello";
input = 123;
console.log(input.toUpperCase());  // 実行時エラーが発生します。なぜでしょうか？

解答のポイント
any 型を使うと、TypeScriptの型チェックが無効化され、意図しないエラーが発生しやすくなります。このコードでは、input が最初は文字列として扱われますが、後で数値が代入されてしまい、文字列メソッド toUpperCase を呼び出すと実行時エラーが発生します。これを防ぐためには、型推論や unknown 型を使って型チェックを強化します。

let input: unknown = "Hello";
if (typeof input === "string") {
  console.log(input.toUpperCase());  // 型チェックを行った上で文字列として処理
}

これらの演習問題を通して、型推論の使い方や、どの場面で明示的に型注釈を付けるべきかを理解することができます。適切な型推論を活用することで、より安全で効率的なコードを書けるようになります。

まとめ

本記事では、TypeScriptの型推論の基本的な概念から、変数や関数、配列、オブジェクトなどに対する推論の仕組みを解説しました。また、型注釈との併用方法や、any 型のリスクについても触れ、実践的な演習問題を通じて理解を深めました。適切な型推論を活用することで、TypeScriptの強力な型システムを最大限に利用し、より安全で効率的なコードを書くことができるようになります。