Golang variables
From wikinotes
Process Variables
Call 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
float32(123) == 123. // cast int as float32 string(107) == "k" // retrieve char for 107 in ascii chart strconv.Itoa(107) == "107" // represent 107 as stringIntrospection
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 - StructsImmutable
- Interfaces - Booleans - Numeric Types - Strings - Pointers