Detail DataTypes In Golang you should know 2019

In Detail DataTypes in Golang By Sagar Jaybhay

---

• Part 1 – https://sagarjaybhay.net/google-go-tutorial-by-sagar-jaybhay-blog-1/
• Part 2- https://sagarjaybhay.net/packages-and-golang-command-part-2/

---

The data types specify the data which is valid Go Variable. In Go programming language data types divided into 4 different categories.

Basic Data Type: basic data types are categorized into 3 different types

• Numbers
• Booleans
• String

Number DataType in Go Language

DATA TYPE	DESCRIPTION
int8	8-bit signed integer
int16	16-bit signed integer
int32	32-bit signed integer
int64	64-bit signed integer
uint8	8-bit unsigned integer
uint16	16-bit unsigned integer
uint32	32-bit unsigned integer
uint64	64-bit unsigned integer
int	Both in and uint contain the same size, either 32 or 64 bit.
uint	Both in and uint contain the same size, either 32 or 64 bit.
rune	It is a synonym of int32 and also represent Unicode code points.
byte	It is a synonym of int8.
uintptr	It is an unsigned integer type. Its width is not defined, but it can hold all the bits of a pointer value.

Floating Point Number

This is used to store numbers with a decimal component. Go language has 2 types of floating-point which are float32 and float64.

The default values of floating point s float64. What is means? When you initialize variable with without specifying type then the variable is referred to as float64.

var a=3214.567

Operations on Numeric Types

Go provides several operators for performing operations on numeric types.

• Arithmetic Operators: +, -, *, /, %
• Comparison Operators: ==, !=, <, >, <=, >=
• Bitwise Operators: &, |, ^, <<, >>
• Increment and Decrement Operators: ++, —
• Assignment Operators: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=

Booleans in Golang

Go language provides bool data type which stores a Boolean value and it has only 2 different values true and false.

Operations on Boolean data types

• && (logical and)
• || (logical or)
• !     (negation)

Complex numbers

The complex numbers are one of the basic data types. It also has 2 different sizes complex64 and complex128

Complex64- has real and imaginary part of float32

Complex128: has a real and imaginary part of float64

var v= 4+7i;

If you want to create a complex number then go language has a built-in complex function for creating a complex number.

var a = 10.11
var b = 22.33

// var c = a + bi won't work. Create a complex number like this -
var c = complex(a, b)

both real and imaginary parts of complex numbers must be the same floating-point type.

But if you try to create a complex number with different real and imaginary part types then it will throw an error.

Operations on complex numbers:  it is addition, subtraction, multiplication, and division.

Strings datatype in golang

It is a sequence of bytes. We can declare a string with double-quotes. If string enclosed in double-quotes then they can have escape character like \n, \t. this escaped character replaced with newline and tab space.

If you enclosed string with backtick then this string treated as a raw string.

Number.go file

package utilitypackage

import (
    "fmt"
    "reflect"
)

var Name string = "sagar"

func CreateDataTypes() {
    a := 10
    b := true
    c := 12.144
    d := "Sagar Jaybhay"
    e := complex(3.7, 4.8)

    fmt.Println(reflect.TypeOf(b), b)
    fmt.Println(reflect.TypeOf(a), a)
    fmt.Println(reflect.TypeOf(c), c)
    fmt.Println(reflect.TypeOf(d), d)

    fmt.Println(reflect.TypeOf(e), e)
}

Main.go file

package main

import (
    "fmt"

    "./utilitypackage"
)

func main() {

    //fmt.Println(utilitypackage.Reverse("sagar"))
    utilitypackage.CreateDataTypes()
    
    fmt.Println(utilitypackage.Name)

}

Point to remember whenever you want to access something outside of file your First letter of variable or function should be capital.

Formating the value:

The package fmt implements formatted I/ O.

Refer link https://golang.org/pkg/fmt/

For example:

%v	the value in a default format
	when printing structs, the plus flag (%+v) adds field names
%#v	a Go-syntax representation of the value
%T	a Go-syntax representation of the type of value
%%	a literal percent sign; consumes no value

Boolean

%t	the word true or false

Integer

%b	base 2
%c	the character represented by the corresponding Unicode code point
%d	base 10
%o	base 8
%O	base 8 with 0o prefix
%q	a single-quoted character literal safely escaped with Go syntax.
%x	base 16, with lower-case letters for a-f
%X	base 16, with upper-case letters for A-F
%U	Unicode format: U+1234; same as "U+%04X"

Floating-point and complex constituents:

%b	decimal less scientific notation with exponent a power of two,
	in the manner of strconv.FormatFloat with the 'b' format,
	e.g. -123456p-78
%e	scientific notation, e.g. -1.234456e+78
%E	scientific notation, e.g. -1.234456E+78
%f	decimal point but no exponent, e.g. 123.456
%F	synonym for %f
%g	%e for large exponents, %f otherwise. The precision is discussed below.
%G	%E for large exponents, %F otherwise
%x	hexadecimal notation (with decimal power of two exponent), e.g. -0x1.23abcp+20
%X	upper-case hexadecimal notation, e.g. -0X1.23ABCP+20

String and slice of bytes (treated equivalently with these verbs):

%s	the uninterpreted bytes of the string or slice
%q	a double-quoted string safely escaped with Go syntax
%x	base 16, lower-case, two characters per byte
%X	base 16, upper-case, two characters per byte

Slice

%p	address of 0th element in base 16 notation, with leading 0x

Pointer

%p	base 16 notation, with leading 0x
The %b, %d, %o, %x and %X verbs also work with pointers,
formatting the value exactly as if it were an integer.

The default format for %v is:

bool:                    %t
int, int8 etc.:          %d
uint, uint8 etc.:        %d, %#x if printed with %#v
float32, complex64, etc: %g
string:                  %s
chan:                    %p
pointer:                 %p

For compound objects, the elements are printed using these rules, recursively, laid out like this:

struct:             {field0 field1 ...}
array, slice:       [elem0 elem1 ...]
maps:               map[key1:value1 key2:value2 ...]
pointer to above:   &{}, &[], &map[]

Number.go file

package utilitypackage

import (
    "fmt"
)

// this name field is used in the main package
var Name string = "sagar"

// This CreateDataTypes called in main function
func CreateDataTypes() {
    a := 10
    b := true
    c := 12.144
    d := "Sagar Jaybhay"
    e := complex(3.7, 4.8)

    fmt.Printf("%v \t", a)
    fmt.Printf("%v \t ", b)
    fmt.Printf("%v \t", c)
    fmt.Printf("%v \t", d)
    fmt.Printf("%v \t", e)

    fmt.Println("\n-------------------------------------------------")

    fmt.Printf("%T \t", a)
    fmt.Printf("%T \t ", b)
    fmt.Printf("%T \t", c)
    fmt.Printf("%T \t", d)
    fmt.Printf("%T \t", e)
}

Main.go file

package main

import (
    "fmt"

    "./utilitypackage"
)

func main() {

    //fmt.Println(utilitypackage.Reverse("sagar"))
    utilitypackage.CreateDataTypes()

    fmt.Println("\n called in main ", utilitypackage.Name)

}

GitHubg Project Link :- https://github.com/Sagar-Jaybhay/GoLanguageLab