オブジェクト型

オブジェクト型リテラル

このエントリーをはてなブックマークに追加
最終更新日 2016-12-31

TypeScript では、関数、クラス、インターフェイス、モジュール、オブジェクトリテラルのような構文によって作られる型は、 総称してオブジェクト型と呼ばれます。 オブジェクト型はリテラルで表現することができ、プロパティシグネチャ、コールシグネチャ、メソッドシグネチャ、コンストラクトシグネチャ、インデックスシグネチャを含むことができます。

プロパティシグネチャ

プロパティシグネチャは、オブジェクト型が含むプロパティの名前とその型を表します。次に示すのは、プロパティシグネチャの書式です。

プロパティ名: プロパティの型名;

次に示すのは、プロパティシグネチャを含むオブジェクト型リテラルを使用する例です。

// 変数 foo1 の型は、プロパティシグネチャを含むオブジェクト型リテラルで表現される
var foo1: {
    x: string;
    y: number;
};

// 変数 foo1 の型のプロパティシグネチャに合致するオブジェクトリテラルを代入する
foo1 = {
    x: "TypeScript",
    y: 123
};
foo1.x;

// シグネチャを満たしていれば、余分な値(この例では z )を含むオブジェクトリテラルを代入してもコンパイルエラーにはならない
foo1 = {
    x: "TypeScript",
    y: 123,
    z: 456
};

// 関数の引数の型がオブジェクト型リテラルの例
function foo(bar: { x: string; y: number; }): void {
    
}
foo({ x: "TypeScript", y: 123 });

プロパティ名の後に ? を付けることによって、プロパティをオプションにすることができます。

var foo2: {
    x: string;
    y?: number;
};

// y を省略してもコンパイルエラーにはならない
foo2 = {
    x: "TypeScript"
};

コールシグネチャ

コールシグネチャは、オブジェクト型が関数のように呼び出せることを表します。次に示すのは、コールシグネチャの書式です。

(引数名: 引数の型名): 戻り値の型名;

次に示すのは、コールシグネチャを含むオブジェクト型リテラルを使用する例です。コールシグネチャを含むオブジェクト型は関数型と言えます。

// 変数 foo3 の型は、コールシグネチャを含むオブジェクト型リテラルで表現される
var foo3: {
    (x: string): string;
};

// 変数 foo3 の型のコールシグネチャに合致する関数式を代入する
foo3 = function(x: string): string {
    return "Hello, " + x;
};

// コールシグネチャを含むので、関数のように呼び出せる
foo3("TypeScript");

複数のコールシグネチャを定義することで、オーバーロードに対応できます。

// 変数 foo4 の型は、オーバーロードに対応したオブジェクト型リテラルで表現される
var foo4: {
    (x: number): number;
    (x: number, y: boolean): number;
    (x: string): string;
};

// 変数 foo4 の型のコールシグネチャに合致する関数式を代入する
foo4 = function(x: any, y?: boolean): any {
    if (typeof x === "number") {
        
    } else {
        
    }
}
foo4(123);
foo4("TypeScript");

コールシグネチャに型パラメータを含めることで、ジェネリックコールシグネチャに対応できます。

// 変数 foo5 の型は、ジェネリックコールシグネチャを含むオブジェクト型リテラルで表現される
var foo5: {
    <T>(x: T): T;
};

// 変数 foo5 の型のジェネリックコールシグネチャに合致する関数式を代入する
foo5 = function<T>(x: T): T { 
    return x;
}
foo5<string>("TypeScript");

メソッドシグネチャ

メソッドシグネチャは、オブジェクト型が関数のように呼び出せるプロパティを含むことを表します。次に示すのは、メソッドシグネチャの書式です。

プロパティ名(引数名: 引数の型名): 戻り値の型名;

次に示すのは、メソッドシグネチャを含むオブジェクト型リテラルを使用する例です。

// 変数 foo6 の型は、メソッドシグネチャを含むオブジェクト型リテラルで表現される
var foo6: {
    greet(x: string): string;
};

// 変数 foo6 の型のメソッドシグネチャに合致する値を代入する
foo6 = { 
    greet: function(x: string): string {
        return "Hello, " + x;
    }
}

// メソッドシグネチャを含むので、クラスのメンバ関数のように呼び出せる
foo6.greet("TypeScript");

// 変数 foo6 の型のメソッドシグネチャに合致するクラスのインスタンスも代入できる
class Bar {
    public greet(x: string): string {
        return "Hello, " + x;
    }
}
foo6 = new Bar;
foo6.greet("TypeScript");

コンストラクトシグネチャ

コンストラクトシグネチャは、オブジェクト型に new 演算子を適用できることを表します。次に示すのは、コンストラクトシグネチャの書式です。

new (引数名: 引数の型名): 戻り値の型名;

次に示すのは、コンストラクトシグネチャを含むオブジェクト型リテラルを使用する例です。コンストラクトシグネチャを含むオブジェクト型はコンストラクタ型と言えます。

// 変数 foo7 の型は、コンストラクトシグネチャを含むオブジェクト型リテラルで表現される
var foo7: {
    new (x: string): Bar;
};

// 変数 foo7 の型のコンストラクトシグネチャに合致するクラスを代入する
class Bar {
    constructor(private x: string) {
    }
    public greet(): string {
        return "Hello, " + this.x;
    }
}
foo7 = Bar;

// コンストラクトシグネチャを含むので、new 演算子を適用できる
var result = new foo7("TypeScript");
result.greet();

インデックスシグネチャ

インデックスシグネチャは、オブジェクト型が含むプロパティの型制約を表します。次に示すのは、インデックスシグネチャの書式です。

[識別子: string] 要素の型名;
[識別子: number] 要素の型名;

次に示すのは、インデックスシグネチャを含むオブジェクト型リテラルを使用する例です。

// 変数 foo8 の型は、インデックスシグネチャを含むオブジェクト型リテラルで表現される
var foo8: {
    [x: string]: number;
};

// 変数 foo8 の型に合致するオブジェクトリテラルを代入する
foo8 = { foo: 123, bar: 456 };
foo8["foo"];

オブジェクト型リテラルに名前を付ける

オブジェクト型リテラルは匿名のオブジェクト型ですが、インターフェイス宣言を使用して名前を付けることができます。 次に示すのは、コールシグネチャを含むオブジェクト型リテラルに Foo という名前を付ける例です。

interface Foo {
    (x: string): string;  // コールシグネチャ
}

var foo9: Foo = function(x: string): string {
    return "Hello, " + x;
};