Multiple switch cases

Switch cases can be separated by coma:

    func shouldEscape(c byte) bool {
        switch c {
        case ' ', '?', '&', '=', '#', '+', '%':
            return true
            }
        return false
        }

Alternative to label

Get out of a for/select loop without using labels:

func main() {
 
OUT:
    for {
        select {
        case ... ):
            ...
        default:
            break OUT
        }
    }
    ....
}

Refactoring out the for loop:

func main() {
    ...
    doSomething()
    ...
}

func doSomething() {
    for {
        select {
        case ...:
            ...
        default:
            return
        }
    }
}

Basic dependency management

To install all the dependencies of a package:

$ go list -f '{{ join .Imports "\n" }}' | xargs go get

TestMain in go 1.4 testing module

Provide setup and teardow to your test with g0 1.4 testing module:

 
func setUp() {

  ...

}

 

func tearDown() {

  ...

}

func TestMain(m *testing.M) {

     setUp()

     r := m.Run()

     tearDown() // cannot run tearDown in a defer because of os.Exit

  os.Exit(r)

} 

func TestFoo(t *testing.T) { 
  ...

}

 

func TestBar(t *testing.T) { 
  ...

}

Exiting carefully

os.Exit() terminates immediately and deferred functions are not run.

Notes on expressions

Expressions

"x |= y" is equivalent to "x = x | y", just like "x += y" is equivalent to "x = x + y".

 Same for &= .

Check interface implementation

- Check if a variable implements a given interface and obtain the variable in the context of that interface:

m, ok := val.(json.Marshaler)


-For example:

 if _, ok := val.(json.Marshaler); ok {
        fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
    }

Select For and Loops

- The canonical way to block indefinitely is an empty select statement:
  select{}

- While canonical way to loop indefinitely is an empty for statement:
  for{}

Trim strings

- To remove final nulls from strings coming from a buffer:
 strings.TrimRight(myStringFromABuffer, "\x00")

- To remove new lines from string:
 strings.Trim(myString, "\r\n")

Go Channels Tips

- Read from an unbuffered channel:
  blocks (use select).

 - Write to an unbuffered channel:
   blocks.

 - Read from a buffered channel:
   blocks (use select).

 - Write to an buffered channel:
   non blocking as long as there is space left in the buffer.

 - Read from a closed channel:
   non blocking, always return the zero value of the channel type.
  
 - Write to a closed channel:
   panic: runtime error: send on closed channel

 - Read from a nil channel:
   blocks forever.

 - Write to a nil channel:
   blocks forever.