TypeScriptで論理和をマスター！手順とサンプルコード10選

はじめに
●TypeScriptの論理和とは
- ○論理和の基本理念
- ○TypeScriptでの論理和の特性
●論理和の使い方
●論理和の応用例
●注意点と対処法
- ○論理和の挙動の特性に関する注意
  - □短絡評価
  - □nullとundefinedの扱い
- ○よくある間違いとその解決策
  - □複数の条件の評価
  - □デフォルト値の誤解
●カスタマイズのポイント
- ○論理和のカスタマイズテクニック
- ○便利なライブラリやツールの紹介
まとめ

はじめに

TypeScriptはJavaScriptに静的型付けの特性を加えた言語であり、近年その人気は急上昇しています。

TypeScriptに慣れる上での一つのステップとして、論理和の活用が挙げられます。

この記事では、TypeScriptでの論理和の使い方やその特性、さらには応用例を踏まえた10つのサンプルコードを提供します。

初心者の方はもちろん、すでにTypeScriptに慣れ親しんでいる方でも、論理和の深い理解とその活用方法をさらに磨くことができる内容となっています。

論理和とは、通常の「or」の条件をコード上で表現するものです。TypeScriptでは、特に型の面での論理和が強力なツールとして使用されます。

本記事を通して、この力強いツールを効果的に活用する手法を学べることを願っています。

●TypeScriptの論理和とは

TypeScriptはJavaScriptのスーパーセットとして認識されている強力なプログラミング言語です。

TypeScriptにはJavaScriptの持つ多くの特性が継承されており、加えて型情報などの追加機能が導入されています。

この記事では、TypeScriptの論理和に焦点を当て、その基本的な概念から実際の使用方法に至るまでを徹底的に探求します。

○論理和の基本理念

論理和とは、複数の条件や式の結果を一つに統合するための論理演算子です。

主に「||」という記号で表現されます。例えば、ある条件Aや条件Bのどちらか一方が真であれば、全体の結果も真となる場合、論理和を用いることができます。

このコードでは、変数aとbの値を使って論理和を表しています。

この例では、aまたはbが真であれば、全体の結果も真となります。

const a = true;
const b = false;
const result = a || b;
console.log(result);

このコードを実行すると、resultの値はtrueとなります。

なぜなら、変数aの値がtrueであるため、a || bの結果もtrueとなるからです。

○TypeScriptでの論理和の特性

JavaScriptと同じく、TypeScriptにおいても論理和は「短絡評価」という特性を持っています。

これは、複数の条件や式を左から順に評価し、最初に真と評価される式の値が全体の結果として返されるというものです。

このコードでは、関数getTrueValueとgetFalseValueを使って論理和の短絡評価を表しています。

この例では、getTrueValueがtrueを返す場合、getFalseValueは評価されず、getTrueValueの結果がそのまま返されます。

function getTrueValue() {
  console.log('getTrueValueが呼ばれました');
  return true;
}

function getFalseValue() {
  console.log('getFalseValueが呼ばれました');
  return false;
}

const result = getTrueValue() || getFalseValue();
console.log(result);

このコードを実行すると、「getTrueValueが呼ばれました」というメッセージが表示され、次にresultの値としてtrueが出力されます。

一方、「getFalseValueが呼ばれました」というメッセージは表示されません。

これは、getTrueValueの結果がtrueであったため、論理和の短絡評価によりgetFalseValueは評価されなかったからです。

●論理和の使い方

TypeScriptでは、論理和を使うことで条件を組み合わせることができます。

具体的には、２つ以上の条件を「または」の関係として組み合わせる場合に使用します。

JavaScriptと同様に、TypeScriptでの論理和は || という演算子で表現されます。

例えば、ある数が10以上または50未満の場合という条件を設定したい場合、次のように記述します。

let num = 15;
if (num >= 10 || num < 50) {
    console.log("数は10以上または50未満です。");
}

このコードでは、変数numに格納されている数が10以上または50未満の場合に、”数は10以上または50未満です。”というメッセージがコンソールに表示されます。

この例では、変数numに15が格納されているため、この条件は真となります。

○サンプルコード1：基本的な論理和の使用

さらに、論理和を使用して、次のサンプルコードを考えてみましょう。

function checkAgeOrStatus(age: number, student: boolean): string {
    if (age >= 20 || student) {
        return "割引が適用されます。";
    } else {
        return "割引の適用はありません。";
    }
}

