Open in App
Not now

# Data Types in Go

• Difficulty Level : Easy
• Last Updated : 23 Mar, 2023

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

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)

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

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`

My Personal Notes arrow_drop_up
Related Articles