❮❮ PREV NEXT ❯❯

GO - NUMBERS

As we have seen in the 'Data Types' topic, there are three types of Numbers supported by Go. Integers, floating point numbers and complexs numbers.

Integers
Integers are the whole numbers (i.e. 7 or 5).

Any whole number(Be it '-4' or '45') can be represented by the 'int' datatype

Let us see it below :
1. int Data Type
  
  The 'Data Type' for a whole number is 'int'.
  Example :
```
package main
import "fmt"

func main() {
          
    var x int = 5
    fmt.Println(x) 
}	
```
  Output :
  
  5
  
  Although the 'int' data type is capable of storing all types of numbers, i.e. A very large number or a small number or a negative number.
  
  But don't you think, it would be a lot better, if we could have different data types for different types of numbers.
  
  And luckily, Go has that.
  
  Let us see them below :
2. uint8 Data Type
  
  The 'uint8' Data Type represents, unsigned 8 bit integers. i.e. It would store numbers from 0 to 255.
  
  Now, if you break 'uint8' datatype,
  
  'u' - Unsigned, i.e. No negative numbers would be allowed.
  
  'int' - It would hold an integer.
  
  '8' - Stores an '8' bit number.
  
  So, if you combine all the three (i.e. 'u', 'int' & '8'), it is a datatype, 'uint8' that stores an unsigned 8 bit integer.
  
  Note : For now you don't have to understand, what a 8 bit number is. Just remember the range(i.e. 0 to 255) and that would be enough.
  
  Anything values other than 0 to 255 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x uint8 = 35
    fmt.Println(x) 
}	
```
  Output :
  
  35
  
  So, in the above example, we have created a variable 'x' of type 'uint8'. And assigned the value '35' to it.
  
  And since '35' falls in the range of 0 to 255, '35' is inserted to x.
  
  Now, what if, we try to insert a value that is other than the range of 0 to 255. Say, 456.
  Example :
```
package main
import "fmt"

func main() {
          
    var x uint8 = 456
    fmt.Println(x) 
}
```
  Output :
  
  constant 456 overflows uint8
  
  And we get the error message that 'constant 456 overflows uint8'.
  
  This actually means that the value '456' doesn't belongs in the range of 0 to 255. And cannot be inserted to the variable 'x'.
3. uint16 Data Type
  
  The 'uint16' Data Type represents, unsigned 16 bit integers. i.e. It would store numbers from 0 to 65535.
  
  Anything values other than 0 to 65535 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x uint16 = 54364
    fmt.Println(x) 
}
```
  Output :
  
  54364
  
  So, in the above example, we have created a variable 'x' of type 'uint16'. And assigned the value '54364' to it.
  
  And since '54364' falls in the range of 0 to 65535, '54364' is inserted to x.
4. uint32 Data Type
  
  The 'uint32' Data Type represents, unsigned 32 bit integers. i.e. It would store numbers from 0 to 4294967295.
  
  Anything values other than 0 to 4294967295 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x uint32 = 645738765
    fmt.Println(x) 
}
```
  Output :
  
  645738765
5. uint64 Data Type
  
  The 'uint64' Data Type represents, unsigned 64 bit integers. i.e. It would store numbers from 0 to 18446744073709551615.
  
  Anything values other than 0 to 4294967295 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
            
    var x uint64 = 8765432876509876567
    fmt.Println(x) 
}	
```
  Output :
  
  8765432876509876567
6. int8 Data Type
  
  The 'int8' Data Type represents, signed 8 bit integers. i.e. It would store numbers from -128 to 127.
  
  Since, it is a signed data type, it can store negative numbers as well.
  
  Anything values other than -128 to 127 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
            
    var x int8 = -125
    fmt.Println(x) 
}
    
```
  Output :
  
  -125
  
  So, in the above example, we have created a variable 'x' of type 'int8'. And assigned the value '-125' to it.
  
  And since '-125' falls in the range of -128 to 127, '-125' is inserted to x.
7. int16 Data Type
  
  The 'int16' Data Type represents, signed 16 bit integers. i.e. It would store numbers from -32768 to 32767.
  
  Anything values other than -32768 to 32767 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x int16 = -24364
    fmt.Println(x) 
}
```
  Output :
  
  -24364
8. int32 Data Type
  
  The 'int32' Data Type represents, signed 32 bit integers. i.e. It would store numbers from -2147483648 to 2147483647.
  
  Anything values other than -2147483648 to 2147483647 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x int32 = -243435664
    fmt.Println(x) 
}
```
  Output :
  
  -243435664
9. int64 Data Type
  
  The 'int64' Data Type represents, signed 32 bit integers. i.e. It would store numbers from -9223372036854775808 to 9223372036854775807.
  
  Anything values other than -9223372036854775808 to 9223372036854775807 would result in an error.
  Example :
```
package main
import "fmt"

func main() {
          
    var x int64 = -223372036854775808
    fmt.Println(x) 
}
```
  Output :
  
  -22337203685477580
float Data Type

There are two types of 'Data Type' for a floating point number.

They are :
1. float32 Data Type
  
  The 'float32' Data Type represents, 32 bit floating point number.
  Example :
```
package main
import "fmt"

func main() {
          
    var x float32 = 5.987
    fmt.Println(x) 
}	
```
  Output :
  
  5.987
  
  So, in the above example, we have created a variable 'x' of type 'float32'. And assigned the value '5.987' to it.
2. float64 Data Type
  
  The 'float64' Data Type represents, 64 bit floating point number. In simple words, it stores a floating point number which is a little large.
  Example :
```
package main
import "fmt"

func main() {
          
    var x float64 = 5.9875532556
    fmt.Println(x) 
}
```
  Output :
  
  5.9875532556
complex Data Type

In Mathematics, you can find lots of formulas where there is a real and an imaginary part.

Say, for example

x = 2 + 5i

Where 'i' is the imaginary part.

To represent the complex numbers, there are two types of 'Data Type' for a complex numbers.

They are :
1. complex64 Data Type
  
  It supports Complex numbers with float32 as real and imaginary parts.
  Example :
```
package main
import "fmt"

func main() {
          
    var x complex64 = complex(2, 5)
    fmt.Println(x) 
}	
```
  Output :
  
  (2+5i)
  
  So, the expression,
  
  var x complex64 = complex(2, 5)
  
  Converts the number '2' and '5' to a complex expression.
  
  (2+5i)
2. complex128 Data Type
  
  It supports Complex numbers with floa64 as real and imaginary parts.
  Example :
```
package main
import "fmt"

func main() {
          
    var x complex128 = complex(6, 8)
    fmt.Println(x) 
}	
```
  Output :
  
  (6+8i)
  
  So, the expression,
  
  var x complex128 = complex(6, 8)
  
  Converts the number '6' and '8' to a complex expression.
  
  (6+8i)

❮❮ PREV NEXT ❯❯

GO - NUMBERS

Integers

int Data Type

Example :

Output :

uint8 Data Type

Example :

Output :

Example :

Output :

uint16 Data Type

Example :

Output :

uint32 Data Type

Example :

Output :

uint64 Data Type

Example :

Output :

int8 Data Type

Example :

Output :

int16 Data Type

Example :

Output :

int32 Data Type

Example :

Output :

int64 Data Type

Example :

Output :

float Data Type

float32 Data Type

Example :

Output :

float64 Data Type

Example :

Output :

complex Data Type

complex64 Data Type

Example :

Output :

complex128 Data Type

Example :

Output :