Comment convertir une valeur int en chaîne dans Go?

486
i := 123
s := string(i) 

s est 'E', mais ce que je veux c'est "123"

Veuillez me dire comment obtenir "123".

Et en Java, je peux faire de cette façon:

String s = "ab" + "c"  // s is "abc"

comment puis-je concatdeux chaînes dans Go?

hardPass
la source
La deuxième question (concaténation de chaînes) a une réponse ailleurs qui couvre l'efficacité.
RedGrittyBrick

Réponses:

772

Utilisez la fonction strconvdu package Itoa.

Par exemple:

package main

import (
    "strconv"
    "fmt"
)

func main() {
    t := strconv.Itoa(123)
    fmt.Println(t)
}

Vous pouvez concaténer des chaînes simplement en +les utilisant ou en utilisant la Joinfonction du stringspaquet.

Klaus Byskov Pedersen
la source
97
Pourquoi les concepteurs de langage ont-ils pensé que les noms de fonctions cryptiques comme "Itoa" étaient préférables à quelque chose qui pourrait être un peu plus descriptif?
Luke
25
@luke il vient de l'héritage C où la machine entière peut avoir 256K de mémoire; l'utilisabilité a été sacrifiée pour intégrer plus de fonctionnalités. Les créateurs de Go sont tous profondément ancrés dans cet héritage et se sentent parfaitement à l'aise avec ces noms.
Bryan
117
Mettre l'histoire au-dessus de l'accessibilité et de la facilité d'apprentissage est une mauvaise conception de l'OMI. :(
Luke
32
@Luke Dépend de qui sont vos utilisateurs cibles et de la force de la convention. Certaines interfaces utilisateur ont toujours une disquette comme icône Enregistrer :)
Nathron
65
pour se souvenir facilement du nom ItoA - Entier à ASCII
Ivan Aracki
139
fmt.Sprintf("%v",value);

Si vous connaissez le type spécifique de valeur, utilisez le formateur correspondant, par exemple %dpourint

Plus d'infos - fmt

Jasmeet Singh
la source
%dpour int - ce
scniro
4
Je ne recommanderais pas cela, car c'est beaucoup moins efficace que les autres méthodes de conversion car il utilise la réflexion.
Ricardo Souza
49

Il est intéressant de noter que strconv.Itoaest un raccourci pour

func FormatInt(i int64, base int) string

avec base 10

Par exemple:

strconv.Itoa(123)

est équivalent à

strconv.FormatInt(int64(123), 10)
kgthegreat
la source
non défini: strconv dans strconv.Itoa
Felo Vilches
1
@FeloVilches import "strconv"
kgthegreat
3
Il est intéressant de noter que l'appel à FormatInt () directement au lieu d'Itoa () permet d'économiser 0,1 nanoseconde selon le benchmark sur stackoverflow.com/a/38077508/968244
isapir
43

fmt.Sprintf, strconv.Itoaet strconv.FormatIntfera le travail. Mais Sprintfutilisera le package reflect, et il allouera un objet de plus, ce n'est donc pas un choix efficace.

entrez la description de l'image ici

Bryce
la source
22

Dans ce cas , les deux strconvet fmt.Sprintffaire le même travail , mais en utilisant le strconvde package Itoafonction est le meilleur choix, car fmt.Sprintfallouer un objet de plus lors de la conversion.

vérifier le résultat de référence des deux vérifiez l'indice de référence ici: https://gist.github.com/evalphobia/caee1602969a640a4530

voir https://play.golang.org/p/hlaz_rMa0D par exemple.

manigandand
la source
1
@Boon Dans un impact visible sur votre application? Comme toujours - cela dépend. Un autre objet signifie qu'un autre objet, au-delà du petit coup de mémoire temporaire évident, doit être récupéré. Si vous appelez la fonction à des taux élevés, par exemple dans le cadre d'un processus de sérialisation utilisé chaque fois qu'un message est reçu de quelque part, cela peut avoir un impact significatif. Étant donné que fmt.Sprintfet strconv.iotasont similaires en termes de facilité d'utilisation et que les données ci-dessus montrent que l'iota est plus rapide avec un impact GC moindre, il semble queiota devrait être utilisé en général lorsqu'un seul entier doit être converti.
Edward
Cela me semble être une optimisation prématurée de penser à ce niveau si tôt. Le mieux est d'écrire d'abord du code lisible.
Boon
@Boon Ils sont également lisibles. Autant utiliser le plus rapide. En outre, que dire d'un nouveau programmeur Golang ne commençant pas par quelque chose qui fait beaucoup de ces conversions? Je suis un programmeur expérimenté qui écrit mon premier code Golang en ce moment et je suis dans cette situation.
sudo
9

Conversion int64:

n := int64(32)
str := strconv.FormatInt(n, 10)

fmt.Println(str)
// Prints "32"
Cae Vecchi
la source
3

ok, la plupart d'entre eux vous ont montré quelque chose de bien. Laissez-moi vous donner ceci:

// ToString Change arg to string
func ToString(arg interface{}, timeFormat ...string) string {
    if len(timeFormat) > 1 {
        log.SetFlags(log.Llongfile | log.LstdFlags)
        log.Println(errors.New(fmt.Sprintf("timeFormat's length should be one")))
    }
    var tmp = reflect.Indirect(reflect.ValueOf(arg)).Interface()
    switch v := tmp.(type) {
    case int:
        return strconv.Itoa(v)
    case int8:
        return strconv.FormatInt(int64(v), 10)
    case int16:
        return strconv.FormatInt(int64(v), 10)
    case int32:
        return strconv.FormatInt(int64(v), 10)
    case int64:
        return strconv.FormatInt(v, 10)
    case string:
        return v
    case float32:
        return strconv.FormatFloat(float64(v), 'f', -1, 32)
    case float64:
        return strconv.FormatFloat(v, 'f', -1, 64)
    case time.Time:
        if len(timeFormat) == 1 {
            return v.Format(timeFormat[0])
        }
        return v.Format("2006-01-02 15:04:05")
    case jsoncrack.Time:
        if len(timeFormat) == 1 {
            return v.Time().Format(timeFormat[0])
        }
        return v.Time().Format("2006-01-02 15:04:05")
    case fmt.Stringer:
        return v.String()
    case reflect.Value:
        return ToString(v.Interface(), timeFormat...)
    default:
        return ""
    }
}
fwhez
la source
0
package main

import (
    "fmt" 
    "strconv"
)

func main(){
//First question: how to get int string?

    intValue := 123
    // keeping it in separate variable : 
    strValue := strconv.Itoa(intValue) 
    fmt.Println(strValue)

//Second question: how to concat two strings?

    firstStr := "ab"
    secondStr := "c"
    s := firstStr + secondStr
    fmt.Println(s)
}
Sagiruddin Mondal
la source