web-dev-qa-db-fra.com

Format float en golang html/template

Je veux formater la valeur float64 à 2 décimales dans golang html/template dire dans le fichier index.html. Dans le fichier .go, je peux formater comme ceci:

strconv.FormatFloat(value, 'f', 2, 32)

Mais je ne sais pas comment le formater dans un modèle. J'utilise le framework gin-gonic/gin pour le backend. Toute aide serait appréciée. Merci.

goformatgo-html-template
10
Bhavana

Vous avez plusieurs options:

  • Vous pouvez décider de formater le nombre, par exemple. utiliser fmt.Sprintf() avant de le transmettre à l'exécution du modèle (n1)
  • Ou vous pouvez créer votre propre type en définissant la méthode String() string, en le formatant à votre guise. Ceci est vérifié et utilisé par le moteur de template (n2).
  • Vous pouvez également appeler printf directement et explicitement à partir du modèle et utiliser une chaîne de format personnalisée (n3).
  • Même si vous pouvez appeler directement printf, cela nécessite de passer au format string. Si vous ne voulez pas le faire à chaque fois, vous pouvez enregistrer une fonction personnalisée faisant exactement cela (n4)

Voir cet exemple:

type MyFloat float64

func (mf MyFloat) String() string {
    return fmt.Sprintf("%.2f", float64(mf))
}

func main() {
    t := template.Must(template.New("").Funcs(template.FuncMap{
        "MyFormat": func(f float64) string { return fmt.Sprintf("%.2f", f) },
    }).Parse(templ))
    m := map[string]interface{}{
        "n0": 3.1415,
        "n1": fmt.Sprintf("%.2f", 3.1415),
        "n2": MyFloat(3.1415),
        "n3": 3.1415,
        "n4": 3.1415,
    }
    if err := t.Execute(os.Stdout, m); err != nil {
        fmt.Println(err)
    }
}

const templ = `
Number:         n0 = {{.n0}}
Formatted:      n1 = {{.n1}}
Custom type:    n2 = {{.n2}}
Calling printf: n3 = {{printf "%.2f" .n3}}
MyFormat:       n4 = {{MyFormat .n4}}`

Sortie (essayez-le sur Go Playground ):

Number:         n0 = 3.1415
Formatted:      n1 = 3.14
Custom type:    n2 = 3.14
Calling printf: n3 = 3.14
MyFormat:       n4 = 3.14
16
icza

Utilisez la fonction printftemplate intégrée avec le "%.2f" format:

tmpl := template.Must(template.New("test").Parse(`The formatted value is = {{printf "%.2f" .}}`))

tmpl.Execute(os.Stdout, 123.456789)

Go Playground

5
dolmen

Vous pouvez enregistrer une FuncMap.

package main

import (
    "fmt"
    "os"
    "text/template"
)

type Tpl struct {
    Value float64
}

func main() {
    funcMap := template.FuncMap{
        "FormatNumber": func(value float64) string {
            return fmt.Sprintf("%.2f", value)
        },
    }

    tmpl, _ := template.New("test").Funcs(funcMap).Parse(string("The formatted value is = {{ .Value | FormatNumber  }}"))

    tmpl.Execute(os.Stdout, Tpl{Value: 123.45678})
}

Cour de récréation

2
Nadh

Edit: je me suis trompé en arrondissant/tronquant.

Le problème avec le formatage %.2f est qu’il ne arrondit pas mais tronque.

J'ai développé une classe décimale basée sur int64 pour gérer l'argent, qui traite les flottants, l'analyse des chaînes, JSON, etc.

Il stocke le montant sous la forme d'un nombre entier de 64 bits. Peut être facilement créé à partir de float ou reconverti en float.

Pratique pour stocker dans DB également. 

https://github.com/strongo/decimal

package example

import "github.com/strongo/decimal"

func Example() {
    var amount decimal.Decimal64p2; print(amount)  // 0

    amount = decimal.NewDecimal64p2(0, 43); print(amount)  // 0.43
    amount = decimal.NewDecimal64p2(1, 43); print(amount)  // 1.43
    amount = decimal.NewDecimal64p2FromFloat64(23.100001); print(amount)  // 23.10
    amount, _ = decimal.ParseDecimal64p2("2.34"); print(amount)  // 2.34
    amount, _ = decimal.ParseDecimal64p2("-3.42"); print(amount)  // -3.42
}

Fonctionne bien pour mon application de suivi des dettes https://debtstracker.io/

0
Alexander Trakhimenok