Use the 'comma, ok' idiom for type assertions to safely handle cases when the assertion fails. Only use a single-value type assertion (which panics on failure) if you are absolutely sure (by prior checks or program logic) that the interface holds the correct type.
If a type assertion is wrong, it causes a run-time panic. By using the two-value form (`value, ok := iface.(Type)`), your code can gracefully handle a bad type instead of crashing. This is especially important when dealing with interfaces like `interface{}` or `json.Unmarshalled` data where the type isn't guaranteed.
Side-by-side examples engineers can pattern-match during review.
var x interface{} = getValue()
// Assuming x should be a string, but not checking
s := x.(string) // will panic if x isn't a stringvar x interface{} = getValue()
s, ok := x.(string)
if !ok {
return fmt.Errorf("unexpected type: %T", x)
}
// use s safely as a stringvar x interface{} = getValue()
// Assuming x should be a string, but not checking
s := x.(string) // will panic if x isn't a stringvar x interface{} = getValue()
s, ok := x.(string)
if !ok {
return fmt.Errorf("unexpected type: %T", x)
}
// use s safely as a stringFrom the same buckets as this rule.
Check if loops use equality operators (== or !=) in termination conditions. These can lead to infinite loops if the condition is never met exactly. Instead, use relational operators like < or > for safer loop termination.