Golang strconv.ParseBool
last modified April 20, 2025
This tutorial explains how to use the strconv.ParseBool function in Go.
We'll cover string-to-boolean conversion basics with practical examples.
The strconv.ParseBool function converts a string to a boolean value. It's commonly used for parsing boolean input from various sources.
ParseBool recognizes "1", "t", "T", "true", "TRUE", "True" as true and "0", "f", "F", "false", "FALSE", "False" as false. Other values return an error.
Basic strconv.ParseBool Example
The simplest use of strconv.ParseBool converts a boolean string to
a bool value. Here we demonstrate successful conversion and error handling.
package main
import (
"fmt"
"strconv"
)
func main() {
boolStr := "true"
b, err := strconv.ParseBool(boolStr)
if err != nil {
fmt.Println("Conversion error:", err)
return
}
fmt.Printf("String '%s' converted to boolean %t\n", boolStr, b)
}
We convert the string "true" to a boolean. The error is checked to handle cases where conversion fails. Successful conversion prints the boolean value.
Handling Different True/False Values
strconv.ParseBool accepts multiple string representations of boolean
values. This example shows various valid inputs.
package main
import (
"fmt"
"strconv"
)
func main() {
trueValues := []string{"1", "t", "T", "true", "TRUE", "True"}
falseValues := []string{"0", "f", "F", "false", "FALSE", "False"}
for _, tv := range trueValues {
b, _ := strconv.ParseBool(tv)
fmt.Printf("%-6s → %t\n", tv, b)
}
for _, fv := range falseValues {
b, _ := strconv.ParseBool(fv)
fmt.Printf("%-6s → %t\n", fv, b)
}
}
We test all valid string representations of true and false. The output shows how each string maps to its corresponding boolean value.
Handling Invalid Boolean Strings
strconv.ParseBool returns an error for invalid boolean strings.
This example demonstrates proper error handling.
package main
import (
"fmt"
"strconv"
)
func main() {
testCases := []string{"yes", "no", "on", "off", "y", "n", "", "2"}
for _, tc := range testCases {
b, err := strconv.ParseBool(tc)
if err != nil {
fmt.Printf("'%s' is not a valid boolean: %v\n", tc, err)
} else {
fmt.Printf("'%s' converted to %t\n", tc, b)
}
}
}
We test various invalid string inputs. The error message helps identify why conversion failed for each invalid input.
Converting User Input
A common use case is converting command-line arguments or user input. This example demonstrates reading and converting boolean values from standard input.
package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
reader := bufio.NewReader(os.Stdin)
fmt.Print("Enter a boolean (true/false, 1/0, t/f): ")
input, _ := reader.ReadString('\n')
input = strings.TrimSpace(input)
b, err := strconv.ParseBool(input)
if err != nil {
fmt.Println("Please enter a valid boolean value")
return
}
fmt.Printf("You entered: %t (negated: %t)\n", b, !b)
}
We read user input, trim whitespace, then attempt conversion. The program provides feedback for invalid input and demonstrates using the converted value.
Working with Configuration Files
ParseBool is often used when reading boolean values from configuration files. This example shows a typical configuration parsing scenario.
package main
import (
"fmt"
"strconv"
)
func main() {
config := map[string]string{
"debug_mode": "true",
"enable_cache": "1",
"verbose_logs": "F",
"dark_mode": "false",
}
debug, _ := strconv.ParseBool(config["debug_mode"])
cache, _ := strconv.ParseBool(config["enable_cache"])
verbose, _ := strconv.ParseBool(config["verbose_logs"])
dark, _ := strconv.ParseBool(config["dark_mode"])
fmt.Println("Debug mode:", debug)
fmt.Println("Cache enabled:", cache)
fmt.Println("Verbose logging:", verbose)
fmt.Println("Dark mode:", dark)
}
We simulate reading from a configuration map and converting values to booleans. Different string formats are used to demonstrate ParseBool's flexibility.
Performance Considerations
For performance-critical code, avoiding repeated conversions can help. This example benchmarks ParseBool against alternatives.
package main
import (
"fmt"
"strconv"
"strings"
"time"
)
func main() {
const iterations = 1000000
testStr := "true"
// Benchmark ParseBool
start := time.Now()
for i := 0; i < iterations; i++ {
strconv.ParseBool(testStr)
}
fmt.Println("ParseBool duration:", time.Since(start))
// Benchmark custom function
start = time.Now()
for i := 0; i < iterations; i++ {
strings.ToLower(testStr) == "true"
}
fmt.Println("Custom check duration:", time.Since(start))
}
ParseBool is more robust than simple string comparison but slightly slower. The difference is usually negligible for most use cases.
Practical Example: Feature Flags
This practical example demonstrates using ParseBool to implement feature flags from environment variables with proper error handling.
package main
import (
"fmt"
"os"
"strconv"
)
func main() {
flags := map[string]string{
"NEW_UI": "1",
"EXPERIMENT_X": "false",
"BETA_FEATURES": "t",
}
for name, value := range flags {
enabled, err := strconv.ParseBool(value)
if err != nil {
fmt.Printf("Invalid value for %s: %s\n", name, value)
continue
}
if enabled {
fmt.Printf("Feature %s is enabled\n", name)
} else {
fmt.Printf("Feature %s is disabled\n", name)
}
}
}
We simulate feature flags from environment variables. Each flag's value is converted to a boolean, with proper error handling for invalid values.
Source
Go strconv package documentation
This tutorial covered the strconv.ParseBool function in Go with
practical examples of string-to-boolean conversion in various scenarios.
Author
List all Go tutorials.