es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

pánico: conversión de interfaz: interface {} es string, no float64

05 Aug, 2023 Programación

Estoy tratando de convertir esta simple función de Python a Golang, pero estoy enfrentando problemas con este error.

def binance(crypto: str, currency: str):
    import requests

    base_url = "https://www.binance.com/api/v3/avgPrice?symbol={}{}"
    base_url = base_url.format(crypto, currency)

    try:
        result = requests.get(base_url).json()
        print(result)
        result = result.get("price")
    except Exception as e:
        return False

    return result

Aquí está la versión en Golang (código más largo y más complicado de lo que debería):

func Binance(crypto string, currency string) (float64, error) {
    req, err := http.NewRequest("GET", fmt.Sprintf("https://www.binance.com/api/v3/avgPrice?symbol=%s%s", crypto, currency), nil)
    if err != nil {
        fmt.Println("Error en req:", err)
    }

    client := &http.Client{}

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("error en enviar req:", err)
    }
    respBody, _ := ioutil.ReadAll(resp.Body)
    var respMap map[string]interface{}
    log.Printf("body=%v", respBody)
    json.Unmarshal(respBody, &respMap)
    log.Printf("response=%v", respMap)
    price := respMap["price"]
    log.Printf("price=%v", price)

    pricer, ok := price.(float64)
    if !ok {
        panic("Conversión de interfaz: interfaz {} es string, no float64")
    }

    return pricer, err
}

Entonces, ¿en qué me estoy equivocando aquí? Anteriormente, tenía el error cannot use price (type interface {}) as type float64 in return argument: need type assertion y ahora intenté la aserción de tipo con pricer := price.(float64) y ahora obtengo este error:

panic: interface conversion: interface {} is string, not float64
Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    El problema aquí es que el valor price devuelto desde la llamada a la API no siempre es de tipo float64. También puede ser de tipo string en algunos casos. Por lo tanto, cuando intentas afirmarlo a tipo float64 usando pricer := price.(float64), resulta en un error si el tipo real es string.

    Para solucionar esto, puedes usar una sentencia de tipo switch para manejar ambos casos:

    var pricer float64
switch v := price.(type) {
case float64:
    pricer = v
case string:
    var err error
    pricer, err = strconv.ParseFloat(v, 64)
    if err != nil {
        return 0, err
    }
default:
    return 0, fmt.Errorf("Valor de precio inesperado: %v", price)
}

    En este código, primero utilizamos una sentencia de tipo switch para determinar si price es de tipo float64 o string. Si es float64, podemos usarlo directamente. Si es string, utilizamos strconv.ParseFloat para convertirlo a float64. Si no es ninguno de estos tipos, devolvemos un error.

Comments are closed.