Short variable declarations

August 16, 2023

Yesterday we saw how to define variables with var, but if you’ve ever actually used Go, you probably know that’s not actually the most common way to define variables. Let’s take a look at the alternative…

Short variable declarations

A short variable declaration uses the syntax:

ShortVarDecl = IdentifierList ":=" ExpressionList .

It is shorthand for a regular variable declaration with initializer expressions but no types:

"var" IdentifierList "=" ExpressionList .
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
_, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate

So in other words, you can use the := assignment operator as a shorthand for certain uses of var. We saw some great examples above, but let me expand on them by showing what the longhand form of each would look like, for direct comparsion.

i, j := 0, 10    // Shorthand
var i, j = 0, 10 // Long form

f := func() int { return 7 }
var f = func() int { return 7 }

ch := make(chan int)
var ch = make(chan int)

r, w, _ := os.Pipe()
var r, w, _ = os.Pipe()

_, y, _ := coord(p)
var _, y, _ = coord(p)

Simple, eh? Notably, and as mentioned in the spec quoted above, there’s no option to specify a type in the variable declaration this way. Although you can git around this in some cases, by specifying the type on the right hand side:

i := int(3)

Tomorrow we’ll look at some of the other implications, and limitations, of the short variable declaration.

Quotes from The Go Programming Language Specification Version of August 2, 2023

Share this

Related Content

No short declarations at package level

A couple last points about short variable declarations before we move on… Short variable declarations … Short variable declarations may appear only inside functions. In some contexts such as the initializers for “if”, “for”, or “switch” statements, they can be used to declare local temporary variables. So first: package foo id := 1 // Invalid. Short declarations only possible within fucntions var id = 1 // But this is valid. Don’t ask me why this rule exists.

Short variable declarations, cont'd

Today we’ll look at one of the most interesting, and I would say, confusing, aspects of short variable declarations. Short variable declarations … Unlike regular variable declarations, a short variable declaration may redeclare variables provided they were originally declared earlier in the same block (or the parameter lists if the block is the function body) with the same type, and at least one of the non-blank variables is new. As a consequence, redeclaration can only appear in a multi-variable short declaration.

Unused variables

Variable declarations … Implementation restriction: A compiler may make it illegal to declare a variable inside a function body if the variable is never used. One short sentence. And people either love it, or hate it. I’m in the “love it” camp, but some people like the option to create unused variables, for later use, or during debugging. func foo() error { var i int // Some commented out code that probably used i // .