Open In App

Data Types in Go

Last Updated : 23 Mar, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Data types specify the type of data that a valid Go variable can hold. In Go language, the type is divided into four categories which are as follows:

  1. Basic type: Numbers, strings, and booleans come under this category.
  2. Aggregate type: Array and structs come under this category.
  3. Reference type: Pointers, slices, maps, functions, and channels come under this category.
  4. Interface type

Here, we will discuss Basic Data Types in the Go language. The Basic Data Types are further categorized into three subcategories which are: 

  • Numbers
  • Booleans
  • Strings

Numbers

In Go language, numbers are divided into three sub-categories that are:

  • Integers: In Go language, both signed and unsigned integers are available in four different sizes as shown in the below table. The signed int is represented by int and the unsigned integer is represented by uint.
    • Possible arithmetic operations : Addition, subtraction, multiplication, division, remainder

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 int and uint contain same size, either 32 or 64 bit.
uint Both int and uint contain 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 uint8.
uintptr It is an unsigned integer type. Its width is not defined, but its can hold all the bits of a pointer value.

Example:

Go




// Go program to illustrate
// the use of integers
package main
import "fmt"
        
func main() {
     
    // Using 8-bit unsigned int
    var X uint8 = 225
    fmt.Println(X, X-3)
     
    // Using 16-bit signed int
    var Y int16 = 32767
    fmt.Println(Y+2, Y-2)
}


Output: 

225 222
-32767 32765

Example of arithmetic operations :

Go




// Possible arithmetic operations for intigers
// Author : Chhanda Saha
 
package main
 
import "fmt"
 
func main() {
 
    var x int16 = 170
    var y int16 = 83
    //Addition
    fmt.Printf(" addition :  %d + %d = %d\n ", x, y, x+y)
    //Subtraction
    fmt.Printf("subtraction : %d - %d = %d\n", x, y, x-y)
    //Multiplication
    fmt.Printf(" multiplication : %d * %d = %d\n", x, y, x*y)
    //Division
    fmt.Printf(" division : %d / %d = %d\n", x, y, x/y)
    //Modulus
    fmt.Printf(" remainder : %d %% %d = %d\n", x, y, x%y)
}


Output:

addition :  170 + 83 = 253
subtraction : 170 - 83 = 87
multiplication : 170 * 83 = 14110
division : 170 / 83 = 2
remainder : 170 % 83 = 4 
  • Floating-Point Numbers: In Go language, floating-point numbers are divided into two categories as shown in the below table.
    • Possible arithmetic operations : Addition, subtraction, multiplication, division.
    • Three literal styles are available :
      • decimal (3.15)
      • exponential ( 12e18 or 3E10)
      • mixed (13.16e12)
Data Type

Description

float32 32-bit IEEE 754 floating-point number
float64 64-bit IEEE 754 floating-point number

Example:

Go




// Go program to illustrate
// the use of floating-point
// numbers
package main
import "fmt"
        
func main() {
    a := 20.45
    b := 34.89
     
    // Subtraction of two
    // floating-point number
    c := b-a
     
    // Display the result
    fmt.Printf("Result is: %f", c)
     
    // Display the type of c variable
    fmt.Printf("\nThe type of c is : %T", c) 
}


Output: 

Result is: 14.440000
The type of c is : float64

Example of arithmetic operations for floating point numbers :

Go




// Possible arithmetic operations for float numbers
// Author : Chhanda Saha
package main
 
import "fmt"
 
func main() {
    var x float32 = 5.00
    var y float32 = 2.25
    //Addition
    fmt.Printf("addition :  %g + %g = %g\n ", x, y, x+y)
    //Subtraction
    fmt.Printf("subtraction : %g - %g = %g\n", x, y, x-y)
    //Multiplication
    fmt.Printf("multiplication : %g * %g = %g\n", x, y, x*y)
    //Division
    fmt.Printf("division : %g / %g = %g\n", x, y, x/y)
 
}


Output:

addition :  5 + 2.25 = 7.25
subtraction : 5 - 2.25 = 2.75
multiplication : 5 * 2.25 = 11.25
division : 5 / 2.25 = 2.2222223
  • Complex Numbers: The complex numbers are divided into two parts are shown in the below table. float32 and float64 are also part of these complex numbers. The in-built function creates a complex number from its imaginary and real part and in-built imaginary and real function extract those parts.
    • There are few built-in functions in complex numbers:
      • complex – make complex numbers from two floats.
      • real() – get real part of the input complex number as a float number.
      • imag() – get imaginary of the input complex number part as float number
Data Type

Description

complex64 Complex numbers which contain float32 as a real and imaginary component.
complex128 Complex numbers which contain float64 as a real and imaginary component.

Example:

Go




// Go program to illustrate
// the use of complex numbers
package main
import "fmt"
 
func main() {
     
   var a complex128 = complex(6, 2)
   var b complex64 = complex(9, 2)
   fmt.Println(a)
   fmt.Println(b)
    
   // Display the type
  fmt.Printf("The type of a is %T and "+
            "the type of b is %T", a, b)
}


Output: 

(6+2i)
(9+2i)
The type of a is complex128 and the type of b is complex64

Built-in functions example :

Go




// Built-in functions in complex numbers
// Author : Chhanda Saha
package main
 