// 割引が適用される例
console.log(checkAgeOrStatus(22, false));

// 学生の場合も割引が適用される例
console.log(checkAgeOrStatus(18, true));

// どちらの条件も満たしていない場合
console.log(checkAgeOrStatus(18, false));

このコードでは、年齢が20歳以上または学生の場合に割引が適用されるというロジックを実装しています。

関数checkAgeOrStatusは2つの引数、ageとstudentを受け取り、割引が適用されるかどうかを文字列として返します。

最初の例では、22歳で学生ではない場合、”割引が適用されます。”と表示されます。

次に、18歳でも学生であるため、”割引が適用されます。”と表示されます。

最後の例では、18歳で学生ではない場合、”割引の適用はありません。”と表示されます。

○サンプルコード2：複数の条件を組み合わせる

論理和は、プログラミングにおいて非常に便利なツールとして知られています。特に、複数の条件を組み合わせる場合にはその真価を発揮します。

ここでは、複数の条件を組み合わせる場面でのTypeScriptでの論理和の使用方法を詳しく解説します。

まずは、次のサンプルコードをご覧ください。

// TypeScriptの論理和を使用して複数の条件を組み合わせる例
const isWeekend = (day: string): boolean => {
  return day === "土曜日" || day === "日曜日";
};

const result = isWeekend("日曜日");

このコードでは、関数isWeekendを使って、指定された曜日が週末（土曜日または日曜日）であるかどうかを判定しています。

この例では、"日曜日"を関数に渡して、その結果をresultに格納しています。

具体的には、day === "土曜日" || day === "日曜日"という部分で論理和を使用しています。

ここでの||が論理和を表す演算子であり、左側の条件または右側の条件のいずれかがtrueであれば全体がtrueとなります。

このサンプルコードの場合、resultはtrueとなります。

というのも、関数に渡された"日曜日"は論理和の条件のどちらかを満たすためです。

複数の条件を組み合わせる際、論理和を駆使することでコードをシンプルに保ちながら、柔軟な条件判定を行うことができます。

このように、TypeScriptの論理和は、条件判定を行う際の強力な味方となります。

○サンプルコード3：論理和を関数の中で使用する

TypeScriptを使っている際、特に関数の中で論理和を用いると非常に便利です。

実際に関数の中での使用例を解説しながら、どのように論理和が役立つのかをご紹介します。

このコードでは、関数getUserDisplayNameを定義しています。

この関数は、ユーザーオブジェクトが与えられた時、そのユーザーの名前情報を返します。

もしユーザーが名前情報を持っていない場合、デフォルトの名前を返すようにしています。

type User = {
    id: number;
    name?: string;
};

function getUserDisplayName(user: User): string {
    return user.name || "名前なし";
}

const user1: User = { id: 1, name: "田中" };
const user2: User = { id: 2 };

console.log(getUserDisplayName(user1));  // 田中
console.log(getUserDisplayName(user2));  // 名前なし

この例では、user.name || "名前なし"を使って、ユーザーが名前情報を持っていればその名前を、持っていなければ”名前なし”という文字列を返すようにしています。

このコードを実行すると、user1は名前情報があるので”田中”と表示され、user2は名前情報がないので”名前なし”と表示されます。

また、関数のデフォルトの返り値をカスタマイズしたい場合、論理和を利用することで、より柔軟に関数をカスタマイズすることができます。

下記のコードは、ユーザーの年齢を元に成人か未成年かを判断する関数checkAgeCategoryの例です。

type Person = {
    id: number;
    age?: number;
};

function checkAgeCategory(person: Person): string {
    return person.age >= 20 ? "成人" : "未成年" || "年齢不明";
}

const person1: Person = { id: 1, age: 25 };
const person2: Person = { id: 2, age: 18 };
const person3: Person = { id: 3 };

console.log(checkAgeCategory(person1));  // 成人
console.log(checkAgeCategory(person2));  // 未成年
console.log(checkAgeCategory(person3));  // 年齢不明

この例では、三項演算子と論理和を組み合わせています。

person.age >= 20 ? "成人" : "未成年"で年齢を元に成人か未成年かを判断し、その後に|| "年齢不明"を使って年齢情報がない場合は”年齢不明”という文字列を返すようにしています。

このコードを実行すると、person1は年齢が20歳以上なので”成人”、person2は20歳未満なので”未成年”、そしてperson3は年齢情報がないので”年齢不明”と表示されます。

