2015-05-11 07:51
浏览 89


In the following code piece, trying to convert a nil interface to a pointer of something fails with the following error: interface conversion: interface is nil, not *main.Node

type Nexter interface {
    Next() Nexter

type Node struct {
    next Nexter

func (n *Node) Next() Nexter {...}

func main() {
    var p Nexter

    var n *Node
    fmt.Println(n == nil) // will print true
    n = p.(*Node) // will fail

Play link here: https://play.golang.org/p/2cgyfUStCI

Why does this fail exactly? It's entirely possible to do

n = (*Node)(nil)

, so I'm wondering how can you achieve a similar effect starting from a nil interface.

图片转代码服务由CSDN问答提供 功能建议

在以下代码段中,尝试将nil接口转换为某物的指针失败,并出现以下错误:< code>接口转换:接口为nil,不是* main.Node

  type Nexter接口{
type节点 struct {
 next Nexter 
func(n * Node)Next()Nexter {...} 
func main(){
 var p Nexter 
 var n * Node 
  fmt.Println(n == nil)//将输出true 
n = p。(* Node)//将失败

此处播放链接 : https://play.golang.org/p/2cgyfUStCI \ n


  n =(* Node)(nil)

完全有可能,所以我 想知道如何从nil接口开始实现类似的效果。

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

1条回答 默认 最新

  • doubi8965 2015-05-11 08:02

    This is because a variable of static type Nexter (which is just an interface) may hold values of many different dynamic types.

    Yes, since *Node implements Nexter, your p variable may hold a value of type *Node, but it may hold other types as well which implement Nexter; or it may hold nothing at all (nil value). And Type assertion cannot be used here because quoting from the spec:

    x.(T) asserts that x is not nil and that the value stored in x is of type T.

    But x in your case is nil. And if the type assertion is false, a run-time panic occurs.

    If you change your program to initialize your p variable with:

    var p Nexter = (*Node)(nil)

    Your program will run and type assertion succeeds. This is because an interface value actually holds a pair in the form of: (value, dynamic type), and in this case your p will not be nil, but will hold a pair of (nil, *Node); for details see The Laws of Reflection #The representation of an interface.

    If you also want to handle nil values of interface types, you may check it explicitly like this:

    if p != nil {
        n = p.(*Node) // will not fail IF p really contains a value of type *Node

    Or better: use the special "comma-ok" form:

    // This will never fail:
    if n, ok := p.(*Node); ok {
    ", n)

    Using the "comma-ok" form:

    The value of ok is true if the assertion holds. Otherwise it is false and the value of n is the zero value for type T. No run-time panic occurs in this case.

    点赞 评论

相关推荐 更多相似问题