import "fmt"
 
func main() {
    comp1 := complex(10, 11)
    // complex number init syntax
    comp2 := 13 + 33i
    fmt.Println("Complex number 1 is :", comp1)
    fmt.Println("Complex number 1 is :", comp2)
    // get real part
    realNum := real(comp1)
    fmt.Println("Real part of complex number 1:", realNum)
    // get imaginary part
    imaginary := imag(comp2)
    fmt.Println("Imaginary part of complex number 2:", imaginary)
 
}


Output:

Complex number 1 is : (10+11i)
Complex number 1 is : (13+33i)
Real part of complex number 1: 10
Imaginary part of complex number 2: 33

Booleans

The boolean data type represents only one bit of information either true or false. The values of type boolean are not converted implicitly or explicitly to any other type. 

Example: 

Go




// Go program to illustrate
// the use of booleans
package main
import "fmt"
 
func main() {
     
    // variables
   str1 := "GeeksforGeeks"
   str2:= "geeksForgeeks"
   str3:= "GeeksforGeeks"
   result1:= str1 == str2
   result2:= str1 == str3
    
   // Display the result
   fmt.Println( result1)
   fmt.Println( result2)
    
   // Display the type of
   // result1 and result2
   fmt.Printf("The type of result1 is %T and "+
                   "the type of result2 is %T",
                             result1, result2)
    
}


Output:

false
true
The type of result1 is bool and the type of result2 is bool

Strings

The string data type represents a sequence of Unicode code points. Or in other words, we can say a string is a sequence of immutable bytes, means once a string is created you cannot change that string. A string may contain arbitrary data, including bytes with zero value in the human-readable form. Strings can be concatenated using plus(+) operator.

Example: 

Go




// Go program to illustrate
// the use of strings
package main
import "fmt"
 
func main() {
     
    // str variable which stores strings
   str := "GeeksforGeeks"
    
   // Display the length of the string
   fmt.Printf("Length of the string is:%d",
                                  len(str))
    
   // Display the string
   fmt.Printf("\nString is: %s", str)
    
   // Display the type of str variable
   fmt.Printf("\nType of str is: %T", str)
}


Output: 

Length of the string is:13
String is: GeeksforGeeks
Type of str is: string

String concatenation example:

Go




// String concatenation
// Author : Chhanda Saha
package main
 
import "fmt"
 
func main() {
    var str1 string = "STRING_"
    var str2 string = "Concatenation"
 
    // Concatenating strings using + operator
    fmt.Println("New string : ", str1+str2)
 
}


Output:

New string :  STRING_Concatenation

 



Previous Article
Next Article

Similar Reads

Different Types of Recursion in Golang
Recursion is a concept where a function calls itself by direct or indirect means. Each call to the recursive function is a smaller version so that it converges at some point. Every recursive function has a base case or base condition which is the final executable statement in recursion and halts further calls. There are different types of recursion
6 min read
How to convert Int data type to Float in Golang?
In Golang, the data types are bound to variables rather than the values, which means that, if you declare a variable as int, then you can store only integer type value in it, you cant assign character or string in it unless you convert the data type to required data type. To convert an integer data type to float you can wrap the integer with float6
2 min read
How to compare Structs with the Different Values Assigned to Data Fields in Golang?
A struct (Structure) is a user-defined type in Golang that contains a collection of named fields/properties which creates own data types by combining one or more types. Also, this concept is generally compared with the classes in object-oriented programming. A struct has different fields of the same or different data types and is declared by compos
3 min read
How to print struct variables data in Golang?
A struct (Structure) is a user-defined type in Golang that contains a collection of named fields/properties which creates own data types by combining one or more types. Also, this concept is generally compared with the classes in object-oriented programming. A struct has different fields of the same or different data types and is declared by compos
2 min read
How to Calculate Percentiles For Monitoring Data-Intensive Systems?
Monitoring often involves the use of percentiles. Unlike average values, which are heavily influenced by outliers, percentiles help understand how the system works most of the time. If 9 out of 10 requests are executed in 1 second and the last one takes 10 seconds, the average will be 1.9 seconds while the 50th percentile will be 1 second. This is
8 min read
Data Structures
Complete Guide to Linked List Data Structure
In this complete guide to Linked List Data Structures, you will learn about the basics of Linked List, how to get started with Linked List, learning, strategy, resources, problems, and much more.
4 min read
Data Processing Agreement
Welcome to GeeksforGeeks. This Agreement is between Sanchhaya Education Pvt. Ltd., registered and headquartered at A-143, Sovereign Corporate Towers, 9th Floor, Sector-136, NOIDA, Gautam Buddha Nagar, Uttar Pradesh,201305, hereinafter referred to as ‘Company’ or GeeksforGeeks (“us”, “we”, or “our”) operates https://www.geeksforgeeks.org/ (hereinaft
11 min read
Complete Guide to Arrays Data Structure
In this complete guide to Array Data Structures, you will learn about the basics of Arrays, how to get started with Array, learning, strategy, resources, problems, and much more.
4 min read
Complete Guide to String Data Structure
In this complete guide to String Data Structures, you will learn about the basics of string, how to get started with String, learning, strategy, resources, problems, and much more.
4 min read
Article Tags :