Nil in Go

What Is nil in Go

nil in Go has several meanings:

  • It represents “null” in Go. This means two things: 1. It does not have a type. 2. Its value is “null”.
  • It is a predeclared identifier in Go, which means you can use it without declaring it.
  • It represents zero values (and default values) of some types in Go, including interface types, pointer types, slice types, map types, channel types, function types.

Using nil as Zero Values

nil represents zero values (and default values) of some types in Go.


Using nil in Comparison

Two nil Values of Two Different Types Are Not Comparable


This code will fail to compile as they are trying to compare nil values of two different types.

Two nil Values of The Same Type May Not Be Comparable


Take var sb = (map[string]bool)(nil) == (map[string]bool)(nil) as an example, the reason why two nil values of the same type ( map[string]bool) are not comparable is because Go does not support comparison in slice, map, and function types. You can see that we are comparing two values of a non-comparable type in this case, thus causing the failure.

But the following code works and the results are true:

Take var sb = (map[string]bool)(nil) == nil as an example, (map[string]bool)(nil) declares a temporary variable map[string]bool which value is nil and (map[string]bool)(nil) == nil detects whether the variable's value is nil and then assigns the results to sb. You can see that we are comparing the value of a non-comparable type with its zero value (nil) in this case. That's why it works.

Two nil Values of The Same Type Can Be Comparable Only When This Type Supports Comparision


Be Careful in nil Comparison When Interface Values Are Involved

The following code will not cause any compiler failure but the result is false other than true.


  • An interface value consists of a dynamic type and a dynamic value. interface{}(nil) declares an interface value with {type: nil, value: nil}.
  • The non-interface value is converted to the type of the interface value before making the comparison with an interface value. In this example, (*int)(nil) is converted to an interface value with {type: *int, value: nil}.
  • Two nil interface values are equivalent only when they carry the same type. In this case, the converted interface value {type: *int, value: nil} has a concrete dynamic type but the other interface value has not. That is why the comparison result is false.

A more interesting example:


  • An interface value equals to nil only when its type and value are both `nil`. In this example, w is an io.Writer interface value with {type: *bytes.Buffer, value: nil} after the w=b assignment. Therefore, w==nil is false as it carries *byte.Buffer other than nil as its concrete dynamic type.


  • nil is and a pre-declared identifier that can be used to represent the zero values of some types in Go.
  • Be careful when using nil in comparison, especially when interface values are involved. You need to understand what you are comparing: types, or values, or both.
  • (a thing)(nil) may not equal to nil, depends on what that thing is (a pointer or an interface). This means nil is strong-typed even though nildoes not have a default type (sarcasm).




A software engineer

Love podcasts or audiobooks? Learn on the go with our new app.

Recommended from Medium

Using environment variables to control a dynamic Airflow DAG

REX: Progressive Web App

Everything I Needed to Know About Observability, I Learned from ‘Bewitched’

Everything I Needed to Know About Observability, I Learned from ‘Bewitched’

A guide to ruby

VoxEdit Beta Update #8 Now Live!

Roof final R2

Kubernetes: Env file to Config Maps and Secrets

TypeError: Can not create providesname index: database or disk is full

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Aaron Zhuo

Aaron Zhuo

A software engineer

More from Medium

Getting started with GO Programming Language — Part Two

[golang] How to use github for hosting self-updating binaries for your golang projects