rango sobre la interfaz {} que almacena un segmento

Dado el escenario en el que tiene una función que acepta t interface{}. Si se determina que tes una rebanada, ¿cómo puedo rangesuperar esa rebanada?

func main() {
    data := []string{"one","two","three"}
    test(data)
    moredata := []int{1,2,3}
    test(data)
}

func test(t interface{}) {
    switch reflect.TypeOf(t).Kind() {
    case reflect.Slice:
        // how do I iterate here?
        for _,value := range t {
            fmt.Println(value)
        }
    }
}

Ejemplo de Go Playground: http://play.golang.org/p/DNldAlNShB

go reflection slice go-reflect

— Nucleón
fuente

¿Por qué no hacer que la función tome una [] interfaz {} en su lugar? ¿Estás intentando manejar varios tipos complejos?

— Jeremy Wall

Sí, es para un sistema de plantillas, por lo que la interfaz {} podría ser un mapa, estructura, sector o matriz. En el código real hay muchas más declaraciones de casos, pero las eliminé de la publicación para hacer el problema más conciso.

— Nucleon

Jeremy, una cadena [] no es un subtipo de [] interfaz {}, por lo que no puedes llamar a una función func ([] interfaz {}) con una cadena [] o [] int, etc. Sería bueno tener una característica en Go para tener un tipo que signifique "porción de algo", donde luego puede iterar sobre los elementos como interfaz {}, pero desafortunadamente necesita una reflexión para eso.

— Bjarke Ebert

@JeremyWall No puede usar [] interfaz {} para actuar como segmento. Puede consultar aquí .

— firelyu

Respuestas:

138

Bueno, usé reflect.ValueOfy luego, si es un segmento, puede llamar Len()y Index()en el valor para obtener lenel segmento y el elemento en un índice. No creo que pueda usar el rango de operación para hacer esto.

package main

import "fmt"
import "reflect"

func main() {
    data := []string{"one","two","three"}
    test(data)
    moredata := []int{1,2,3}
    test(moredata)
} 

func test(t interface{}) {
    switch reflect.TypeOf(t).Kind() {
    case reflect.Slice:
        s := reflect.ValueOf(t)

        for i := 0; i < s.Len(); i++ {
            fmt.Println(s.Index(i))
        }
    }
}

Ejemplo de Go Playground: http://play.golang.org/p/gQhCTiwPAq

— masebase
fuente

Funciona muy bien, gracias. Lo único que agregar sería que s.Index(i)devuelva un, reflect.Valuepor lo que en mi caso necesitaba s.Index(i).Interface()hacer referencia al valor real.

— Nucleon

¿Qué harías si tuvieras un puntero a un corte interface{}? Por ejemplo moredata := &[]int{1,2,3}

— Ryan Walls

Respondiendo a mi pregunta: si tiene un puntero a un segmento en lugar de un segmento, deberá usarlo Elem()para obtener el valor subyacente. preflect.TypeOf(reflect.ValueOf(t).Elem().Interface()).Kind()

— Ryan Walls

¿Qué pasa si quiero obtener el valor del campo de la interfaz del segmento de la interfaz sin ninguna estructura? Probé esta solución, pero está limitada a obtener la referencia de la interfaz solo de la sección, no de los valores reales de los campos.

— Amandeep kaur

woh muchas gracias, ese truco me ahorró mucho tiempo (¡y dolor de cabeza!)

— Nicolas Garnier

No necesita utilizar la reflexión si sabe qué tipos esperar. Puede usar un interruptor de tipo , como este:

package main

import "fmt"

func main() {
    loop([]string{"one", "two", "three"})
    loop([]int{1, 2, 3})
}

func loop(t interface{}) {
    switch t := t.(type) {
    case []string:
        for _, value := range t {
            fmt.Println(value)
        }
    case []int:
        for _, value := range t {
            fmt.Println(value)
        }
    }
}

Mira el código en el patio de recreo .

— Inanc Gumus
fuente

Sin embargo, esto no funcionará en una matriz, solo en un segmento

— user1028741

@ user1028741 No, el código funciona para todos los tipos, incluidas las matrices + Siempre puede tomar una porción de una matriz array[:].

— Inanc Gumus

Pero el tipo de una matriz estará con la capacidad real de la misma. [3] int no es del mismo tipo que [2] int o [] int. Por lo tanto, si el tipo de 't' es en realidad una matriz, no se aplicará el caso relevante.

— user1028741

Lo que quiero decir es que su ejemplo no funcionará en matrices. Lo cambié aquí: play.golang.org/p/DAsg_0aXz-r

— user1028741

No puede hacer que funcione fácilmente, si no conoce el tipo de su parámetro en primer lugar. Para usar su truco (matriz [:]), tendrá que usar la reflexión para decidir que es una matriz, luego convertirla en matriz y luego generar una porción de ella. Por eso dije que funciona en un segmento, no en una matriz. Claramente, con suficiente esfuerzo, puede producir una porción de la matriz ...

— user1028741

hay una excepción en la forma en que se comporta la interfaz {}, @Jeremy Wall ya dio un puntero. si los datos pasados se definen como [] interfaz {} inicialmente.

package main

import (
    "fmt"
)

type interfaceSliceType []interface{}

var interfaceAsSlice interfaceSliceType

func main() {
    loop(append(interfaceAsSlice, 1, 2, 3))
    loop(append(interfaceAsSlice, "1", "2", "3"))
    // or
    loop([]interface{}{[]string{"1"}, []string{"2"}, []string{"3"}})
    fmt.Println("------------------")


    // and of course one such slice can hold any type
    loop(interfaceSliceType{"string", 999, map[int]string{3: "three"}})
}

func loop(slice []interface{}) {
    for _, elem := range slice {
        switch elemTyped := elem.(type) {
        case int:
            fmt.Println("int:", elemTyped)
        case string:
            fmt.Println("string:", elemTyped)
        case []string:
            fmt.Println("[]string:", elemTyped)
        case interface{}:
            fmt.Println("map:", elemTyped)
        }
    }
}

salida:

int: 1
int: 2
int: 3
string: 1
string: 2
string: 3
[]string: [1]
[]string: [2]
[]string: [3]
------------------
string: string
int: 999
map: map[3:three]

Pruébalo

— Matus Kral
fuente