유형이 Go에서 함수가되는 방식은 무엇입니까?

Question

나는 Go 신인이다.

나는 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 
} 

내가 이것을 읽는 방법을 hazily 알고,하지만 난 내 용어의 잘못을 얻을거야 확신 :

나는이 볼이 곳 keyLookupFunc라는 유형, 그리고 kl은 효과적으로이다 그것의 인스턴스이고이 함수는 GetByKey이라 불릴 수 있습니다. 그것은 key 유형이이 string입니다 받아, 그것은 세 가지 값을 반환 등 등

(나는 my best guess as to where it should live in the language specification에서이 특정 건설에 대한 BNF 표시되지 않습니다,하지만 난 그렇게하기 전에이 구성을 여러 번 본 적이 I 믿음에 그것을 가지고) 소스 코드에서 최대 높은

, 나는 이것을주의 사항 :.

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

좋아, 그럼 실제로 keyLookupFunc 일종이며,받는 함수가 무언가를 설명하는 데 사용되는 0 매개 변수를 반환하고 testFifoObject의 슬라이스를 반환합니다.

내 손에 keyLookupFunc 유형의 변수가있는 경우, GetByKey을 "on"으로 호출 할 수 있어야합니다. 나는이 상황에서 어떻게 함수가 하나의 유형처럼 행동 할 수 있는지 완전히 확신하지는 않지만 믿음으로 받아 들일 것입니다.

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") 호출 :

지금 나는 see this partial stuff,이 모든 사용 방법을 보려면 볼 때. f은 DeltaFIFO에 대한 포인터이며 I just happen to know is returned by NewDeltaFIFO입니다.

는 어떻게도 할 수있다, f이 DeltaFIFO에 대한 포인터임을 감안할 keyLookupFunc이 코드는 "의" 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 
} 

이

Answer 1

참고 두 GetByKey 방법은 두 개의 서로 다른 유형의 두 개의 방법 (이름이 같은 방법으로 두 가지 종류)이다

// 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) 
} 

을 또한 세 개의 전화 : (return f.GetByKey(key)에서 delta_fifo.go 파일에) 한 번 여기라고 (f.GetByKey("foo")에서 delta_fifo_test.go 파일에) 여기 시간 :

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의 1 등 시민입니다. 함수는 메소드를 포함 할 수 있으며 인터페이스도 구현할 수 있습니다.

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