Déterminer le type de valeur d'interface {} renvoyée par une fonction dans Golang

Contenu de la question

J'ai une fonction qui renvoie une valeur à partir d'une énumération. L'énumération est définie comme suit :

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
}

La signature de la méthode Visite est la suivante

Visit(tree antlr.ParseTree) interface{}

Après avoir appelé la méthode, je reçois une valeur de type DataType et j'imprime le type et la valeur de retour dans les lignes suivantes.

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

Le résultat est le suivant :

TYPE -> exec.DataType                   
VALUE -> 5

Jusqu'ici tout va bien, mais je dois faire une comparaison et c'est le problème que j'ai, que je ne connais pas grand-chose à Golang. J'ai ce qui suit :

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

C'est là que je ne sais pas comment procéder pour valider le type de retour, si j'essaye les lignes suivantes je n'exécute jamais le code que je veux, qui dans ce cas est de renvoyer VOID. Ma question est de savoir comment comparer les types de retour pour effectuer une action spécifique en fonction du résultat. J'ai également essayé ce qui suit :

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

            return execResult
        }
}

Dans ce cas, la situation à l'intérieur du commutateur n'est pas non plus satisfaite. Ma question est essentiellement de savoir comment déterminer le type de valeur interface{} renvoyée par un appel de fonction.

Bonne réponse

Je pense que @Charlie Tumahai a raison : le problème est une inadéquation des valeurs. J'ai essayé un petit exemple sur le Go Playground et cela fonctionne comme prévu : si DataType 是从 Visit 返回，然后与 DataType la comparaison peut être vraie.

Le type renvoyé doit être DataType 类型。 Visit2 方法演示了这一点：它返回一个 int64，它永远不会等于 BREAK.

Ceci est décrit dans la

Spécification du langage de programmation Go sous Opérateurs de comparaison :

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
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!