○サンプルコード4：オブジェクトのプロパティとして論理和を利用

TypeScriptでは、オブジェクトのプロパティの初期化時や参照時に、論理和を活用して動的に値を決定することができます。

論理和のシンボルとして使用される || は、左側の式がundefined, null, falseなどのfalsyな値である場合に、右側の式を評価・返すという特性を持っています。

これを利用して、プロパティのデフォルト値を設定する際に大変便利です。

このコードでは、オブジェクトのプロパティとして論理和を使い、指定されていないプロパティにデフォルトの値を設定しています。

この例では、nameやageといったプロパティに値が存在しない場合、予め定義したデフォルトの値を割り当てる方法を表しています。

interface Person {
    name?: string;
    age?: number;
}

function createPerson(data: Person) {
    const person = {
        name: data.name || '名無し',
        age: data.age || 20
    };
    return person;
}

const person1 = createPerson({});
const person2 = createPerson({ name: '太郎' });
const person3 = createPerson({ age: 25 });

console.log(person1);  // { name: '名無し', age: 20 }
console.log(person2);  // { name: '太郎', age: 20 }
console.log(person3);  // { name: '名無し', age: 25 }

このサンプルコードでは、Personインターフェースを使ってnameとageのプロパティをオプションにしています。

そして、createPerson関数では、渡されたデータにnameやageが存在しない場合、それぞれ'名無し'や20というデフォルト値を設定しています。

このコードを実行すると、createPerson関数に空のオブジェクトを渡した場合や、特定のプロパティのみを渡した場合でも、論理和を利用してデフォルト値を適用することができることが分かります。

具体的には、person1オブジェクトはデフォルト値を持つ{ name: '名無し', age: 20 }となり、person2オブジェクトは{ name: '太郎', age: 20 }、person3オブジェクトは{ name: '名無し', age: 25 }となります。

●論理和の応用例

論理和は非常に実用的なツールであり、TypeScriptのプログラムにおいて多くのシチュエーションで利用されます。

基本的な使い方を把握したら、次に進むべきステップはその応用例を理解することです。

応用例を理解することで、あなたのコーディングスキルは一段と向上するでしょう。

○サンプルコード5：論理和を使ったデータのフィルタリング

多くの場面で、データのフィルタリングは非常に重要な役割を果たします。

例えば、特定の条件に基づいてリストからアイテムを選択したり、不要なデータを取り除くための条件を設定する必要があります。

論理和はこのようなタスクを効率的に実行するための強力なツールとして使用できます。

論理和を用いて、指定された条件に基づいて配列の中のオブジェクトをフィルタリングするサンプルコードを紹介します。

type User = {
    id: number;
    name: string;
    age: number;
    isPremium: boolean;
};

const users: User[] = [
    { id: 1, name: '田中', age: 25, isPremium: true },
    { id: 2, name: '佐藤', age: 30, isPremium: false },
    { id: 3, name: '鈴木', age: 22, isPremium: true },
];

const premiumUsersOrOlderThan27 = users.filter(user => user.isPremium || user.age > 27);

このコードでは、Userという型を定義しており、それに基づいてusersという配列を作成しています。

そして、filterメソッドを使用して、プレミアムユーザーまたは27歳以上のユーザーだけを選択しています。

この例では、filterメソッドのコールバック関数内で論理和を使用しています。

このように論理和を活用することで、簡潔かつ効果的に条件を組み合わせることができます。

このコードを実行すると、結果として次のような配列が得られます。

[{ id: 1, name: '田中', age: 25, isPremium: true }, { id: 2, name: '佐藤', age: 30, isPremium: false }]

上記の結果から、田中さんはプレミアムユーザーであるため、佐藤さんは27歳以上であるため、この2人のユーザー情報だけが選択されていることが確認できます。

このように、論理和を使用することで、複数の条件を組み合わせたデータのフィルタリングが簡単に実行できます。

○サンプルコード6：エラーハンドリングに論理和を使用

TypeScriptにおいて、エラーハンドリングは非常に重要なプロセスです。

特にアプリケーションの安定性やユーザーエクスペリエンスの向上のためには、適切なエラーハンドリングが必須です。

ここでは、論理和(||)を使ってエラーハンドリングを行う方法について詳しく見ていきましょう。

