ADVERTISEMENT
ADVERTISEMENT

Golang Data Types

Golang | Data Types: In this tutorial, we are going to learn about the different types of data types with examples in the Go language?
Submitted by IncludeHelp, on August 05, 2021

In any programming language, the data types are the important part of the programs, these are used to describe the type of the data. A data type tells the type of data that a Go variable can store. Memory for a variable is also created based on the data type.

Go language has many built-in data types which we will now read in more detail.

The Golang data types can be classified as follows –

  1. Basic Types
    1. Boolean Types
      1. true
      2. false
    2. Numeric Types
      1. Integer Types
      2. Floating Types
      3. Complex Types
    3. String Types
  2. Aggregate Types
    1. Arrays
    2. Structures
  3. Reference Types
    1. Pointers
    2. Slices
    3. Maps
    4. Functions
    5. Channels
  4. Interface Types

In this Golang Data Types tutorial, we will learn about the basic types only.

Golang Basic Types

The basic data types further divided into 3 categories,

  1. Boolean Types
  2. Numeric Types
  3. String Types

(a) Go Boolean Types

true and false are only two values that come under Boolean types, it represents only one bit of the information.

The bool keyword is used to declare a Boolean data type. And, its default value is false.

Example 1:

// Golang program to demonstrate the
// example of Boolean types

package main

import (
	"fmt"
)

func main() {
	// declaring Boolean variables
	var x bool = true
	var y bool = false
	var z bool // default value is false

	// printing the values
	fmt.Println("x = ", x)
	fmt.Println("y = ", y)
	fmt.Println("z = ", z)
}

Output:

x =  true
y =  false
z =  false

Example 2:

// Golang program to demonstrate the
// example of Boolean operations

package main

import (
	"fmt"
)

func main() {
	x := 10
	y := 20

	// printing the result and types
	fmt.Printf("Expression: (x == y), Result: %t, Result Type: %T\n", x == y, x == y)
	fmt.Printf("Expression: (x != y), Result: %t, Result Type: %T\n", x != y, x != y)
	fmt.Printf("Expression: (x < y),  Result: %t, Result Type: %T\n", x < y, x < y)
	fmt.Printf("Expression: (x > y),  Result: %t, Result Type: %T\n", x > y, x > y)
	fmt.Printf("Expression: (x <= y), Result: %t, Result Type: %T\n", x <= y, x <= y)
	fmt.Printf("Expression: (x >= y), Result: %t, Result Type: %T\n", x >= y, x >= y)
}

Output:

Expression: (x == y), Result: false, Result Type: bool
Expression: (x != y), Result: true, Result Type: bool
Expression: (x < y),  Result: true, Result Type: bool
Expression: (x > y),  Result: false, Result Type: bool
Expression: (x <= y), Result: true, Result Type: bool
Expression: (x >= y), Result: false, Result Type: bool

(b) Go Numeric Types

In Go language, numeric data types are,

  1. Integers
  2. Floating-Point Numbers
  3. Complex Numbers

(i) Integers

Both signed and unsigned integers types are available in the Go language. These types are available in 4 different sizes 8 bits, 16 bits, 32 bits, and 64 bits.

The integer types are –

Data Type Size Value Range
Signed
uint8 8 bits 0 to 255
uint16 16 bits 0 to 65535
uint32 32 bits 0 to 4294967295
uint64 64 bits 0 to 1844674407370955161
Unsigned
int8 8 bits -128 to 127
int16 16 bits -32768 to 32767
int32 32 bits -2147483648 to 2147483647
int64 64 bits -9223372036854775808 to 9223372036854775807
Others
byte 8 bits Synonyms of int8
int 32 bits or 64 bits based on the system architecture Signed integer value based on the size occupied.
uint 32 bits or 64 bits based on the system architecture Unsigned integer value based on the size occupied.
rune 32 bits Similar as int32, also represents Unicode code points.
uintptr Not defined Can store the uninterpreted bits of a pointer value.

Example:

// Golang program to demonstrate
// signed & unsigned integers

