golang

Golang Bool to String Examples

In Go (Golang), working with Boolean values is a common task. Sometimes, we might need to translate a Boolean value into its string equivalent. This article guides us through the process of converting a Boolean to a string using different approaches in the Go programming language. We will explore the standard method using the “strconv” package, “fmt” package, as well as an alternative method to utilize a map and if-else statment.

Example 1: Golang Bool to String Using the FormatBool() Method

Specifically, we may use the strconv.FormatBool() function from the “strconv” library to transform a Boolean value into a string representation.

Take a look at the following example where the FormatBool() function is used.

package main
import (
  "fmt"
  "reflect"
  "strconv"
)
func main() {
  boolValue := true
  strValue := strconv.FormatBool(boolValue)
  fmt.Println(strValue)
 fmt.Println("The type of string value is:", reflect.TypeOf(strValue))
}

In the previous program, the “strconv” package is imported to convert the Boolean to the string. There, we also defined another package which is “reflect” to retrieve the type of the resulting string. We established the “boolValue” variable of type “bool” which is initialized with the “true” value. We then created another variable which is “strValue” of type “string” that converts the Boolean value.

We setup this variable with the strconv.FormatBool function which stores the “boolValue” inside it as an argument. The strconv.FormatBool() function converts a Boolean value to its corresponding string representation: “true” for true and “false” for false. The string value is “true” in this instance since the “boolValue” is true. Lastly, we used the reflect.TypeOf()function to obtain the type information of the “strValue”.

Since the “strValue” is string, the output displays the typed string as follows:

Example 2: Golang Bool to String Using the Fmt.Sprintf() Method

Additionally, the fmt.Sprintf() function in Go also allows us to transform the Boolean values to strings using the the%v verb and generate the value in accordance with its default format. Consider the working of the Sprintf() function:

package main
import (
    "fmt"
)
func main() {
    b1 := true
    s1 := fmt.Sprintf("%v", b1)
    fmt.Printf("Type : %T \nValue : %v\n\n", s1, s1)   
    b2 := false
    s2 := fmt.Sprintf("%v", b2)
    fmt.Printf("Type : %T \nValue : %v\n", s2, s2)
}

In the given program, we defined a variable “b1” and assigned the Boolean value of “true” where it represents a true condition. After that, we employed the fmt.Sprintf() function which converts the Boolean value of “b1” to a string using the “%v” format specifier. This format specifier is a general placeholder that represents the value in its default format. We stored the resulting value in the “s1” variable.

The fmt.Printf() function is then called to print the type and value of “s1” to the console. The “%T” format specifier here is used to print the type, and “%v” is used to print the value. Then, we also declared the Boolean variable of “b2” with the value of “false”. Here, it represents a false condition. Similarly, we deployed the fmt.Sprintf() function to convert the Boolean value of “b2” to a string using the “%v” format specifier and the resulting string is stored in the “s2” variable.

The output shows that both “s1” and “s2” have a “string” type. For “s1”, the value is true. While for “s2”, the value is false:

Example 3: Golang Bool to String Using If-Else Statement

Moreover, we can manually examine the Boolean value and give its associated string representation if we want to convert a Boolean value in Go to a string using an if-else expression.

package main
import "fmt"
func main() {
    boolIs := false
    stringIs := func() string {
        if boolIs {
            return "true"
        }
        return "false"
    }()
    fmt.Println(stringIs)
}

The given program creates the “boolIs” variable with the Boolean value of “false”. Then, we declared the “stringIs” variable as an anonymous function for a string result. This function is immediately invoked by adding () after its definition. Inside the anonymous function, an “if” statement checks the value of “boolIs”. The function returns “true” if the given scenario is true. It provides the “false” string in the absence of that. Then, we specified the “stringIs” variable to be a function that provides a string anonymously.

The condition returns the Bool false as the string value of false in the following output:

Example 4: Golang Bool to String Using the Map Method

However, if we specifically want to use the “map” method, we can define a map that maps the Boolean values to their corresponding string representations. Here’s the map program to convert the Bool to a string.

package main
import "fmt"
func main() {
    bool1 := true
    bool2 := false
    boolToString := map[bool]string{
        true:  "true",
        false: "false",
    }
    trueStr := boolToString[bool1]
    falseStr := boolToString[bool2]
    fmt.Println(trueStr)  
    fmt.Println(falseStr)
}

In the given program, the two boolean variables, “bool1” and “bool2”, are declared and assigned with the Boolean values of true and false, respectively. Then, we setup the “boolToString” map with Bool as the key type and string as the value type. It maps the Boolean values to their string representations. After that, the “boolToString” map is initialized with two key-value pairs: The “true” key is mapped to the “true” string, while the “false” key is mapped to the “false” string. Next, we defined the “trueStr” and “falseStr” variables which are assigned with the values that are obtained from the “boolToString” map using the Boolean variables of “bool1” and “bool2”, respectively.

Using a map lookup, the output displays the conversion of Boolean values to their corresponding string representations:

Example 5: Golang String to Bool Using the ParseBool() Method

The prior examples are all transformations of Bool to string type. Here, we use the ParseBool() method to parse a string into the Bool type. The Boolean value that the string represents is returned by the ParseBool() method. The program is given in the following to convert the string to Bool using the ParseBool() function:

package main
import "fmt"
import "strconv"
func main() {
    var MyStr string = "false"
    var MyBool bool = true

    MyBool, err := strconv.ParseBool(MyStr)
    if err != nil {
        panic(err)
    } else {
        fmt.Println("Result: ", MyBool)
    }
}

In the given program, we declared a “MyStr” variable of type string and assigned it with the “false” value. Then, a bool-type variable named “MyBool” with the “true” value as its initial value is given. Next, we used the strconv.ParseBool() function to parse the string representation of a Boolean value that is stored in “MyStr”. The result of the parsing is assigned to the “MyBool” variable, and any error that is encountered during parsing is assigned to the “err” variable.

The output generates the results where the “false” string is parsed into a Boolean value:

Conclusion

Many Go applications frequently need to transform a Boolean value into a string representation. Here, we discussed the approaches that are useful in transforming the Boolean type into a “string” type. Apart from these examples, we also demonstrated the method to transform the string to the Bool type.

About the author

Kalsoom Bibi

Hello, I am a freelance writer and usually write for Linux and other technology related content