まず、論理和の基本的な動作を理解するための簡単なコードから始めます。

let value = undefined || "デフォルト値";
console.log(value);

このコードでは、undefinedやnullなどの”falsy”な値を持つ変数が||の前に来たとき、その後の値（この場合は"デフォルト値"）が代入されるという特性を利用しています。

この例では、value変数には"デフォルト値"が代入されます。

しかし、この特性をエラーハンドリングの際にどのように応用できるのでしょうか。

関数からの戻り値がnullやundefinedの場合にデフォルトのメッセージを返すような実装の一例を紹介します。

function fetchErrorMessage(errorCode?: string): string {
    const errorMessage = errorCode || "不明なエラーが発生しました。";
    return errorMessage;
}

const resultMessage = fetchErrorMessage();
console.log(resultMessage);

この例では、関数fetchErrorMessageがエラーコードを引数として受け取り、そのエラーコードに対応するエラーメッセージを返すことを想定しています。

ただし、エラーコードが未定義の場合やfalsyな値の場合には、"不明なエラーが発生しました。"というデフォルトのエラーメッセージを返します。

こちらのコードを実行すると、resultMessageにはデフォルトのエラーメッセージが代入され、コンソールに"不明なエラーが発生しました。"と表示されます。

このように、TypeScriptの論理和を利用することで、エラーハンドリングの際のデフォルト値の指定や、変数の代入の際のfalsyな値のハンドリングなど、様々な場面で便利に利用することができます。

○サンプルコード7：非同期処理との組み合わせ

非同期処理は、JavaScriptやTypeScriptでのプログラムの実行をブロックしない処理を意味します。

例えば、APIからデータをフェッチする、データベースから情報を取得するなどの操作が非同期処理の一例です。非同期処理は、通常、Promiseやasync/await構文を使用して実装されます。

しかし、非同期処理と論理和を組み合わせることで、非同期処理の結果に基づいて特定のアクションを実行したり、エラーハンドリングを効果的に行うことができます。

下記のサンプルコードでは、APIからデータをフェッチし、それを基に判定を行うシンプルな例を表しています。

// APIからデータをフェッチする非同期関数
async function fetchData(): Promise<string | null> {
    try {
        const response = await fetch('https://api.example.com/data');
        if (!response.ok) {
            throw new Error('Network response was not ok');
        }
        const data = await response.json();
        return data.message;
    } catch (error) {
        console.error('Fetch error: ', error);
        return null;
    }
}

// データを取得して特定のアクションを実行する関数
async function executeAction() {
    const message = await fetchData();
    const defaultMessage = "デフォルトのメッセージです";

    // フェッチしたメッセージが存在する場合、それを表示。存在しない場合はデフォルトのメッセージを表示
    console.log(message || defaultMessage);
}

executeAction();

このコードでは、まずfetchData関数を使ってAPIからデータをフェッチしています。

フェッチが成功した場合、データの中のmessageを返します。

しかし、何らかのエラーが発生した場合や、フェッチが失敗した場合にはnullを返します。

次に、executeAction関数では、fetchData関数で取得したメッセージをmessageとして取得します。

その後、論理和の特性を利用して、messageが存在する場合はそれを、存在しない場合はデフォルトのメッセージを表示します。

この例を実行すると、APIからのデータの取得が成功してmessageが存在する場合、そのmessageがコンソールに表示されます。

一方、データの取得が失敗したり、何らかのエラーが発生した場合には、デフォルトのメッセージがコンソールに表示されます。

このように、非同期処理と論理和を組み合わせることで、非同期で取得したデータの存在チェックやエラーハンドリングをシンプルに、かつ効果的に行うことができます。

○サンプルコード8：型ガードと論理和

TypeScriptは静的型付け言語の一つで、JavaScriptの上に型情報を追加することで、より堅牢なコードを書く手助けをしてくれます。

ここでは、TypeScriptでの「型ガード」と「論理和」の組み合わせについて解説します。

型ガードとは、ある変数が特定の型であることをランタイム時に確認する機能のことを指します。

まず、型ガードとは何か、簡単なサンプルコードで確認しましょう。

function isString(value: any): value is string {
    return typeof value === "string";
}

このコードでは、isStringという関数を定義しています。

引数valueの型はanyで、戻り値の型はvalue is stringとなっています。

このvalue is stringという型は、valueがstring型であることを示す型ガードのための特殊な型です。

