Show Menu

Golang Naming Conventions Cheat Sheet by [deleted]

A quick reference guide for idiomatic, non-idiomatic and abbreviation conventions in golang.

Why naming is important?

Critical for Readab­ility = Mainta­ina­bility
The naming is important because it is very critical for readab­ility and if you can't read the code, you can't properly maintain it.

Imagine a book that you don't unders­tand, and someone comes to you and asks you to fix the typos in it.

Can you really do it, without unders­tanding it?
There are only two hard things in Computer Science:
cache invali­dation and naming things.
- Phil Karlton


func Read(buffer *Buffer, inBuffer []byte) (size int, err error) {
        if buffer.empty() {
        size = copy(
        buffer.offset += size
        return size, nil
This code is unnece­ssarily verbose. Everything has been declared in English words, which generally should be avoided. From the readab­ility and mainta­ina­bility perspe­ctive, this code is not good.


func Read(b *Buffer, p []byte) (n int, err error) {
        if b.empty() {
        n = copy(p, b.buf[]) += n
        return n, nil
This code is very concise and idiomatic and it's easy to understand and maintain.


Use the first few letters of the words

var fv string // flag value

Use fewer letters in smaller scopes

var bytesRead int // number of bytes read
var n int // number of bytes read

Use the complete words in larger scopes

package file
var fileClosed bool
Imagine that this variable is declared in the package block of the  file  package.

It's a package level variable and therefore it's in a larger scope. Don't use abbrev­iations there and don't mix caps in the name. file  starts with a lowercase letter.

Use mixedCaps like this

type playerScore struct

Use all caps for acronyms

var localApi string
var localAPI string

Do not stutter


Do not use under_­scores oR LIKE_THIS

const MAX_TIME int
const MaxTime int
const N int

Abbrev­iation - Rules

Abbrev­iations should be pronou­nceable.

Abbrev­iations should have at least one vowel.

Abbrev­iations should not split up plosiv­e/l­iquid combin­ations but as plosiv­e/p­losive, for example, the  ct in dictionary or pt in caption.

Abbrev­iations should not have more than three consonants in a row and should usually end in a consonant, unless the vowel is needed for discri­min­ation, for example, alg and algo.

All of the letters in the abbrev­iation should be present in the long form and in the same order, and need not appear in sequence in the long form, for example, recv and receive.

There are a few exceptions to the above rules for common, well-e­sta­blished forms.

ct and pt can be used for ction and ption if the abbrev­iation would be too short otherwise, for example, act and opt.

There are also other types of prefixing, for example, the three-­letter prefixes used to distin­guish field names in the same database table.

Examples would include cusID for customer ID and ordID for order ID.

Those prefixes don't need to follow the same rules.

Length­/Me­aning and Interp­ret­ation
An abbrev­iation should be less than or equal to half the length of the original form.

Abbrev­iations should be at least three letters long.

Abbrev­iations should not be whole words that mean something else.

Abbrev­iations should not just consist of the prefix of a word, for example, sym for symbol or syl for syllable.

Abbrev­iations shouldn't be ambiguous. However, if the names are different that no confusion can result, they are OK.


var a int
// array
var arg []string
// argument
var b []byte
// buffer
var b byte
// byte
var bs bytes
// bytes
var buf []byte
// buffer
var c int
// capacity
var c int
// character
var dst int
// destination
var err error
// error value
var fv string
// flag value
var i int
// index
var l int
// length
var m int
// another number
var msg string
// message
var n int
// number or number of
var num int
// number
var off int
// offset
var op int
// operation
var parsed bool
// parsed ok?
var pkg string
// package
var pos int
// position
var r rune
// rune
var r io.Reader
// reader
var s string
// string
var seen bool
// has seen?
var sep string
// separator
var src int
// source
var str string
// string
var v string
// value
var val string
// value
var w io.Writer
// writer
...the list goes on and on...


No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

          GoLang fmt Printing Cheat Sheet
          GoLang Cheat Sheet