package main

import (
	"fmt"
)

func main() {
	// unsigned integers
	var a uint8 = 0
	var b uint16 = 0
	var c uint32 = 0
	var d uint64 = 0

	// signed integers
	var e int8 = -128
	var f int16 = -32768
	var g int32 = -2147483648
	var h int64 = -9223372036854775808

	fmt.Println("Minimum values....")
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
	fmt.Println("c = ", c)
	fmt.Println("e = ", e)
	fmt.Println("f = ", f)
	fmt.Println("g = ", g)
	fmt.Println("h = ", h)

	a = 255
	b = 65535
	c = 4294967295
	d = 1844674407370955161
	e = 127
	f = 32767
	g = 2147483647
	h = 9223372036854775807

	fmt.Println("Maximum values....")
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
	fmt.Println("c = ", c)
	fmt.Println("d = ", d)
	fmt.Println("e = ", e)
	fmt.Println("f = ", f)
	fmt.Println("g = ", g)
	fmt.Println("h = ", h)
}

Output:

Minimum values....
a =  0
b =  0
c =  0
e =  -128
f =  -32768
g =  -2147483648
h =  -9223372036854775808
Maximum values....
a =  255
b =  65535
c =  4294967295
d =  1844674407370955161
e =  127
f =  32767
g =  2147483647
h =  9223372036854775807

(ii) Floating-Point Numbers

Golang has two data types for floating-point numbers which are float32 and float64.

Data Type Size Value Range
float32 32 bits Single precision floating, IEEE 754 floating-point number
float64 64 bits Double precision, IEEE 754 floating-point number

Example:

// Golang program to demonstrate
// the floating-point types

package main

import (
	"fmt"
)

func main() {
	var a float32 = 12.123456789
	var b float64 = 12.123456789

	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
}

Output:

a =  12.123457
b =  12.123456789

(iii) Complex Numbers

Complex numbers consist of two parts real and imaginary. Go language has two data types for complex numbers which are complex64 and complex128. To create a complex number variable, Golang has built-in functions.

Data Type Size Value Range
complex64 64 bits Complex numbers containing float32 value as real part and imaginary component.
complex128 128 bits Complex numbers containing float64 value as real part and imaginary component.

Example:

// Golang program to demonstrate
// the complex numbers

package main

import (
	"fmt"
)

func main() {
	var a complex64 = complex(123, 456)
	var b complex128 = complex(123, 456)

	fmt.Println("a = ", a)
	fmt.Println("b = ", b)
}

Output:

a =  (123+456i)
b =  (123+456i)

(c) Go String Types

In Go language, the string is a sequence of immutable bytes (Unicode characters) that cannot be changed.

Example:

// Golang program to demonstrate
// the string types

package main

import (
	"fmt"
)

func main() {
	var str1 string = "New Delhi, India"

	var str2 string
	str2 = "Hello, world!"

	str3 := "Hi, there?"

	fmt.Println("str1 = ", str1)
	fmt.Println("str2 = ", str2)
	fmt.Println("str3 = ", str3)
}

Output:

str1 =  New Delhi, India
str2 =  Hello, world!
str3 =  Hi, there?

ADVERTISEMENT



ADVERTISEMENT



Comments and Discussions


ADVERTISEMENT

ADVERTISEMENT
ADVERTISEMENT
ADVERTISEMENT

Languages: » C » C++ » C++ STL » Java » Data Structure » C#.Net » Android » Kotlin » SQL
Web Technologies: » PHP » Python » JavaScript » CSS » Ajax » Node.js » Web programming/HTML
Solved programs: » C » C++ » DS » Java » C#
Aptitude que. & ans.: » C » C++ » Java » DBMS
Interview que. & ans.: » C » Embedded C » Java » SEO » HR
CS Subjects: » CS Basics » O.S. » Networks » DBMS » Embedded Systems » Cloud Computing
» Machine learning » CS Organizations » Linux » DOS
More: » Articles » Puzzles » News/Updates

© https://www.includehelp.com some rights reserved.