Go에서 슬라이스로 제네릭 함수를 만들려면 어떻게해야합니까?

Question

의 내가 조각 나는 직관적으로 쓰고 싶은

에 값을 찾는 함수를 작성하고 싶은 말은하자

func find(s []interface{}, f func(interface{})bool) int { 
    for i, item := range s { 
     if f(item) { 
      return i 
     } 
    } 
    return -1 
} 

그러나 나는 이동이 작업을 수행하기 위해 관리하지 않습니다. , ... 등 추가 내가 재정의하는 경우 : 나는

Len() int 
Value(int) interface{} 
... 

과의 인터페이스를 가질 수 이것은 작동합니다하지만 내 실제 코드에서 가지 (등 내가 [끝에서] 조각을 할 필요가) 더 복잡 이 모든 것을 하나의 인터페이스에두면 많은 코드가 생깁니다. 더 좋은 방법이 있습니까?

Answer 1

리플렉션을 사용할 수 있습니다. 나는이 프로젝트에 대해이 기능을 작성, 사용 주시기 :

// InSlice returns true if value is in slice 
func InSlice(value, slice interface{}) bool { 
    switch reflect.TypeOf(slice).Kind() { 
    case reflect.Slice, reflect.Ptr: 
     values := reflect.Indirect(reflect.ValueOf(slice)) 
     if values.Len() == 0 { 
      return false 
     } 

     val := reflect.Indirect(reflect.ValueOf(value)) 

     if val.Kind() != values.Index(0).Kind() { 
      return false 
     } 

     for i := 0; i < values.Len(); i++ { 
      if reflect.DeepEqual(values.Index(i).Interface(), val.Interface()) { 
       return true 
      } 
     } 
    } 
    return false 
} 

Answer 2

당신은 []int 또는 []string 같은 미리 정의 된 유형을 가지고 (reflect를 사용하지 않고)이 작업 예제 코드를 볼 []interface{}로 변환하지 않으려는 경우 :

package main 

import "fmt" 

func find(s []int, f func(int) bool) int { 
    for i, item := range s { 
     if f(item) { 
      return i 
     } 
    } 
    return -1 
} 
func findString(s []string, f func(string) bool) int { 
    for i, item := range s { 
     if f(item) { 
      return i 
     } 
    } 
    return -1 
} 

func main() { 
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 
    fmt.Println(find(s, func(a int) bool { return a == 5 })) //5 

    strs := []string{"A", "B", "C"} 
    fmt.Println(findString(strs, func(a string) bool { return a == "B" })) //1 
} 

또는이 작업의 샘플 코드와 같은 reflect를 사용할 수있다 :

package main 

import "fmt" 
import "reflect" 

func find(slice interface{}, f func(interface{}) bool) int { 
    switch reflect.TypeOf(slice).Kind() { 
    case reflect.Slice: 
     values := reflect.Indirect(reflect.ValueOf(slice)) 
     for i := 0; i < values.Len(); i++ { 
      if f(values.Index(i).Interface()) { 
       return i 
      } 
     } 
    } 
    return -1 
} 

func main() { 
    a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 
    fmt.Println(find(a, func(i interface{}) bool { return i == 5 })) //5 

    b := []string{"A", "B", "C"} 
    fmt.Println(find(b, func(i interface{}) bool { return i == "B" })) //1 
} 

출력 :

5 
1 

,536,

도움이되기를 바랍니다.

Answer 3

당신이 임의의 값의 조각을 가지고 find 기능의 종류를 사용하고 [] 표준 reslicing의 가능성을 갖고 싶어 내가 어쩌면, 생각 가장 좋은 방법은 다른 구조체

type proxy struct { 
    val interface{} 
} 

로 interface{}을 캡슐화하고

func find(s []proxy , f func(proxy)bool) int {} 

를 사용하고 근래하는 것입니다 e f 함수는 interface{} 비교/유형 캐스팅을 처리합니다.