Golang variables

Documentation

new()	https://go.dev/doc/effective_go#allocation_new
make()	https://go.dev/doc/effective_go#allocation_make

Allocation

There are two keywords for allocating memory.

new(MyType)  // allocate memory without initialization, return pointer (works for any type)
make(MyType) // for slice/map/channel only, allocates/initializes, returns instance

Process Variables

Commandline Parameters

commandline arguments are stored in os.Args

for _, arg := range os.Args[1:] {
    switch arg {
    case "-h", "--help":
        // .. print help
    case "-v", "--verbose":
        // .. enable verbose logging
    }
}

Environment Variables

import "os"

path, err := os.LookupEnv("HOME")  // "/home/will"
err := os.SetEnv("FOO", "BAR")
vars = os.Environ()                // ["FOO=BAR", "BAR=BAZ", ...]

Go 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)
    }
}

Exported symbols (functions, variables) begin with a capital letter.
this means they can be used by files that import this package.

Foo := "bar"
func MyPublicFunc() { ... }

Exported symbols from packages defined within an internal/ directory are only exported within your go module.
Consumers of your go module and it's packages will not have access to these symbols.

Type Conversion

general

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

strings

strconv.Itoa(107) == "107"  // represent 107 as string

interfaces and concretions

// cast var typed as interface,
// to it's concretion (so you can use it's methods)
var foo MyInterface
foo = MyConcretion{}
castFoo := foo.(MyConcretion)

// cast var typed as interface,
// whose concretion has pointer methods
// to it's concretion (so you can use it's methods)
var foo MyInterface
foo = MyConcretion{}
castFoo := foo.(*MyConcretion)

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

See enums in golang datatypes

Mutability

Mutable

- Arrays
- Maps
- Channels
- Structs

Immutable

- Interfaces
- Booleans
- Numeric Types
- Strings
- Pointers