Cannot Range Over List Type Interface {} In Function Using Go

Cannot Range Over List Type Interface {} In Function Using Go.

• for me is important then i execute for in a function.

How can fix?

package main

import (
	"fmt"
)

type MyBoxItem struct {
	Name string
}

type MyBox struct {
	Items []MyBoxItem
}

func (box *MyBox) AddItem(item MyBoxItem) []MyBoxItem {
	box.Items = append(box.Items, item)
	return box.Items
}

func PrintCustomArray(list interface{}) interface{}  {
	//items := reflect.ValueOf(list)
	for _, v := range list {
		fmt.Println(v.Key,v.Value)
	}
	return 0
}
func main() {

	items := []MyBoxItem{}
	item := MyBoxItem{Name: "Test Item 1"}
	box := MyBox{items}
	box.AddItem(item)
	fmt.Println((box.Items))
	PrintCustomArray(box.Items)
}

https://play.golang.org/p/ZcIBLMliq3

Error : cannot range over list (type interface {})

How can fix?

Note

The answer below describes, in broad strokes, 2 possible approaches: using interfaces, and using specific types. The approach focusing on interfaces is mentioned for completeness sake. IMHO, the case you've presented is not a viable use-case for interfaces.

Below, you'll find a link to a playground example that uses both techniques. It should be apparent to anyone that the interface approach is too cumbersome if for this specific case.

Quite apart from the fact that you don't really seem to be too familiar with how loops work in go (v.Key and v.Value are non-existent fields for example), I'll attempt to answer your question.

You are passing a list to your function, sure enough, but it's being handled as an interface{} type. That means your function accepts, essentially, any value as an argument. You can't simply iterate over them.

What you can do is use type assertions to convert the argument to a slice, then another assertion to use it as another, specific interface:

type Item interface{
    key() string
    val() string
}

func (i MyBoxItem) key() string {
    return i.Key
}

func (i MyBoxItem) val() string {
    return i.Value
}

func PrintCustomArray(list interface{}) error  {
    listSlice, ok := list.([]interface{})
    if !ok {
        return fmt.Errorf("Argument is not a slice")
    }
    for _, v := range listSlice {
        item, ok := v.(Item)
        if !ok {
            return fmt.Errorf("element in slice does not implement the Item interface")
        }
        fmt.Println(item.key(), item.val())
    }
    return nil
}

But let's be honest, a function like this only works if a slice is passed as an argument. So having that first type assertion in there makes no sense whatsoever. At the very least, changing the function to something like this makes a lot more sense:

func PrintCustomArray(list []interface{})

Then, because we're not expecting an array as such, but rather a slice, the name should be changed to PrintCustomSlice.<br>
Lastly, because we're using the same type assertion for every value in the slice, we might as well change the function even more:

// at this point, we'll always return 0, which is pointless
// just don't return anything
func PrintCustomSlice(list []Item) {
    for _, v := range list {
        fmt.Println(v.key(), v.val())
    }
}

The advantages of a function like this is that it can still handle multiple types (all you have to do is implement the interface). You don't need any kind of expensive operations (like reflection), or type assertions.

Type assertions are very useful, but in a case like this, they merely serve to hide problems that would otherwise have resulted in a compile-time error. Go's interface{} type is a very useful thing, but you seem to be using it to get around the type system. If that's what you want to achieve, why use a typed language in the first place?

Some closing thoughts/remarks: If your function is only going to be used to iterate over specific "thing", you don't need the interfaces at all, simply specify the type you're expecting to be passed to the function in the first place. In this case that would be:

func PrintCustomSlice(list []MyBoxItem) {
    for _, v := range list {
        fmt.Println(v.Key, v.Value)
    }
}

Another thing that I've noticed is that you seem to be exporting everything (all functions, types, and fields start with a capital letter). This, in go, is considered bad form. Only export what needs to be public. In the main package, that usually means you're hardly export anything.

Lastly, as I mentioned at the start: you don't seem to have a firm grasp on the basics just yet. I'd strongly recommend you go through the interactive tour. It covers the basics nicely, but shows you the features of the language at a decent pace. It doesn't take long, and is well worth taking a couple of hours to complete

Playground demo

It's possible to implement PrintCustomArray using the reflect package, but most experienced Go programmers will write a simple for loop:

for _, i := range box.Items {
	fmt.Println("Name:", i.Name)
}

https://play.golang.org/p/RhubiCpry0

You can also encapsulate it in a function:

func PrintCustomArray(items []MyBoxItem) {
  for _, i := range items {
	fmt.Println("Name:", i.Name)
  }
}

https://play.golang.org/p/c4EPQIx1AH

Here since you are returning box.Items from AddItem(), Items is of the type []MyBoxItem , so list should be of type []MyBoxItem .Moreover you are returning 0 in PrintCustomArray and the return type you have set is {}interface.

func PrintCustomArray(list []MyBoxItem) {
    //items := reflect.ValueOf(list)
	for i, v := range list {
    	fmt.Println(i, v)
    }
    //return 0
}

Again, MyBoxItem struct has only one variable named Name so v.key v.value won't make any sense.

This is what the proper code should look like https://play.golang.org/p/ILoUwEWv6Y .

You need to clear your understanding about interfaces in go. This might help https://golang.org/doc/effective_go.html#interfaces_and_types .