Table of contents
Variable
A variable is a symbolic name given to the storage location which contains some value that can be changed at any time during the execution of the program. A variable must be defined with the type of data or value it is holding.
Data types
There are several data types in Go.
bool int uint float32 complex64
string int8 uint8 float64 complex128
byte int16 uint16
rune int32 uint32
error int64 uint64
Zero value
In some programming languages variable holds a null
or undefined
value when not initialized, Go gives it a zero value of its data type. A boolean
variable if not initialized, get the false
value and an integer
variable gets 0
value, string
variable will get ""
(empty) value.
Declaring a variable
The var
the statement declares a list of variables. The type is at the last of the statement.
var varName dataType
E.g.:
var i, j, k int
var f float32
var u uint
Variables with initializers
We can initialize variables while declaring.
var varName dataType = value
var i int = 10
var s string = "hello"
var ok bool = true
We can omit the type of variable, it will take the type of initializers
var i = 42 // int
var f = 3.142 // float64
var g = "hello" // string
Short-hand declaration
This is the most commonly used variable declaration inside functions.
varName := value
E.g.:
i := 10
s := "hello"
ok := true
When declaring a variable without specifying it’s type the variable’s type is inferred from the value on the right-hand side.
var i int
j := i // j is an int
i := 42 // int
f := 3.142 // float64
g := 0.867 + 0.5i // complex128
Assign or Re-assign
You can assign or re-assign value to a declared variable as:
varName = value
E.g.:
i = 12
s = "world"
ok = false
Multiple variable declarations
Multiple variables of the same type with the single var statement
var i, j, k int
var x, y, z = 0.867 + 0.5i, 4.65, true
Multiple variables of the different types with the single var statement
var (
i int = 10
s string = "hello"
ok bool = true
)
Constants
Go supports constants of character, string, boolean, and numeric values. Constants are declared using the const
keyword.
E.g:
const str string = "constants"
Untyped and Typed
Constants can be declared with or without a type in Go. If we are declaring a literal constant, then we are declaring constants that are untyped and unnamed.
E.g.:
const str string = "constants" //Typed constant
const i = 10 //Untyped constant, literal declaration
const f = 3.14
The constants on the LHS of the declaration are named constants and the literal values on the RHS are unnamed constants.
Typed constants don’t use the same type system as variables, they've their implementation for representing the values that we associate with them.
In the case of a typed constant, the declared type is used to associate the type’s precision limitations or kind of constant.
In the case of an untyped constant, the literal value will determine what kind/type the constant takes
Every GO compiler has the flexibility to implement constants as they wish, within the mandatory set of requirements.
Thank you for reading this blog, and please give your feedback in the comment section below.