i := 123
s := string(i)
s is 'E', but what I want is "123"
Please tell me how can I get "123".
10 Answers
Use the strconv package's Itoa function.
For example:
package main
import (
"strconv"
"fmt"
)
func main() {
t := strconv.Itoa(123)
fmt.Println(t)
}
answered Apr 11, 2012 at 12:33
Klaus Byskov Pedersen
122k31 gold badges191 silver badges223 bronze badges
16 Comments
Luke
Why did the language designers think that cryptic functions names like "Itoa" were preferable to something that might be a little more descriptive?
Bryan
@luke it comes from the C heritage where the entire machine might have 256K memory; usability was sacrificed to fit more functionality in. The creators of Go are all deeply embedded in that heritage and feel entirely comfortable with these names.
Luke
Putting history above accessibility and ease of learning is bad design IMO. :(
Nathron
@Luke Depends on who your target users are and how strong the convention is. Some UIs still have a floppy disk as the Save icon :)
Ivan Aracki
for easy remembering name ItoA - Integer to ASCII
|
fmt.Sprintf("%v",value);
If you know the specific type of value use the corresponding formatter for example %d for int
More info - fmt
5 Comments
Ricardo Souza
I would not recommend this, as this is far less efficient than other conversion methods because it uses reflection.
Himanshu
But if you don't know the specific type, Sprintf is the way to go.
vaibhav3027
I heard the implementation of sprintf in c to parse a json file was the reason GTA's online mode used to take around 14 minutes to start. An Indie dev pointed it out and the load time got all the way down to ~1.5 minutes
Torsten Bronger
fmt.Sprint is simpler.
Jasmeet Singh
@RicardoSouza I agree
fmt.Sprintf, strconv.Itoa and strconv.FormatInt will do the job. But Sprintf will use the package reflect, and it will allocate one more object, so it's not an efficient choice.
1 Comment
Eric
And
strconv.FormatUint() for uint64 -> stringIt is interesting to note that strconv.Itoa is shorthand for
func FormatInt(i int64, base int) string
with base 10
For Example:
strconv.Itoa(123)
is equivalent to
strconv.FormatInt(int64(123), 10)
1 Comment
isapir
Interesting to note that calling FormatInt() directly instead of Itoa() saves 0.1 nanosecond according to the benchmark at stackoverflow.com/a/38077508/968244
You can use fmt.Sprintf or strconv.FormatFloat
For example
package main
import (
"fmt"
)
func main() {
val := 14.7
s := fmt.Sprintf("%f", val)
fmt.Println(s)
}
Comments
In this case both strconv and fmt.Sprintf do the same job but using the strconv package's Itoa function is the best choice, because fmt.Sprintf allocate one more object during conversion.
check the benchmark here: https://gist.github.com/evalphobia/caee1602969a640a4530
see https://play.golang.org/p/hlaz_rMa0D for example.
3 Comments
Edward
@Boon In visible impact to your app? As always - it depends. Another object means one more object, beyond the obvious temporary small memory hit, needs to be garbage collected. If you are calling the function at high rates, for example as part of some serialization process used whenever a message is received from somewhere, it could have a significant impact. Since
fmt.Sprintf and strconv.iota are similar in terms of ease of use and the above data shows iota to be faster with lower GC impact, it appears that iota should be used in general when a single integer needs converting.
Boon
Seems like premature optimization to me to be thinking at this level so soon. Best is to write readable code first.
sudo
@Boon They're equally readable. Might as well use the faster one. Also, what's to say a new Golang programmer isn't starting with something that does lots of these conversions? I'm an experienced programmer writing my first Golang code right now and am in that situation.
Another option:
package main
import "fmt"
func main() {
n := 123
s := fmt.Sprint(n)
fmt.Println(s == "123")
}
1 Comment
guettli
Thank you very much. This is the a convenient and easy to remember solution (my point of view).
Converting int64:
n := int64(32)
str := strconv.FormatInt(n, 10)
fmt.Println(str)
// Prints "32"
Comments
ok,most of them have shown you something good. Let'me give you this:
// 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 ""
}
}
package main
import (
"fmt"
"strconv"
)
func main(){
intValue := 123
// keeping it in separate variable :
strValue := strconv.Itoa(intValue)
fmt.Println(strValue)
}
strconv.Itoa(i)(int to ASCII) to set an int to a string. See stackoverflow.com/a/62737936/12817546.strconv.Atoi(s)(ASCII to int) to set a string to an int. See stackoverflow.com/a/62740786/12817546.