では、この型ガードを利用して、論理和を使ったサンプルコードを見てみましょう。

type Animal = { name: string; type: "dog" | "cat"; };

function isDog(animal: Animal | string): animal is Animal {
    return (animal as Animal).type === "dog";
}

const pet: Animal | string = { name: "Tom", type: "cat" };

if (isDog(pet)) {
    console.log(pet.name + "は犬です。");
} else if (isString(pet)) {
    console.log(pet + "は文字列です。");
} else {
    console.log(pet.name + "は猫です。");
}

この例では、Animalという型を定義しており、犬か猫かを示すtypeプロパティを持っています。

また、isDogという型ガード関数を定義し、これを使用してpet変数がAnimal型で、かつtypeプロパティが”dog”であるかどうかを確認しています。

最後に、if文を使って、petが犬、猫、または文字列のいずれであるかを判別し、結果をコンソールに表示しています。

このサンプルコードを実行すると、コンソールには「Tomは猫です。」と表示されます。

なぜなら、pet変数のtypeプロパティは”cat”であるからです。

○サンプルコード9：配列の中の要素を確認する

論理和を使って、配列内の特定の要素の存在を確認する場面は、日常的なTypeScriptプログラミングで頻繁に出てきます。

特に、データのフィルタリングやバリデーション処理などで役立つこの技法を学んでみましょう。

このコードでは、includesメソッドとsomeメソッドを組み合わせて、配列内に特定の要素が存在するかどうかを確認しています。

この例では、配列fruitsに”apple”が存在するか、そして配列numbersに偶数が存在するかを論理和を使用して確認しています。

// 複数のフルーツを持つ配列
const fruits = ["apple", "banana", "cherry"];

// "apple"がfruitsに存在するか確認
const hasApple = fruits.includes("apple");

// 複数の数字を持つ配列
const numbers = [1, 3, 5, 7, 9];

// numbersに偶数が存在するか確認
const hasEvenNumber = numbers.some(num => num % 2 === 0);

console.log(`fruits配列にappleは存在するか？: ${hasApple}`);
console.log(`numbers配列に偶数は存在するか？: ${hasEvenNumber}`);

このサンプルコードを解析すると、fruits.includes("apple")は配列fruitsに”apple”という文字列が存在するかどうかを確認しています。

結果として、hasAppleはtrueとなります。

次に、numbers.some(num => num % 2 === 0)の部分では、配列numbersに偶数が1つでも存在するかを確認しています。

こちらの結果は、配列に偶数が存在しないため、hasEvenNumberはfalseとなります。

このような場面でのコードの実行結果は次となります。

fruits配列にappleは存在するか？という問いに対する答えはtrueです。

逆に、numbers配列に偶数は存在するか？という問いに対する答えはfalseとなります。

○サンプルコード10：関数の戻り値として論理和を利用

TypeScriptで関数を作成する際、戻り値として論理和を利用することで、複数の異なる型を返すことが可能になります。

具体的には、関数の戻り値の型として「型A | 型B」のような形式で指定することで、関数は「型A」または「型B」のどちらかの型の値を返すことができるようになります。

この特性は、特定の条件下で異なる型の値を返す必要がある際に非常に便利です。

では、実際にこの概念を取り入れたサンプルコードを見てみましょう。

function checkEvenOrOdd(num: number): string | number {
    if (num % 2 === 0) {
        return "even";
    }
    return num;
}

// 使用例
const result1 = checkEvenOrOdd(4);
const result2 = checkEvenOrOdd(3);

このコードの「checkEvenOrOdd」という関数は、数値を引数として受け取り、その数値が偶数の場合は文字列 “even” を、奇数の場合はその数値自体を返すという動きをします。

戻り値の型として string | number を指定することで、関数内での返す値の型の柔軟性を持たせることができています。

このコードを実行すると、result1 には “even” が、result2 には 3 という数値が代入されることになります。

つまり、関数が異なる型の値を適切に返すことが確認できます。

このように、TypeScriptの関数の戻り値として論理和を利用することで、より柔軟な関数の作成が可能となり、異なる状況や条件下での処理の振り分けを簡潔に表現することができます。

●注意点と対処法

TypeScriptでのコーディングにおいて論理和は数多くの利便性を提供しますが、その柔軟性の裏には、注意を払うべきいくつかの挙動の特性が存在します。

