Golang variables

Assignment

// declare and assign variable
var name string
name = "foo"

// declare and assign var in one step
var name string = "foo"

// declare and assign variable, inferring type
name := "foo"

Scope

// global variables are defined outside of functions
foo_global := "bar"

// local variables defined in functions
func main() {
    foo_local := "bar"
}

go supports closures (although to be async friendly, it is recommended to explicitly pass params)

func main() {
    a := 123
    func() {
        fmt.Println("value of a:", a)
    }
}

Type Conversion

float32(123) == 123.        // cast int as float32
string(107) == "k"          // retrieve char for 107 in ascii chart
strconv.Itoa(107) == "107"  // represent 107 as string

Introspection

fmt.Prinf("%T\n", myVar)   // print type of myVar

Constants

Basics

const myVar := "hi"       // variable that cannot be reassigned
const MyVar := "hi"       // exported variable, that cannot be reassigned

const myVar = 2           // infer constant type

const (                   // group constant assignment
    name string = "foo"
    age int = 123
)

There are some rules for constant:

• Constants cannot be assigned at runtime (ex. the result of a function). They must be static at compile time.
• Constants must be assigned a immutable type (ex. collections are mutable, so they cannot be constants)
• Inner scopes can declare the same constant with a new value. It will superseed the outer constant's value while working within that scope.
• If inferring a constant, it's type may take on the type of an operation it is used with. (likely best to explicitly declare type)

iota

iota will auto-increment the value of the assignment,
allowing you to use constants similar to an enum

The type this constant takes is inferred based on the types it is used with.

const (
    red = iota  // 0 (because var usage below)
    green       // 1
    blue        // 2
)

var color int = red  // types within the group will be int now

Since the type here is inferred, comparing a variable with no value to the first entry will return true. for this reason, the first const in a iota group is generally discarded or used as an error value.

// ex.
//   const ( red = iota; green; blue )
//   var i int
//   i == red // returns true   <--- Not what we want!!
const (
    _ = iota  // this is our trash value -- it's inaccessible
    red   // 1 (if with assignment as int)
    green // 2
    blue  // 3
)

Set iota initial-value

const (
    _ = iota + 10
    red   // 11
    green // 12
    blue  // 13
)

Assignment Patterns (ex. unit increases)

const (
    _ = iota
    KB = 1 << (10 * iota)  // 1024
    MB                     // 1024^2
    GB                     // 1024^3
)

Permission Bitmasks

const (
  r = 1 << iota  // 0b001
  w              // 0b010
  x              // 0b100
)

userPermissions := read | write
if (userPermissions & read) {
    fmt.Println("user can read file!")
}

Mutability

Mutable

- Arrays
- Maps
- Channels
- Structs

Immutable

- Interfaces
- Booleans
- Numeric Types
- Strings
- Pointers