Golang variables: Difference between revisions
From wikinotes
Line 27: | Line 27: | ||
) | ) | ||
/ | </syntaxhighlight> | ||
// | 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 == | |||
<blockquote> | |||
<code>iota</code> will auto-increment the value of the assignment,<br> | |||
allowing you to use constants similar to an enum | |||
The type this constant takes is inferred based on the types it is used with. | |||
<syntaxhighlight lang="go"> | |||
const ( | |||
red = iota | |||
green | |||
blue | |||
) | |||
var color int = red // types within the group will be int now | |||
fmt.Println(red) // 0 | |||
fmt.Println(green) // 1 | |||
fmt.Println(blue) // 2 | |||
</syntaxhighlight> | |||
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 reserved as an error | |||
<syntaxhighlight lang="go"> | |||
// ex. | // ex. | ||
// const ( red = iota; green; blue ) | // const ( red = iota; green; blue ) | ||
// var i int | // var i int | ||
// i == red // returns true | // i == red // returns true <--- Not what we want!! | ||
const ( | const ( | ||
invalid = iota | invalid = iota | ||
Line 45: | Line 72: | ||
) | ) | ||
</syntaxhighlight> | </syntaxhighlight> | ||
</blockquote><!-- iota --> | |||
</blockquote><!-- Constants --> | </blockquote><!-- Constants --> | ||
Revision as of 18:40, 29 May 2022
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"
Constants
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 enumThe type this constant takes is inferred based on the types it is used with.
const ( red = iota green blue ) var color int = red // types within the group will be int now fmt.Println(red) // 0 fmt.Println(green) // 1 fmt.Println(blue) // 2
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 reserved as an error// ex. // const ( red = iota; green; blue ) // var i int // i == red // returns true <--- Not what we want!! const ( invalid = iota red green blue )
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
Mutability
Mutable
- Arrays - Maps - Channels - StructsImmutable
- Interfaces - Booleans - Numeric Types - Strings - Pointers