Bestimmen Sie den Typ des Schnittstellenwerts {}, der von einer Funktion in Golang zurückgegeben wird

Frageninhalt

Ich habe eine Funktion, die einen Wert aus einer Aufzählung zurückgibt. Die Aufzählung ist wie folgt definiert:

type DataType int64

const (
    INT DataType = iota
    FLOAT
    STRING
    BOOL
    CHAR
    VOID
    ERROR
    BREAK
    CONTINUE
)

    func (l *TSwiftVisitor) VisitWhileInstr(ctx *parser.WhileInstrContext) interface{} {        
    if condExpression.ValType == BOOL {             
        condResult := condExpression.asBool()       
        for condResult {            
            for _, currentInstr := range ctx.InstrList().AllInstr() {
                execResult := l.Visit(currentInstr)
                fmt.Printf("TYPE -> %T\n", execResult) // Prints exec.DataType (the type)
                fmt.Printf("VALUE -> %v\n", execResult) // Prints 5 (the enum value)
                if execResult == BREAK { // This never executes
                    fmt.Println("Es break")
                    return VOID
                } else { // This executes
                    fmt.Println("Es otra mierda")
                }
            }           
            condResult = l.Visit(ctx.Expr()).(*Expression).asBool()
        }       
    } else {
        return ERROR
    }
    return VOID
}

Die Signatur der Visit-Methode lautet wie folgt

Visit(tree antlr.ParseTree) interface{}

Nach dem Aufruf der Methode erhalte ich einen Wert vom Typ DataType und gebe den Typ und den Rückgabewert in den folgenden Zeilen aus.

fmt.Printf("TYPE -> %T\n", execResult) // Prints exec.DataType (the type)
fmt.Printf("VALUE -> %v\n", execResult) // Prints 5 (the enum value)

Die Ausgabe ist wie folgt:

TYPE -> exec.DataType                   
VALUE -> 5

Soweit so gut, aber ich muss vergleichen und das ist mein Problem, dass ich nicht viel über Golang weiß. Ich habe Folgendes:

if execResult == BREAK { // This never executes
    fmt.Println("It's a break")
    return VOID
} else { // This executes
    fmt.Println("It's another thing")
}

Hier weiß ich nicht, wie ich mit der Validierung des Rückgabetyps fortfahren soll. Wenn ich die folgenden Zeilen versuche, führe ich nie den gewünschten Code aus, der in diesem Fall darin besteht, VOID zurückzugeben. Meine Frage ist, wie man die Rückgabetypen vergleicht, um basierend auf dem Ergebnis eine bestimmte Aktion auszuführen. Ich habe auch Folgendes versucht:

switch execResult.(type) {
    case DataType:
        if execResult.(DataType) == BREAK {

            return execResult
        }
}

In diesem Fall ist auch die Situation im Schalter nicht zufriedenstellend. Meine Frage ist im Grunde, wie man den Typ des von einem Funktionsaufruf zurückgegebenen Interface{}-Werts bestimmt.

Richtige Antwort

Ich denke, @Charlie Tumahai hat Recht: Das Problem ist eine Diskrepanz zwischen den Werten. Ich habe ein kleines Beispiel auf dem Go Playground ausprobiert und es funktioniert wie erwartet: Wenn DataType 是从 Visit 返回，然后与 DataType der Vergleich wahr sein kann.

Der zurückgegebene Typ muss sein DataType 类型。 Visit2 方法演示了这一点：它返回一个 int64，它永远不会等于 BREAK.

Dies wird in der

Go Programming Language Specification unter Vergleichsoperatoren beschrieben:

package main

import "fmt"

type DataType int64

const (
    INT DataType = iota
    BREAK
    CONTINUE
)

func Visit() interface{} { return BREAK }
func Visit2() interface{} {return int64(BREAK) }

func main() {
    for _, x := range []interface{}{Visit(), Visit2()} {
        fmt.Printf("x = %v, T(x) = %T : ", x, x)
        if x == BREAK {
            fmt.Println("x is BREAK")
        } else {
            fmt.Println("Cannot identify x")
        }
    }

    // Output:
    // x = 1, T(x) = main.DataType : x is BREAK
    // x = 1, T(x) = int64 : Cannot identify x
}

Das obige ist der detaillierte Inhalt vonBestimmen Sie den Typ des Schnittstellenwerts {}, der von einer Funktion in Golang zurückgegeben wird. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!