これらの特性を理解し、適切に活用しなければ、時にはコードのバグや予期せぬ結果を生む原因となることもあるのです。

ここでは、論理和を使用する際によくある誤解や落とし穴について議論し、それらがもたらす可能性のある問題を避けるための対処法を探っていきます。

○論理和の挙動の特性に関する注意

TypeScriptの論理和は、多くの初心者にとって一見シンプルに見えますが、実際には細かな特性があります。

これを理解せずにコードを書くと、思わぬバグの原因となります。

□短絡評価

TypeScriptの論理和（||）は、左のオペランドがtruthyである場合、右のオペランドを評価せずに左のオペランドを返します。

これは「短絡評価」と呼ばれます。

このコードではaがtruthyな場合、bは評価されずにaの値が返されます。

この例ではaがtrueであるため、bは評価されず、結果としてtrueが返されます。

let a = true; let b = false; console.log(a || b); // true

□nullとundefinedの扱い

論理和を使用する際、nullやundefinedの値が意図しない挙動を引き起こすことがあります。

特に初心者は、これらの値がfalsyであることを忘れがちです。

このコードではnameがnullの場合、"Unknown"が代わりに使用される例です。

この例ではnameがnullなので、"Unknown"が返されます。

let name: string | null = null; console.log(name || "Unknown"); // "Unknown"

○よくある間違いとその解決策

実際のコーディング作業中には、TypeScriptの論理和を使った条件の評価で混乱しやすい状況にしばしば遭遇します。

複数の条件を組み合わせる際に、適切な評価となるよう、特に注意が必要です。

ここでは、そのような複雑な条件の評価時によく発生するミスとその解決策について説明します。

これらの頻出する問題を解決するための具体的な方法を学ぶことで、より堅牢なロジックとバグを防止するコードを記述するための技術的な洞察を深めることができます。

□複数の条件の評価

論理和を使って複数の条件を評価する際、括弧を適切に使用しないと意図しない結果を得る可能性があります。

このコードではaとcの間の論理和が先に評価され、その結果とbの論理積が評価されます。

この例ではtrueが返されます。

let a = true;
let b = false;
let c = true;
console.log(a || b && c); // true

意図した結果を得るためには、括弧を使用して条件をグループ化します。

console.log(a || (b && c)); // true

□デフォルト値の誤解

論理和を使用してデフォルト値を設定する際、falsyな値が意図しないデフォルト値に置き換えられることがあります。

このコードではvalueが0の場合、defaultValueが代わりに使用されます。

この例ではvalueが0なので、意図しない10が返されます。

let value = 0;
console.log(value || 10); // 10

正確にデフォルト値を扱いたい場合は、次のように条件式を使用します。

console.log(value !== null && value !== undefined ? value : 10); // 0

これらの注意点を理解して、TypeScriptの論理和を正確に活用することが、効果的なコードを書くための鍵となります。

●カスタマイズのポイント

論理和の使用は、そのままの形で非常に役立つものですが、より柔軟に利用するためのカスタマイズが可能です。

ここでは、そのカスタマイズの方法やポイント、そしてTypeScriptをより効果的に使用するための外部ツールやライブラリを紹介します。

○論理和のカスタマイズテクニック

論理和は、多岐にわたる条件を処理する際に非常に有用です。

しかし、その機能性を更に拡張し、カスタマイズすることで、より多様なシチュエーションでの対応が可能となります。

例として、論理和を用いて変数が特定の型の場合のみ処理を実行するカスタマイズ方法を紹介します。

// 複数の型を論理和で組み合わせた型を定義
type CustomType = string | number | boolean;

function processData(input: CustomType) {
    if (typeof input === 'string') {
        console.log(`文字列: ${input}`);
    } else if (typeof input === 'number') {
        console.log(`数値: ${input}`);
    } else if (typeof input === 'boolean') {
        console.log(`真偽値: ${input}`);
    }
}

// 使用例
processData("こんにちは"); // 文字列: こんにちは
processData(123); // 数値: 123
processData(true); // 真偽値: true

このコードでは、CustomTypeという新しい型を定義しています。

この型は、string、number、booleanのいずれかの型を取ることができます。

そして、processData関数では、inputの型に応じて異なる処理を行っています。

この例を実際に実行すると、processData関数に文字列を渡すと「文字列: こんにちは」と表示され、数値を渡すと「数値: 123」と表示され、真偽値を渡すと「真偽値: true」と表示されます。