TypeScriptにおける型安全なプログラミングは、特に大規模なプロジェクトや長期的なメンテナンスを考慮した際に非常に重要です。型安全性を確保することで、コードの予測可能性が向上し、実行時エラーのリスクが大幅に低減します。TypeScriptでは、keyofやtypeofといったキーワードを活用することで、型システムを強化し、キーと値のペアを型安全に操作することが可能です。本記事では、これらのTypeScriptの機能を組み合わせ、開発において柔軟かつ堅牢なコードを書くための手法を解説します。
`keyof`とは何か：キーを型として扱う方法
keyofは、オブジェクトのプロパティ名（キー）を型として取得できるTypeScriptのユーティリティ型です。これにより、あるオブジェクトの全てのプロパティのキーを集約し、型として扱うことが可能になります。
使用例
例えば、次のようなオブジェクトがあるとします。
type Person = {
name: string;
age: number;
};この場合、keyof Personを使用すると、"name" | "age"というリテラル型が取得されます。このリテラル型を活用することで、オブジェクトのプロパティ名に基づいた型安全な操作が可能になります。
メリット
keyofを使用することで、オブジェクトのプロパティにアクセスする際のミスを防ぎ、予測可能なコードを実現することができます。例えば、誤ったプロパティ名を指定してもコンパイル時にエラーが出るため、実行時のバグを未然に防ぐことができます。
`typeof`の使い方：オブジェクトの型を取得する
typeofは、JavaScriptにおける値のデータ型を取得する演算子ですが、TypeScriptでは型の宣言や操作に使う強力な機能も持っています。特に、オブジェクトや変数の型をそのまま再利用する際に便利です。
使用例
例えば、以下のコードでは、personというオブジェクトからその型を取得して利用しています。
const person = {
name: "John",
age: 30,
};
type PersonType = typeof person;このPersonTypeは、{ name: string; age: number; }という型になります。これにより、personオブジェクトの構造をそのまま型として再利用でき、型の定義を繰り返し書く手間を省くことができます。
メリット
typeofを使用することで、オブジェクトや変数の型を動的に取得し、コードの保守性を向上させることができます。特に、同じ構造を持つ複数のオブジェクトや変数を扱う場合、型を一度定義して再利用できるため、コードの冗長性が減り、変更があった際にも型定義を一箇所だけ修正すれば良いという利点があります。
`keyof`と`typeof`を組み合わせた型安全な操作のメリット
TypeScriptでkeyofとtypeofを組み合わせることで、オブジェクトのプロパティ名とその型情報を動的かつ型安全に扱うことができます。これにより、誤ったキーや型に依存したコードのエラーを防ぎ、予測可能で堅牢なコードを作成できます。
使用例
次のコードでは、keyofとtypeofを組み合わせて、型安全にオブジェクトのプロパティにアクセスしています。
const person = {
name: "Alice",
age: 25,
};
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const name = getProperty(person, "name"); // 正しい型：string
const age = getProperty(person, "age"); // 正しい型：numberこの例では、getProperty関数は、オブジェクトpersonのプロパティを安全に取得します。keyofを使うことで、personオブジェクトのキーが必ず型チェックされるため、存在しないプロパティを指定するとコンパイルエラーが発生します。
メリット
- 型安全性の向上：キーと値が一致する型を動的に取得するため、コードの信頼性が向上します。
- コードの保守性の向上：オブジェクトの構造が変更された場合も、型が自動的に追従するため、手動で型を変更する手間が減ります。
- エラーの防止：存在しないプロパティへのアクセスや不正な型へのアクセスをコンパイル時に防げるため、実行時エラーを未然に防止できます。
これにより、開発者は型に基づいた安全なコードをより簡潔に記述でき、誤りを防ぎつつ柔軟に操作することが可能になります。
`keyof`と`typeof`を使った実際のコード例
keyofとtypeofを組み合わせることで、TypeScriptでは型安全なコードを柔軟に書けるようになります。ここでは、実際のコード例を通じて、どのようにこれらを活用して型安全な操作が行えるかを解説します。
オブジェクトのプロパティへの型安全なアクセス
次のコードでは、keyofとtypeofを使って、オブジェクトのプロパティに安全にアクセスする方法を示します。
const car = {
make: "Toyota",
model: "Corolla",
year: 2020,
};
function getCarProperty<T, K extends keyof T>(carObj: T, key: K): T[K] {
return carObj[key];
}
const carMake = getCarProperty(car, "make"); // 正しい型: string
const carModel = getCarProperty(car, "model"); // 正しい型: string
const carYear = getCarProperty(car, "year"); // 正しい型: numberこのgetCarProperty関数では、オブジェクトcarのプロパティに対して型安全なアクセスが行われています。keyofを使って、carのキーが型に基づいてチェックされるため、不正なプロパティ名を指定するとコンパイル時にエラーが発生します。
型エラーの防止
間違ったプロパティ名を指定した場合、コンパイル時にエラーが発生します。
const invalidProperty = getCarProperty(car, "price"); // コンパイルエラー: プロパティ 'price' は存在しませんこのように、keyofを使うことで存在しないプロパティへのアクセスが防止されます。
動的なオブジェクト型の操作
typeofを使って動的に型を取得し、さらにkeyofでそのプロパティ名を型として利用する例を示します。
const user = {
id: 1,
name: "John",
email: "john@example.com",
};
type User = typeof user;
type UserKeys = keyof User; // "id" | "name" | "email"
function logUserProperty(key: UserKeys) {
console.log(`User property: ${key}`);
}
logUserProperty("name"); // 正常
logUserProperty("email"); // 正常
// logUserProperty("password"); // コンパイルエラー: 'password' は 'UserKeys' に含まれませんこのように、typeofとkeyofを使うことで、既存のオブジェクトから動的に型を取得し、それをもとに型安全な操作を行うことが可能です。
まとめ
これらの実例により、keyofとtypeofを使ってオブジェクトのプロパティに対する型安全な操作を行う方法が明確になりました。型エラーを防ぎつつ、予測可能なコードを書くための重要な手法です。
TypeScriptの型安全性を強化する実践的な方法
TypeScriptでは、keyofやtypeofの他にも、型安全性を強化するための様々な機能が用意されています。これらの機能を組み合わせて使うことで、さらに強固で保守性の高いコードを実現することが可能です。ここでは、型安全性を向上させるための具体的な実践的な方法を解説します。
ユニオン型を活用した型安全な関数
ユニオン型を使用することで、特定の値セットに基づく型安全な操作が可能です。次の例では、keyofを活用してオブジェクトのプロパティ名を特定のユニオン型として定義し、許可されるキーだけを受け付ける関数を作成しています。
type Car = {
make: string;
model: string;
year: number;
};
function getCarDetail<K extends keyof Car>(car: Car, key: K): Car[K] {
return car[key];
}
const car: Car = {
make: "Toyota",
model: "Corolla",
year: 2020,
};
const model = getCarDetail(car, "model"); // 正しい型: string
const year = getCarDetail(car, "year"); // 正しい型: numberこのコードでは、ユニオン型を使ってCarのキーを定義し、プロパティ名がmakeやmodel、yearのいずれかであることを保証しています。これにより、誤ったキー名が指定されることを防ぎ、型安全性が保たれます。
インデックス型による柔軟な型定義
インデックス型を使うことで、プロパティが多数ある場合や、動的にキーが追加されるようなオブジェクトに対して型安全性を保ちながら柔軟な型定義が可能です。
type Product = {
[key: string]: string | number;
};
const product: Product = {
name: "Laptop",
price: 1500,
brand: "BrandX",
};
function getProductDetail(key: keyof Product): string | number {
return product[key];
}
const price = getProductDetail("price"); // 正しい型: numberこの例では、Productというインデックス型を定義し、プロパティの数や名称に制限を設けず、型安全に操作できるようにしています。
Genericsを使った柔軟な型安全操作
ジェネリクス（Generics）は、汎用的な型定義が可能で、さまざまなデータ型に対して型安全な操作を実現できます。これにより、どんな型でも対応できる関数やクラスを作成でき、コードの再利用性を高めることができます。
function identity<T>(arg: T): T {
return arg;
}
const result1 = identity(42); // number型
const result2 = identity("Hello"); // string型このidentity関数は、ジェネリクスを使うことで、引数として渡された値の型に応じて結果の型が自動的に決まるため、型安全な操作が保証されます。
Mapped Typesを使った型の変換
マップ型（Mapped Types）を利用することで、既存の型を基にして新しい型を定義し、型変換を行うことが可能です。これは、オブジェクトの型を一括で操作したい場合に非常に便利です。
type ReadonlyCar = {
readonly [K in keyof Car]: Car[K];
};
const car: ReadonlyCar = {
make: "Toyota",
model: "Corolla",
year: 2020,
};
// car.make = "Honda"; // エラー: プロパティは読み取り専用この例では、Car型のすべてのプロパティを読み取り専用（readonly）に変換しています。これにより、元のオブジェクトを改変できない安全な型を作成できます。
まとめ
keyofやtypeofに加え、ユニオン型、インデックス型、ジェネリクス、マップ型などを活用することで、TypeScriptにおける型安全性を強化し、柔軟かつ保守性の高いコードを実現できます。これらの実践的な手法を駆使することで、予期せぬエラーを未然に防ぎ、効率的な開発を進めることができます。
型エラーを防ぐためのコーディングパターン
TypeScriptでは、型エラーを防ぐために様々なコーディングパターンを取り入れることが推奨されます。これらのパターンを活用することで、実行時エラーを未然に防ぎ、予測可能で安全なコードを維持することができます。以下では、いくつかの主要なパターンを紹介します。
1. 明示的な型注釈を使用する
型推論はTypeScriptの強力な機能の一つですが、状況によっては明示的に型を注釈することで型エラーを避けることができます。特に、関数の引数や返り値に対して明示的な型注釈を行うと、意図しない型変換やミスを防ぐことができます。
function add(a: number, b: number): number {
return a + b;
}
const result = add(5, 10); // 正しい型: number明示的に型を指定することで、意図しないデータ型の使用を防ぎ、コードの安全性が向上します。
2. 型ガードで型を安全に確認する
型ガードを使うと、動的に型をチェックし、安全に操作することができます。例えば、typeofやinstanceofを使った型ガードを利用すると、コードが特定の型を持つかどうかを判定できます。
function printId(id: number | string) {
if (typeof id === "string") {
console.log(`ID: ${id.toUpperCase()}`);
} else {
console.log(`ID: ${id}`);
}
}この例では、idが文字列か数値かを動的にチェックし、それに応じて安全に操作しています。
3. 非nullアサーション演算子（`!`）の使用
TypeScriptでは、nullやundefinedの値に対して安全にアクセスするための機能が充実していますが、どうしても値がnullでないことが確実な場合、非nullアサーション演算子を使用して型エラーを回避できます。
let button = document.querySelector("button");
button!.addEventListener("click", () => console.log("Button clicked!"));この例では、buttonがnullでないことを確実にした上で操作していますが、基本的には非nullアサーションを乱用しないよう注意が必要です。
4. オプショナルチェーン（`?.`）で安全にプロパティにアクセスする
オブジェクトのプロパティにアクセスする際に、存在しないプロパティにアクセスしてエラーになるリスクを防ぐため、オプショナルチェーンを利用すると便利です。これにより、undefinedやnullを安全に処理できます。
const user = {
name: "Alice",
address: {
street: "123 Main St",
},
};
console.log(user.address?.street); // 正常にアクセスできる場合
console.log(user.address?.city); // undefined (エラーにはならない)このパターンにより、存在しないプロパティにアクセスしてもundefinedが返るため、エラーが発生しません。
5. 型の絞り込み（Discriminated Unions）
TypeScriptでは、ユニオン型を使用しながら、各ケースごとに型を絞り込むことができます。これを利用して、ある型が特定の条件に一致する場合にのみ処理を行うことが可能です。
type Vehicle = { type: "car"; speed: number } | { type: "bike"; gear: number };
function getVehicleInfo(vehicle: Vehicle) {
if (vehicle.type === "car") {
console.log(`Car speed: ${vehicle.speed}`);
} else {
console.log(`Bike gear: ${vehicle.gear}`);
}
}この例では、vehicle.typeが"car"か"bike"であることを判別し、それぞれに対応するプロパティにアクセスしています。
まとめ
型エラーを防ぐためのコーディングパターンを実践することで、予期せぬ実行時エラーを避け、信頼性の高いコードを作成することができます。明示的な型注釈、型ガード、非nullアサーション、オプショナルチェーン、型の絞り込みといったパターンは、日常の開発において役立つ強力なツールです。これらの手法を適切に組み合わせることで、型安全性が向上し、保守しやすいコードベースを維持できます。
よくある間違いとその対処法
TypeScriptを使い始めると、開発者は特定のパターンや機能の誤用によって型エラーや意図しない挙動に直面することがあります。ここでは、keyofやtypeofを使用する際によくある間違いとその対処法について解説します。
1. `keyof`で無効なプロパティ名を指定する
keyofを使って型安全にオブジェクトのプロパティにアクセスする場合、間違ったプロパティ名を指定するとコンパイルエラーが発生します。しかし、型の定義が不完全な場合や、定義された型に基づかない値を使用すると、エラーに気付きにくくなります。
type Person = {
name: string;
age: number;
};
const person: Person = {
name: "John",
age: 30,
};
function getPersonProperty(key: keyof Person) {
// 正しいキーを指定しないとエラーが発生
return person[key];
}
getPersonProperty("email"); // コンパイルエラー: 'email'は'keyof Person'ではありません対処法：このエラーは、keyofを使って型安全にプロパティにアクセスする際の利点でもあります。無効なキーを使用しないように、常に型に基づいたプロパティを指定することが重要です。
2. `typeof`と値の型を混同する
typeofはJavaScriptでも使われる演算子ですが、TypeScriptでは型定義に用いる特別な機能としても使用されます。ここで混同しやすいのは、typeofを使って値の型を取得する際、単に値そのものと型を混同してしまうことです。
const num = 42;
type NumType = typeof num; // number型を取得
let anotherNum: NumType = "42"; // エラー: string型はnumber型に代入できません対処法：typeofは値の「型」を取得するために使われるため、実際の値ではなくその型に基づいて扱う必要があります。値そのものと型を明確に区別しましょう。
3. `keyof`とインデックス型の誤用
keyofをインデックス型と組み合わせる際、型定義が広すぎるときに予期せぬエラーが発生することがあります。特に、オブジェクトがインデックス型を持っている場合、keyofで取得した型が想定通りでないことがあります。
type Product = {
[key: string]: string | number;
};
const product: Product = {
name: "Laptop",
price: 1500,
};
function getProductProperty(key: keyof Product) {
return product[key];
}
getProductProperty("name"); // OK
getProductProperty("unknownKey"); // 型上はエラーにならないが、実際にはundefined対処法：インデックス型を使用する際は、keyofによってすべてのプロパティが型安全に保証されるわけではないことに注意が必要です。型の設計時に特定のプロパティのみを型に明示的に含めることを検討しましょう。
4. 型キャスト（アサーション）の過剰な使用
TypeScriptでは、型キャスト（アサーション）を使用してコンパイラに特定の型を強制することができますが、これを乱用すると型安全性を損なう可能性があります。
const value: any = "hello";
const length = (value as number).toFixed(2); // 実行時エラーこの例では、valueが実際には文字列であるにもかかわらず、型アサーションによって数値型として扱われているため、実行時エラーが発生します。
対処法：型キャストは慎重に使い、型システムに頼るように設計することが重要です。特に、any型やunknown型を安易に型アサートするのではなく、型ガードや条件分岐を使用して安全に値を処理しましょう。
5. `any`型の誤用
any型はTypeScriptにおいて非常に便利ですが、型安全性を著しく低下させるため、できるだけ避けるべきです。any型を使うと、TypeScriptの型チェック機能が無効化され、型の不整合によるバグが発生しやすくなります。
let value: any = 42;
value = "Now I'm a string"; // 型チェックが行われない対処法：any型の代わりに、可能な限り具体的な型やunknown型を使用し、適切に型チェックを行うようにしましょう。unknown型はanyよりも安全で、型チェックを行わないと使用できないため、より安全なコードを実現できます。
まとめ
keyofやtypeofを使用する際に直面するよくある間違いは、TypeScriptの型システムを正しく理解することで回避できます。型注釈の適切な使用、型ガードやインデックス型の正しい理解、型キャストやany型の乱用を避けることが、型安全なコードの維持に繋がります。
応用例：オブジェクトのプロパティに基づく型安全なアクセス
keyofとtypeofを組み合わせることで、TypeScriptでは大規模なオブジェクトのプロパティに対して型安全にアクセスし、柔軟な操作が可能になります。ここでは、これらの機能を使った応用的な例を紹介し、より実践的な活用方法を見ていきます。
動的オブジェクトのプロパティに対する型安全な関数
複雑なオブジェクト構造を扱う際、特定のプロパティにアクセスするコードは頻繁に書かれます。ここでは、keyofを使ってオブジェクトのプロパティに動的にアクセスし、かつ型安全を確保する関数を作成します。
type User = {
id: number;
name: string;
email: string;
address: {
city: string;
zipCode: number;
};
};
const user: User = {
id: 1,
name: "Alice",
email: "alice@example.com",
address: {
city: "Wonderland",
zipCode: 12345,
},
};
function getUserProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const userName = getUserProperty(user, "name"); // 正しい型: string
const userEmail = getUserProperty(user, "email"); // 正しい型: string
const userCity = getUserProperty(user.address, "city"); // 正しい型: stringこの例では、getUserProperty関数がkeyofを使って型安全にuserオブジェクトのプロパティにアクセスしています。TypeScriptの型システムにより、誤ったプロパティ名や型が自動的に防がれます。
プロパティ名のリストを自動的に取得する
keyofを使ってオブジェクトのすべてのプロパティ名を型として取得し、それを基に動的に操作を行うことも可能です。これにより、特定のプロパティに基づいた処理を効率的に行うことができます。
function logUserProperties<T>(obj: T) {
(Object.keys(obj) as Array<keyof T>).forEach((key) => {
console.log(`${key}: ${obj[key]}`);
});
}
logUserProperties(user);
// 出力:
// id: 1
// name: Alice
// email: alice@example.com
// address: [object Object]Object.keys()で取得したキーをkeyofで型キャストすることで、プロパティ名と値に型安全にアクセスしつつ、動的に処理を行うことができます。
ネストされたプロパティへの安全なアクセス
ネストされたオブジェクトに対してもkeyofとtypeofを使うことで、安全にアクセスできます。たとえば、ユーザーの住所データに基づいて動的に処理を行う場合、次のように書くことができます。
function getNestedProperty<T, K1 extends keyof T, K2 extends keyof T[K1]>(
obj: T,
key1: K1,
key2: K2
): T[K1][K2] {
return obj[key1][key2];
}
const city = getNestedProperty(user, "address", "city"); // 正しい型: string
const zipCode = getNestedProperty(user, "address", "zipCode"); // 正しい型: numberこの例では、getNestedProperty関数を使用して、ネストされたプロパティに型安全にアクセスしています。これにより、誤ったキーやプロパティのタイプミスを防ぐことができます。
プロパティと型を一致させた条件付き処理
さらに応用として、特定のプロパティの値に基づいて動的に型チェックを行い、条件付きで処理を実行することも可能です。例えば、typeofを使って動的な型チェックを行い、その型に応じた処理を記述できます。
function handleUserProperty<T, K extends keyof T>(obj: T, key: K) {
const value = obj[key];
if (typeof value === "string") {
console.log(`The string value is: ${value.toUpperCase()}`);
} else if (typeof value === "number") {
console.log(`The number value is: ${value}`);
}
}
handleUserProperty(user, "name"); // 出力: The string value is: ALICE
handleUserProperty(user, "id"); // 出力: The number value is: 1このように、typeofとkeyofを組み合わせてプロパティの型に基づいた動的処理を行うことで、型安全かつ柔軟なコードが書けます。
まとめ
keyofとtypeofを駆使することで、オブジェクトのプロパティに対する型安全なアクセスが可能となり、コードの保守性と安全性が向上します。これらの応用例を基にすれば、TypeScriptを使ったプロジェクトにおいて型の恩恵を最大限に活かしつつ、動的なプロパティ操作を実現することができます。
演習問題：`keyof`と`typeof`を活用した型安全なコードを作成する
ここでは、keyofとtypeofを使ったTypeScriptの理解を深めるための演習問題を紹介します。これらの問題を通じて、型安全な操作やコードの柔軟性を実践的に学んでいきましょう。
問題1: オブジェクトのプロパティへの型安全なアクセス関数を作成する
次のようなBook型のオブジェクトがあります。このオブジェクトのプロパティに型安全にアクセスする関数getBookPropertyを作成してください。
type Book = {
title: string;
author: string;
yearPublished: number;
};
const myBook: Book = {
title: "The TypeScript Handbook",
author: "John Doe",
yearPublished: 2021,
};
// 関数を作成してください
function getBookProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
// ここで実装
}
// 実行例
console.log(getBookProperty(myBook, "title")); // 出力: "The TypeScript Handbook"
console.log(getBookProperty(myBook, "yearPublished")); // 出力: 2021ヒント:
keyofを使ってオブジェクトのプロパティ名に型安全にアクセスしましょう。- 返り値の型はプロパティ名に基づく型に設定します。
問題2: 動的なオブジェクト型の操作
次のUserProfile型を使って、オブジェクトのプロパティに動的にアクセスできる型安全な関数updateProfileを作成してください。この関数は、特定のプロパティを更新し、新しいオブジェクトを返すものです。
type UserProfile = {
username: string;
age: number;
email: string;
};
const profile: UserProfile = {
username: "alice123",
age: 30,
email: "alice@example.com",
};
// updateProfile関数を作成してください
function updateProfile<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
// ここで実装
}
// 実行例
const updatedProfile = updateProfile(profile, "age", 31);
console.log(updatedProfile);
// 出力: { username: "alice123", age: 31, email: "alice@example.com" }ヒント:
- 関数は指定されたキーと値に基づいて、新しいオブジェクトを作成します。
- 元のオブジェクトは変更せず、新しいオブジェクトを返すようにします。
問題3: ネストされたオブジェクトの型安全なプロパティアクセス
次のようなネストされたProduct型のオブジェクトに対して、型安全にネストされたプロパティにアクセスする関数getNestedPropertyを作成してください。
type Product = {
name: string;
details: {
weight: number;
manufacturer: string;
};
};
const product: Product = {
name: "Laptop",
details: {
weight: 2.5,
manufacturer: "TechCorp",
},
};
// getNestedProperty関数を作成してください
function getNestedProperty<T, K1 extends keyof T, K2 extends keyof T[K1]>(
obj: T,
key1: K1,
key2: K2
): T[K1][K2] {
// ここで実装
}
// 実行例
const manufacturer = getNestedProperty(product, "details", "manufacturer");
console.log(manufacturer); // 出力: "TechCorp"ヒント:
- ネストされたプロパティにアクセスするために、
keyofを活用して型安全なアクセスを実装します。
問題4: 型チェック付きのプロパティ更新関数
次のCar型のオブジェクトに対して、特定のプロパティが数値の場合のみ更新を許可するupdateCarProperty関数を作成してください。
type Car = {
make: string;
model: string;
year: number;
};
const car: Car = {
make: "Toyota",
model: "Corolla",
year: 2020,
};
// updateCarProperty関数を作成してください
function updateCarProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
if (typeof obj[key] === "number" && typeof value === "number") {
return { ...obj, [key]: value };
} else {
console.log(`Property "${key}" is not a number.`);
return obj;
}
}
// 実行例
const updatedCar = updateCarProperty(car, "year", 2021);
console.log(updatedCar);
// 出力: { make: "Toyota", model: "Corolla", year: 2021 }
updateCarProperty(car, "model", "Camry");
// 出力: Property "model" is not a number.ヒント:
typeofを使って動的に型チェックを行い、数値型のプロパティにのみ更新を適用します。
まとめ
これらの演習問題を通じて、keyofとtypeofの活用方法をより深く理解することができます。これらの機能を使いこなすことで、型安全性を高め、柔軟で保守性の高いTypeScriptコードを実現できるようになるでしょう。
まとめ
本記事では、TypeScriptにおけるkeyofとtypeofを組み合わせて、型安全なキーと値のペアを操作する方法を解説しました。これにより、型安全性を確保しつつ、柔軟で信頼性の高いコードを作成できるようになります。keyofを使ったプロパティ名の取得や、typeofを使った型の再利用、さらには応用例や演習問題を通して、実践的なコーディングパターンを学んできました。これらの知識を活用し、予測可能で堅牢なコードを作成できるようにしましょう。
コメント