Go supports many elementary data types, including int, bool, int32, and float64. One of the most obvious points where the language specification diverges from the familiar C/Java syntax is where, in the declaration syntax, the declared name appears before the type. For example, consider the following snippet:
var count int
It declares a count variable of the integer type (int). When the type of a variable is unambiguous from the initial value, then Go offers a shorted variable declaration syntax pi := 3.14.
It's important to note the language is strongly typed, so the following code, for example, would not compile:
var a int = 10
var b int32 = 20
c := a + b
One unique data type in Go is the error type. It's used to store errors, and there is a helpful package called errors for working with the variables of this type:
err := errors.New("Some Error")
if err != nil {
fmt.Print(err)
}
Go, like C, gives the programmer control over pointers. For example, the following code denotes the layout of a point structure and a pointer to a Point Struct:
type Point Struct {
X, Y int
}
Go also supports compound data structures, such as string, map, array, and slice natively. The language runtime handles the details of memory management and provides the programmer with native types to work with:
var a[10]int // an array of type [10]int
a[0] = 1 // array is 0-based
a[1] = 2 // assign value to element
var aSlice []int // slice is like an array, but without upfront sizing
var ranks map[string]int = make(map[string]int) // make allocates the map
ranks["Joe"] = 1 // set
ranks["Jane"] = 2
rankOfJoe := ranks["Joe"] // get
string s = "something"
suff := "new"
fullString := s + suff // + is concatenation for string
Slices are internally handled as Struct, with fields defining the current start of the memory extent, the current length, and the extent.