簡単なtypescriptですたとえば、私は活字を学んだし、この例に取り組んでい

Question

「提供されたパラメータは、対象のコールサインを一致していません」これはfunc関数のreturn文で、最後の行でfuncの呼び出し内のxを返します。

これはエラーです：

Supplied parameters do not match call signature of target

しかし、私はコンパイルされたバージョンを取り、ちょうどそれが「という文字列と言う文字列」をロギングすることで動作しますコンソールに貼り付けた場合。

https://www.typescriptlang.org/play/index.html

私は、このエラーでstackoverflowの上の他の質問と回答を見てきましたが、それらはより複雑な角度の質問に関連しているように見える：私は活字体遊び場でコンパイラを使用してい

var obj = { 
    a: 5, 
    b: true, 
    c: 'string that says string' 
}; 
function x(someObj) { 
    return someObj.c; 
} 
function func(someObj, x) { 
    return x(someObj); 
} 
console.log(func(obj, x));  //string that says string 

私はそれらを理解していません。

Answer 1

あなたのコメントを拡大するには、Andrew Li（正解でなければならない）の答えに、実際にあなたが作成したコーナーをOVER-TYPINGで固定しました。

それはあなたが明示的にすべてのものを入力して、しかし、あなたが実際に矛盾をできるように余分なスペースを提供していることで、余分な安全でいるように見えるかもしれ

をFUNCように見えていた：。

function func (obj: Thing, x): string { 
    return x(obj); 
} 

ご使用のバージョンや設定に応じてうまく機能している（または「何の示唆もない」と訴えている）かもしれません。

あなたがしたことは、システムを安楽化させるために使い捨てを提供したかったので、一致しなかったタイプを提供することでした。

私は対立する、または何かをすることを意味するものではありません。私たちはすべてそれを犯しています。しかし、タイプシステムを癒す必要があると、私たちはいつも怠惰になります。

私はそれを見て苦痛が少ない方法は、このようになると主張するだろう：あなたはVSCodeにそれをロードした場合、私はあなたと愉快に驚くだろうと確信している

interface Transform<A, B> { 
    (x:A):B; 
} 

interface Thing { 
    a: number; 
    b: boolean; 
    c: string; 
} 

type ThingC = Transform<Thing, string>; 

const x = (obj: Thing) => obj.c; 
const func = (obj: Thing, x: ThingC) => x(obj); 


const c = func({ a: +!0, b: !0, c: "I work fine." }, x); 

あなたがそれから得る情報を入力してください。

タイプは実際にメソッドシグニチャーのためのものです。
あなたはもちろん、彼らの周りのツーリングをしたい場合は、constsに型情報を追加すること自由に感じなさい：

const obj: Thing = { a: 1, b: true, c: "Yes" }; 

をしかし、それは最も有益だところそれは本当にありません。特にobjがOtherThingのような異なるタイプのものであっても、の基準を満たしていても、それは何も知らずに何も知らなくても、それはまだxまたはfuncに入る可能性があるからです。あなたがどんなタイプミスをした場合、あなたに大声になるだろう、と今でも、あなたはまだ厳密されリテラルで関数を呼び出しているタイプ -

interface Transform<A, B> { 
    (x:A):B; 
} 

interface Apply<A, B> { 
    (x:A, f: Transform<A, B>):B; 
} 

interface Thing { 
    a: number; 
    b: boolean; 
    c: string; 
} 

const x: Transform<Thing, string> = obj => obj.c; 
const f: Apply<Thing, string> = (obj, x) => x(obj); 

const c = f({ a: 1, b: true, c: "" }, x); 

：でも、より一般的な場合ことを確認するために

チェック

何かが欲しいですか？

const g = <A, B>(o: A, x: Transform<A, B>):B => x(o); 
const d = g({ a: 1, b: true, c: "" }, x); 

あなたはそれが扱っていたものの種類についてgANYTHINGを教えてくれませんでした。これは無名関数であり、匿名型があり、変換が渡されます。

それは、まだはdに返さなっているどのタイプを知っている、そしてそれはまだ（関係なく、どのようなクラスのそれがあるか、それが持っているものインタフェース）oがThingであることを知っています。これは、それがxからそれらのタイプを引っ張って、後方に働いたので、これを知っています。

は、だから今、あなたは持っている：

interface Transform<A, B> { (x:A):B; } 
interface Thing { a: number; b: boolean; c: string; } 

const x = (obj: Thing) => 
    obj.c; 

const g = <A, B>(o: A, x: Transform<A, B>):B => 
    x(o); 

const d = g({ a: 1, b: true, c: "" }, x); 

そして、それまだはd権利を取得します。
このようなタイプを使用することは、直観に反するかもしれませんが、タイプ・システムを手作業で喜ばせるのではなく、実際にタイプ推論の強みに頼ることで、余分なノイズは、それが持つべきと考えるものと衝突する可能性があります。