Typescriptインタフェースファイルで戻り値の型を表現するにはどうすればよいですか？次のコードの違いは何ですか

Question

：

changeName(): ng.IPromise<any>; 

と

changeName:() => ng.IPromise<any>; 

は、私は1つを理解するには、戻り値の型であるが、私は最初の1程度混乱しています。

ここでは関数の本体です：

changeName =(): ng.IPromise<any> => { 
     var self = this; 
     self.chnAction = "PREFERENCES.CHANGE_NAME.SUBMITTING_BUTTON_TEXT"; 
     self.chnErrorMessage = null; 
     return self.uss.changeName(
      self.chnNewFirstName, 
      self.chnNewLastName) 
      .then(
      (response: ng.IHttpPromiseCallbackArg<any>): any => { 
       self.chnAction = "PREFERENCES.CHANGE_NAME.SUBMITTED_BUTTON_TEXT"; 
       self.chnNewFirstName = ''; 
       self.chnNewLastName = ''; 
       self.chnErrorMessage = null; 
       self.logout(); 
       return this.$state.go('home.auth', { content: 'change_name_success' }); 
      }, 
      (error: ng.IHttpPromiseCallbackArg<any>): ng.IPromise<any> => { 
       if (error.status === 500) { 
        self.chnErrorMessage = 'AUTH_SERVICE.UNABLE_TO_CONTACT_SERVER'; 
       } else { 
        var errors: string[] = []; 
        Object.keys(error.data.modelState).forEach((key) => { 
         errors.push.apply(errors, error.data.modelState[key]); 
        }); 
        self.chnErrorMessage = errors[0]; 
        self.chnErrorMessages = errors; 
        self.chnAction = "PREFERENCES.CHANGE_NAME.SUBMIT_BUTTON_TEXT"; 
       } 
       return this.$q.reject(error); 
      }); 
    }; 

Answer 1

根本的な違いは、このです：

• changeName(): ng.IPromise<any>;は方法を表します。
• changeName:() => ng.IPromise<any>;は、機能を保持することができるプロパティを表します（これは、プロパティに機能を割り当てるためchangeName =(): ng.IPromise<any> => { ... };に一致します）。

このため、プロパティとメソッドの違いが適用されます。

interface MyInterface { 
    myMethod(): string; 
    myProperty:() => string; 
} 

class MyBaseClass implements MyInterface { 
    myMethod() { 
     return "string"; 
    } 

    myProperty =() => "string"; 
} 

class MyChildClass extends MyBaseClass { 
    myMethod() { 
     return super.myMethod(); 
    } 

    myProperty =() => super.myProperty(); // error 
} 

プロパティに割り当てられた矢印の機能がそれにバインドされているものに関係なくthisの値を保持していないので、代わりに時々行われている方法の矢印関数プロパティを使用している理由...

：ここでは一例です

class MyClass { 
    myMethod() { 
     console.log(this); 
    } 

    myProperty =() => console.log(this); 
} 

new MyClass().myMethod.call({}); // outputs {} 
new MyClass().myProperty.call({}); // outputs the instance of MyClass 

... thisの値がコンストラクタに保存されているので...

var MyClass = (function() { 
    function MyClass() { 
     // captures this here 
     var _this = this; 
     // guaranteed to always use instance of class for `this` 
     this.myProperty = function() { return console.log(_this); }; 
    } 
    MyClass.prototype.myMethod = function() { 
     // not guarnateed to always use instance of class 
     console.log(this); 
    }; 
    return MyClass; 
})(); 

追記：については、hereで読むことができます。

Answer 2

は、全体のサンプルコードを表示する方が良いだろう。

class MyClass { 

    changeName(): number { 
     return 5; 
    } 

    changeName2 =():number => { 
     return 5; 
    } 
} 

transpiles：うまくいけば、次の例では、あなたの質問を説明します

var MyClass = (function() { 
    function MyClass() { 
     this.changeName2 = function() { 
      return 5; 
     }; 
    } 
    MyClass.prototype.changeName = function() { 
     return 5; 
    }; 
    return MyClass; 
})(); 

[Playground]

あり、これら二つの定義間の相違点の詳細な説明：Declaring javascript object method in constructor function vs. in prototype

Answer 3

次のコードとの違いは何ですか

実際に設定された内容を確認するためのコードを追加していないため、 1だからobject, string, array, numberなど、何もすることができた、それはどのようなタイプの約束を返しているというものを

を理解することができ、このコードを1として

changeName(): ng.IPromise<any>; 

：私はあなたが2行のコードを持って見ることができるようにchangeName()は<any>のタイプのng.IPromise値を返すと言うことができます。

---

コードの他のライン間：

changeName:() => ng.IPromise<any>; 

は、この関数は値<any>事のng.IPromiseを返すことを言います。

Answer 4

インターフェイスには違いはありません。ここで両方の表記を使用するインターフェイスだ（のは、明確にするため、戻り値の型としてstringを使用してみましょう）：

ここ

interface MyInterface { 
    foo(): string; // preferred 
    bar:() => string; 
} 

、fooは、戻り値の型stringを持つ関数です。また、barのタイプは戻りタイプstringの関数です。最初の表記は通常よりきれいです。次のオブジェクトは、インターフェイスと一致する一の表記であるクラス、上

let x: MyInterface = { 
    foo:() => "", 
    bar:() => "" 
} 

を他の新しいインスタンス（this.myFunc = ...）のプロパティとして追加しながら、プロトタイプに機能を追加します。これはJavaScriptとまったく同じ効果を持ちます（インスタンスプロパティとして関数/メソッドを追加する必要はほとんどありません）。

class MyClass { 
    bar(): string { return ""; } // prototype, preferred 
    foo =() => ""; // instance property 
} 

我々は下記見ることができるように、クラスは私がfooとbarを逆にしたにも関わらず、私たちのオリジナルのインタフェースに適合します。したがって、インタフェースは、メソッドの設定方法の実装の詳細を課すものではありません。

let y: MyInterface = new MyClass(); 

クラスは特殊なタイプではなく、実際にはインターフェイスと実装の両方になります。だから、としてMyClassを使用することができますでしょう（インターフェイスまたはクラスとして定義されているかどうか）の任意の他のタイプ：

で使用する場合は、しかし、違いはありません（インタフェースが定義するものである）のタイプに関しては

let z: MyClass = { 
    foo:() => "", 
    bar:() => "" 
} 

表記法は異なる実装を生成する。