Go Concepts - The Type System: Difference between revisions
Line 10: | Line 10: | ||
For more details on typing, see [[Programming#Static_Typing_vs_Dynamic_Typing|static typing vs. dynamic typing]] and [[Programming#Strong_Typing_vs_Loose_Typing|strong typing vs. loose typing]]. | For more details on typing, see [[Programming#Static_Typing_vs_Dynamic_Typing|static typing vs. dynamic typing]] and [[Programming#Strong_Typing_vs_Loose_Typing|strong typing vs. loose typing]]. | ||
Go provides a ''hierarchy-free'' type system - there are no classes and no class inheritance. It is still an object-oriented language. | |||
=Type Definition= | =Type Definition= |
Revision as of 06:03, 2 April 2016
Internal
Overview
Go is statically typed. Go designers tried to alleviate some of the "heaviness" associated with statically typed languages and made it "feel" like a dynamic language. For example Go uses local type inference, which eliminates the need to specify the type unnecessarily in program, the compiler figures it out.
Go is strongly typed meaning that yes cannot be unsafely coerced into other types they're not, or at least without programmer giving explicit permission. In JavaScript, for example, implicit conversion is done based on complicated rules that are not always easy to remember.
For more details on typing, see static typing vs. dynamic typing and strong typing vs. loose typing.
Go provides a hierarchy-free type system - there are no classes and no class inheritance. It is still an object-oriented language.
Type Definition
Zero Value
Zero value for a specific type: 0 for ints, 0.0 for floats, "" for strings, false for Booleans and nil for pointers. For reference types, their underlying data structures are initialized to their zero values.
Built-in Types
The definition of the following types can be found in $GO_HOME/src/builtin/builtin.go:
bool
Integers
Floating-Point Numbers
string
Arrays
Slices
Maps
error
Function Types
A function is member of a function type. The function type is defined by its signature:
func(input_param_type1, input_param_type2, ...) (return_type1, return_type2, ...)
Example of a function that requires an int and returns an int:
func(int) int
// a variable of type func(int) int is declared var f func(int) int; // the variable is initialized with an actual function f = func(i int) int { return i + 1 }
Also see:
Pointer Types
A pointer type is declared using the dereference operator * placed in front of the target type - the type of the stored value:
*int
We cannot do pointer arithmetic. Assuming ptr is a *int, we cannot do ptr + 1 (compilation error message: invalid operation: ptr + 1 (mismatched types *int and int)) and we can't do ptr + ptr2 (compilation error message: invalid operation: ptr + ptr2 (operator + not defined on pointer)).
For more details, see pointers.
User-Defined Types
The user-defined types are introduced by the type keyword. There are two kinds of user-defined types: structs and interfaces.
Structs
Interfaces
Conversion Between Types
In order to convert between types, the type name is used like a function:
var f float64 = 5.0 var i int = 5 ... result = f / float64(i)
This is equivalent with Java cast.
Also see: