TypeScript チートシート

// プリミティブ型
let age: number = 25;
let name: string = "太郎";
let isActive: boolean = true;

// 配列
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["太郎", "花子"];

// タプル
let user: [string, number] = ["太郎", 25];

// any (型安全を失うため非推奨)
let data: any = "文字列でも数値でもOK";

// unknown (anyより安全)
let value: unknown = "型チェック必須";
if (typeof value === "string") {
    console.log(value.toUpperCase());
}

// 基本的なインターフェース
interface User {
    id: number;
    name: string;
    email: string;
}

const user: User = {
    id: 1,
    name: "太郎",
    email: "taro@example.com"
};

// オプショナルプロパティ
interface Product {
    id: number;
    name: string;
    price: number;
    description?: string;  // 省略可能
}

// 読み取り専用プロパティ
interface Config {
    readonly apiKey: string;
    readonly endpoint: string;
}

const config: Config = {
    apiKey: "abc123",
    endpoint: "https://api.example.com"
};
// config.apiKey = "xyz"; // エラー!

// プリミティブのエイリアス
type ID = number;
type Email = string;

// オブジェクト型
type User = {
    id: ID;
    email: Email;
    createdAt: Date;
};

// ユニオン型
type Status = "pending" | "approved" | "rejected";
type Result = string | number | boolean;

// 関数型
type Callback = (data: string) => void;
type Calculator = (a: number, b: number) => number;

const add: Calculator = (a, b) => a + b;

// ユニオン型
type Response = string | number | null;

function handleResponse(res: Response) {
    // 型ガード (typeof)
    if (typeof res === "string") {
        console.log(res.toUpperCase());
    } else if (typeof res === "number") {
        console.log(res.toFixed(2));
    } else {
        console.log("null response");
    }
}

// in演算子による型ガード
type Cat = { meow: () => void };
type Dog = { bark: () => void };

function speak(animal: Cat | Dog) {
    if ("meow" in animal) {
        animal.meow();
    } else {
        animal.bark();
    }
}

// カスタム型ガード
function isString(value: unknown): value is string {
    return typeof value === "string";
}

// 基本的な関数
function greet(name: string): string {
    return `Hello, ${name}!`;
}

// オプション引数
function buildName(firstName: string, lastName?: string): string {
    return lastName ? `${firstName} ${lastName}` : firstName;
}

// デフォルト引数
function multiply(a: number, b: number = 1): number {
    return a * b;
}

// Rest引数
function sum(...numbers: number[]): number {
    return numbers.reduce((a, b) => a + b, 0);
}

// アロー関数
const divide = (a: number, b: number): number => a / b;

// void型 (返り値なし)
function logMessage(message: string): void {
    console.log(message);
}

// never型 (決して返らない)
function throwError(message: string): never {
    throw new Error(message);
}

// 基本的なジェネリクス関数
function identity<T>(arg: T): T {
    return arg;
}

const result1 = identity<string>("hello");
const result2 = identity<number>(42);

// ジェネリクス配列
function getFirstElement<T>(arr: T[]): T | undefined {
    return arr[0];
}

// ジェネリクスインターフェース
interface Box<T> {
    value: T;
}

const stringBox: Box<string> = { value: "hello" };
const numberBox: Box<number> = { value: 123 };

// 複数の型パラメータ
function pair<K, V>(key: K, value: V): [K, V] {
    return [key, value];
}

const userPair = pair("id", 1);  // [string, number]

// ジェネリクス制約
interface HasLength {
    length: number;
}

function logLength<T extends HasLength>(arg: T): void {
    console.log(arg.length);
}

logLength("hello");     // OK
logLength([1, 2, 3]);   // OK
// logLength(123);      // エラー!

class Person {
    // プロパティ
    private name: string;
    protected age: number;
    public email: string;

    // コンストラクタ
    constructor(name: string, age: number, email: string) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // メソッド
    greet(): string {
        return `Hello, I'm ${this.name}`;
    }

    // Getter
    get fullInfo(): string {
        return `${this.name} (${this.age})`;
    }

    // Setter
    set updateAge(newAge: number) {
        if (newAge > 0) {
            this.age = newAge;
        }
    }
}

// 継承
class Employee extends Person {
    private department: string;

    constructor(name: string, age: number, email: string, dept: string) {
        super(name, age, email);
        this.department = dept;
    }

    getDepartment(): string {
        return this.department;
    }
}

// 抽象クラス
abstract class Animal {
    abstract makeSound(): void;

    move(): void {
        console.log("Moving...");
    }
}

interface User {
    id: number;
    name: string;
    email: string;
    age: number;
}

// Partial - すべてのプロパティをオプションに
type PartialUser = Partial<User>;
// { id?: number; name?: string; ... }

// Required - すべてのプロパティを必須に
type RequiredUser = Required<PartialUser>;

// Readonly - すべてのプロパティを読み取り専用に
type ReadonlyUser = Readonly<User>;

// Pick - 特定のプロパティのみ抽出
type UserPreview = Pick<User, "id" | "name">;
// { id: number; name: string; }

// Omit - 特定のプロパティを除外
type UserWithoutEmail = Omit<User, "email">;
// { id: number; name: string; age: number; }

// Record - キーと値の型を指定
type UserRoles = Record<string, string>;
const roles: UserRoles = {
    admin: "管理者",
    user: "一般ユーザー"
};

// ReturnType - 関数の戻り値の型を取得
function getUser() {
    return { id: 1, name: "太郎" };
}
type UserReturn = ReturnType<typeof getUser>;
// { id: number; name: string; }