ジェネリック型を使用して、さまざまな型の入力パラメータを受け取り、それに応じた型の戻り値を返す関数を作成する方法

TypeScript 関数における入力パラメータに基づいた戻り値の型

例

function add(a: number, b: number): number {
  return a + b;
}

const result = add(1, 2); // result は number 型になる

function greet(name: string): string {
  return `Hello, ${name}!`;
}

const message = greet('John Doe'); // message は string 型になる

上記の例では、add 関数は 2 つの number 型のパラメータを受け取り、number 型の値を返します。同様に、greet 関数は 1 つの string 型のパラメータを受け取り、string 型の値を返します。

より複雑な例

function multiply(a: number, b: number): number | string {
  if (a === 0) {
    return 'Zero cannot be multiplied';
  }
  return a * b;
}

const result1 = multiply(2, 3); // result1 は number 型になる
const result2 = multiply(0, 5); // result2 は string 型になる

上記の例では、multiply 関数は 2 つの number 型のパラメータを受け取り、number 型または string 型の値を返します。a が 0 の場合は、string 型の値 "Zero cannot be multiplied" を返し、それ以外の場合は number 型の値 a * b を返します。

ジェネリック型

ジェネリック型を使用して、さまざまな型の入力パラメータを受け取り、それに応じた型の戻り値を返す関数を作成することができます。

function identity<T>(value: T): T {
  return value;
}

const number1 = identity(1); // number1 は number 型になる
const string1 = identity('Hello'); // string1 は string 型になる

上記の例では、identity 関数は 1 つのジェネリック型パラメータ T を受け取り、T 型の値をそのまま返します。

例 1: 単純な関数

function add(a: number, b: number): number {
  return a + b;
}

const result1 = add(1, 2); // result1 は number 型になる
const result2 = add(1.5, 2.5); // result2 は number 型になる

// 誤った型の引数を渡すと、エラーが発生する
// const result3 = add('1', '2'); // エラー: Argument of type 'string' is not assignable to parameter of type 'number'.

例 2: 条件分岐による戻り値の型

function multiply(a: number, b: number): number | string {
  if (a === 0) {
    return 'Zero cannot be multiplied';
  }
  return a * b;
}

const result1 = multiply(2, 3); // result1 は number 型になる
const result2 = multiply(0, 5); // result2 は string 型になる

console.log(result1); // 6
console.log(result2); // Zero cannot be multiplied

例 3: ジェネリック型

function identity<T>(value: T): T {
  return value;
}

const number1 = identity(1); // number1 は number 型になる
const string1 = identity('Hello'); // string1 は string 型になる

console.log(number1); // 1
console.log(string1); // Hello

// ジェネリック型を使用して、複数の型を扱う関数を作成することもできる
function swap<T, U>(a: T, b: U): [U, T] {
  return [b, a];
}

const pair1 = swap(1, 'Hello'); // pair1 は [string, number] 型になる
const first1 = pair1[0]; // first1 は string 型になる
const second1 = pair1[1]; // second1 は number 型になる

console.log(pair1); // ['Hello', 1]
console.log(first1); // Hello
console.log(second1); // 1

例 4: 型エイリアス

type User = {
  name: string;
  age: number;
};

function getUser(id: number): User {
  // ... データベースからユーザー情報を取得する処理 ...

  return {
    name: 'John Doe',
    age: 30,
  };
}

const user1 = getUser(1); // user1 は User 型になる

console.log(user1.name); // John Doe
console.log(user1.age); // 30

as キーワード

as キーワードを使用して、戻り値の型を明示的に指定することができます。

function add(a: number, b: number): number {
  return a + b;
}

const result = add(1, 2) as number; // result は number 型になる

// 誤った型を指定すると、エラーが発生する
// const result2 = add(1, 2) as string; // エラー: Type 'number' is not assignable to type 'string'.

typeof 演算子

typeof 演算子を使用して、別の関数の戻り値の型を参照することができます。

function add(a: number, b: number): number {
  return a + b;
}

function multiply(a: number, b: number): number {
  return a * b;
}

const result = add(1, 2) + multiply(3, 4); // result は number 型になる

// typeof を使用して、add 関数の戻り値の型を number 型と明示的に指定することもできる
const result2 = add(1, 2) as typeof add; // result2 は number 型になる

never 型

never 型は、決して到達しないことを意味します。エラー処理など、特定の条件下でしか呼び出されない関数に使用することができます。

function error(message: string): never {
  throw new Error(message);
}

const result = error('Something went wrong'); // result は never 型になる

// never 型は、関数が決して戻らないことを示すために使用できる
function infiniteLoop(): never {
  while (true) {}
}