
This post covers converting (cast) String type to float type or float type to String with an example.
Golang strconv package
The string is a group of characters referenced by a variable. A float is a numeric number that stores a set of all IEEE-754 64-bit floating-point numbers.
Both are of different types, and automatic conversions will not occur.
The developer needs to write a code to handle this.
Golang provides a standard inbuilt package strconv
to do string conversions to other types.
It is a common task of the developer to convert String to float or float to String.
How to Convert String to float in Golang?
strconv
package provides ParseFloat
function to convert to float numeric types.
You can check more about this function here
Here is syntax
func ParseFloat(s string, bitSize int) (float64, error)
arguments are
The string is an input string. if a given string is not numeric, It gives error strconv.ParseFloat: parsing “abc”: invalid syntax
bisize is of int type with values 32 or 64.
Here is a strconv ParseFloat function example program
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
floatString := "587.23"
floatNumb, err := strconv.ParseFloat("abc", 32)
fmt.Println(floatNumb)
fmt.Println(reflect.TypeOf(floatNumb))
fmt.Println(err)
if n1, err := strconv.ParseFloat(floatString, 32); err == nil {
fmt.Printf("%T, %v\n", n1, n1)
}
if n2, err := strconv.ParseFloat(floatString, 64); err == nil {
fmt.Printf("%T, %v\n", n2, n2)
}
}
An output of the above program
0
float64
strconv.ParseFloat: parsing "abc": invalid syntax
float64, 587.22998046875
float64, 587.23
Convert float number to String example
There are two ways to convert float type to String type.
- One, is using fmt.Sprintf() function
- Another way, is using strconv.FormatFloat function
fmt Sprintf function example
fmt
package provides Sprintf
is used to convert to string.
Here is a syntax
func Sprintf(format string, a ...interface{}) string
the format is a string
%f - Decimal format
%e - scientific notation format
%.5f- the precision with 5 format
%g - exponent format
and parameter a is of the vardiac interface that accepts any value type.
Here is an fmt Sprintf function example program
package main
import (
"fmt"
"reflect"
)
func main() {
str := fmt.Sprintf("%f", 45.1) //45.100000
fmt.Println(reflect.TypeOf(str))
fmt.Println(str)
str1 := fmt.Sprintf("%e", 45.1) //4.510000e+01
fmt.Println(reflect.TypeOf(str1))
fmt.Println(str1)
str2 := fmt.Sprintf("%.5f", 45.1) //45.10000
fmt.Println(reflect.TypeOf(str2))
fmt.Println(str2)
str3 := fmt.Sprintf("%g", 45.1) //45.1
fmt.Println(reflect.TypeOf(str3))
fmt.Println(str3)
}
Output:
string
45.100000
string
4.510000e+01
string
45.10000
string
45.1
strconv FormatFloat function example
strconv
package has FormatFloat
function convert the floating number to string with a given format and precision.
Here is a syntax of this function
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
Arguments are
the floating number converted to a string
fmt is of byte contains values b -binary exponent, e or E - Decimal exponent, F - no exponent, g or G - a large exponents
prec is of int precision value
bitSize is of int type that contains 32 and 64 values.
Here is a strconv FormatFloat function example program
package main
import (
"fmt"
"reflect"
"strconv"
)
func main() {
floatNumb := 5.789455
str := strconv.FormatFloat(floatNumb, 'f', 5, 64)
fmt.Println(reflect.TypeOf(str))
fmt.Println(str)
str1 := strconv.FormatFloat(floatNumb, 'e', 5, 64)
fmt.Println(reflect.TypeOf(str1))
fmt.Println(str1)
str2 := strconv.FormatFloat(floatNumb, 'g', 5, 64)
fmt.Println(reflect.TypeOf(str2))
fmt.Println(str2)
}
Output is
string
5.78946
string
5.78946e+00
string
5.7895