一個類型在Go中如何成爲函數？

Question

我是個新手。我正在尋找some Kubernetes source code。

我看到這一點：

// GetByKey returns the key if it exists in the list returned by kl. 
func (kl keyLookupFunc) GetByKey(key string) (interface{}, bool, error) { 
    for _, v := range kl() { 
     if v.name == key { 
      return v, true, nil 
     } 
    } 
    return nil, false, nil 
} 

我朦朧地知道如何閱讀，但我敢肯定，我會得到我的術語錯誤：有一個地方叫keyLookupFunc類型，kl是有效的它的實例，並且可以調用名爲GetByKey的此函數。它接受一個key類型爲string，並返回三個值，等等，等等

（我沒有看到BNF在my best guess as to where it should live in the language specification這個特殊的建築，但我之前，所以見過這種結構好幾次我只要相信）

越往上源代碼

，我注意到這一點：

// keyLookupFunc adapts a raw function to be a KeyLookup. 
type keyLookupFunc func() []testFifoObject 

OK，所以確實keyLookupFunc是一種類型，它是用來描述的東西，是需要一個功能零參數並返回一片testFifoObject s。如此天真，如果我手上有一個keyLookupFunc-type變量，我應該可以調用GetByKey「on」。我不完全確定一個函數在這種情況下的行爲如何，但我會信賴它。

現在，當我看看，看看這是怎麼用的，我see this partial stuff：

func TestDeltaFIFO_requeueOnPop(t *testing.T) { 
    f := NewDeltaFIFO(testFifoObjectKeyFunc, nil, nil) 

    f.Add(mkFifoObj("foo", 10)) 
    _, err := f.Pop(func(obj interface{}) error { 
     if obj.(Deltas)[0].Object.(testFifoObject).name != "foo" { 
      t.Fatalf("unexpected object: %#v", obj) 
     } 
     return ErrRequeue{Err: nil} 
    }) 
    if err != nil { 
     t.Fatalf("unexpected error: %v", err) 
    } 
    if _, ok, err := f.GetByKey("foo"); !ok || err != nil { 
     t.Fatalf("object should have been requeued: %t %v", ok, err) 
    } 

注意f.GetByKey("foo")調用。 f是指向DeltaFIFO，其中I just happen to know is returned by NewDeltaFIFO。

鑑於f是一個指向DeltaFIFO，怎麼還可以是這樣keyLookupFunc，這個代碼可以「」它叫GetByKey？我如何連接這些點？

Answer 1

注意兩個GetByKey方法是在兩個不同類型的兩個單獨的方法中，（兩種不同類型的與具有相同名稱的方法）：

注意最後f.GetByKey是：

// GetByKey returns the complete list of deltas for the requested item, 
// setting exists=false if that list is empty. 
// You should treat the items returned inside the deltas as immutable. 
func (f *DeltaFIFO) GetByKey(key string) (item interface{}, exists bool, err error) { 
    f.lock.RLock() 
    defer f.lock.RUnlock() 
    d, exists := f.items[key] 
    if exists { 
     // Copy item's slice so operations on this slice (delta 
     // compression) won't interfere with the object we return. 
     d = copyDeltas(d) 
    } 
    return d, exists, nil 
} 

和這調用一次在這裏（在delta_fifo.go文件在return f.GetByKey(key)）：

// Get returns the complete list of deltas for the requested item, 
// or sets exists=false. 
// You should treat the items returned inside the deltas as immutable. 
func (f *DeltaFIFO) Get(obj interface{}) (item interface{}, exists bool, err error) { 
    key, err := f.KeyOf(obj) 
    if err != nil { 
     return nil, false, KeyError{obj, err} 
    } 
    return f.GetByKey(key) 
} 

而且也叫三這裏次（delta_fifo_test.go文件在f.GetByKey("foo")）：

func TestDeltaFIFO_requeueOnPop(t *testing.T) { 
    f := NewDeltaFIFO(testFifoObjectKeyFunc, nil, nil) 

    f.Add(mkFifoObj("foo", 10)) 
    _, err := f.Pop(func(obj interface{}) error { 
     if obj.(Deltas)[0].Object.(testFifoObject).name != "foo" { 
      t.Fatalf("unexpected object: %#v", obj) 
     } 
     return ErrRequeue{Err: nil} 
    }) 
    if err != nil { 
     t.Fatalf("unexpected error: %v", err) 
    } 
    if _, ok, err := f.GetByKey("foo"); !ok || err != nil { 
     t.Fatalf("object should have been requeued: %t %v", ok, err) 
    } 

    _, err = f.Pop(func(obj interface{}) error { 
     if obj.(Deltas)[0].Object.(testFifoObject).name != "foo" { 
      t.Fatalf("unexpected object: %#v", obj) 
     } 
     return ErrRequeue{Err: fmt.Errorf("test error")} 
    }) 
    if err == nil || err.Error() != "test error" { 
     t.Fatalf("unexpected error: %v", err) 
    } 
    if _, ok, err := f.GetByKey("foo"); !ok || err != nil { 
     t.Fatalf("object should have been requeued: %t %v", ok, err) 
    } 

    _, err = f.Pop(func(obj interface{}) error { 
     if obj.(Deltas)[0].Object.(testFifoObject).name != "foo" { 
      t.Fatalf("unexpected object: %#v", obj) 
     } 
     return nil 
    }) 
    if err != nil { 
     t.Fatalf("unexpected error: %v", err) 
    } 
    if _, ok, err := f.GetByKey("foo"); ok || err != nil { 
     t.Fatalf("object should have been removed: %t %v", ok, err) 
    } 
} 

---

而另一種方法是：

// GetByKey returns the key if it exists in the list returned by kl. 
func (kl keyLookupFunc) GetByKey(key string) (interface{}, bool, error) { 
    for _, v := range kl() { 
     if v.name == key { 
      return v, true, nil 
     } 
    } 
    return nil, false, nil 
} 

，這是不使用（不叫）。

Answer 2

功能是Go的頭等公民：它可以有一個方法，甚至可以實現接口。

https://play.golang.org/p/d-N4OKLirQ