range over interface{} which stores a slice

Given the scenario where you have a function which accepts t interface{}. If it is determined that the t is a slice, how do I range over that slice?

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

Go Playground Example: http://play.golang.org/p/DNldAlNShB

Well I used reflect.ValueOf and then if it is a slice you can call Len() and Index() on the value to get the len of the slice and element at an index. I don't think you will be able to use the range operate to do this.

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

Go Playground Example: http://play.golang.org/p/gQhCTiwPAq

You don't need to use reflection if you know which types to expect. You can use a type switch, like this:

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

Check out the code on the playground.

there is one exception from the way interface{} behaves, @Jeremy Wall gave already pointer. if the passed data is defined as []interface{} initially.

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

output:

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]

try it out

Expanding on the answer provided by masebase, you could generalize the iteration on an interface{} slice with a function like this:

func forEachValue(ifaceSlice interface{}, f func(i int, val interface{})) {
	v := reflect.ValueOf(ifaceSlice)
	if v.Kind() == reflect.Ptr {
		v = v.Elem()
	}
	if v.Kind() != reflect.Slice {
		panic(fmt.Errorf("forEachValue: expected slice type, found %q", v.Kind().String()))
	}

	for i := 0; i < v.Len(); i++ {
		val := v.Index(i).Interface()
		f(i, val)
	}
}

Then, you use it like this:

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

func test(sliceIface interface{}) {
    forEachValue(sliceIface, func(i int, value interface{}) {
      fmt.Println(value)
    }
}

a common in function

import (
	"fmt"
	"reflect"
)

func In(item interface{}, list interface{}) (ret bool, err error) {
	defer func() {
		if r := recover(); r != nil {
			ret, err = false, fmt.Errorf("%v", r)
		}
	}()
	itemValue, listValue := reflect.ValueOf(item), reflect.ValueOf(list)
	for i := 0; i < listValue.Len(); i++ {
		if listValue.Index(i).Interface() == itemValue.Interface() {
			return true, nil
		}
	}
	return false, nil
}

not so graceful but works well

fmt.Println(In(1, []int(2, 1, 3)))