Zero-initialization

Zero-initialization is a source of confusion sometimes. They are default values for many types that are assigned even if you don't provide a value for the definition. Following are the zero-initialization for various types:

• The false initialization for bool type.
• Using 0 values for int type.
• Using 0.0 for float type.
• Using "" (empty strings) for string type.
• Using nil keyword for pointers, functions, interfaces, slices, channels and maps.
• Empty struct for structures without fields.
• Zero-initialized struct for structures with fields. The zero value of a structure is defined as the structure that has its fields initialized as zero value too.

Zero-initialization is important when programming in Go because you won't be able to return a nil value if you have to return an int type or a struct. Keep this in mind, for example, in functions where you have to return a bool value. Imagine that you want to know if a number is divisible by a different number but you pass 0 (zero) as the divisor.

func main() { 
    res := divisibleBy(10,0) 
    fmt.Printf("%v\n", res) 
} 
 
func divisibleBy(n, divisor int) bool { 
    if divisor == 0 { 
        //You cannot divide by zero 
        return false 
    } 
 
    return (n % divisor == 0) 
} 

The output of this program is false but this is incorrect. A number divided by zero is an error, it's not that 10 isn't divisible by zero but that a number cannot be divided by zero by definition. Zero-initialization is making things awkward in this situation. So, how can we solve this error? Consider the following code:

func main() { 
    res, err := divisibleBy(10,0) 
    if err != nil { 
log.Fatal(err) 
    } 
 
    log.Printf("%v\n", res) 
} 
 
func divisibleBy(n, divisor int) (bool, error) { 
    if divisor == 0 { 
        //You cannot divide by zero 
        return false, errors.New("A number cannot be divided by zero") 
    } 
 
    return (n % divisor == 0), nil 
} 

We're dividing 10 by 0 again but now the output of this function is A number cannot be divided by zero. Error captured, the program finished gracefully.