Data Types: Overview of Go's basic
Published: 2023-03-21 05:30:00

Go is a statically-typed programming language that has built-in support for various data types. Go's basic data types include integers, floating-point numbers, strings, and booleans, as well as arrays, slices, maps, and pointers.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1j5wacbwovec5986xubl.png)

## Integers


Integers are whole numbers without a fractional component. Go supports three main categories of integers: signed integers, unsigned integers, and byte-sized integers. Signed integers can represent both positive and negative numbers, while unsigned integers can only represent positive numbers. Byte-sized integers are used to represent small numbers and take up less space in memory compared to other integer types.

In Go, integers are defined by their bit size. For example, `int8` has a bit-size of 8, while `int64` has a bit-size of 64. The `uint` type is used to define unsigned integers, and `byte` is used to define byte-sized integers.

Go supports various operations on integers, including addition, subtraction, multiplication, division, and modulo. Here's an example of using integers in Go:


```
package main

import "fmt"

func main() {
    var a int = 10
    var b int = 20
    var c int

    c = a + b
    fmt.Printf("a + b = %d\\n", c)
}

```


## Floating-Point Numbers

Floating-point numbers represent numbers with a fractional component. Go supports two types of floating-point numbers: float32 and float64. Float32 is a single-precision floating-point number, while float64 is a double-precision floating-point number. Float64 is more precise than float32, but it takes up more space in memory.

Go supports various operations on floating-point numbers, including addition, subtraction, multiplication, division, and modulo. However, arithmetic operations on floating-point numbers can result in rounding errors due to the limited precision of floating-point numbers. Here's an example of using floating-point numbers in Go:

```
package main

import "fmt"

func main() {
    var a float32 = 10.5
    var b float32 = 20.5
    var c float32

    c = a + b
    fmt.Printf("a + b = %f\\n", c)
}

```

## Strings

Strings are a sequence of characters. In Go, strings are immutable, which means that once a string is created, it cannot be modified. Go represents strings using UTF-8 encoding, which allows for support of various languages and symbols.

Go provides various built-in functions to manipulate strings, such as `len()` to get the length of a string, `+` to concatenate two strings, and `strings.Split()` to split a string into a slice of substrings. Here's an example of using strings in Go:

```
package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "Hello, World!"
    fmt.Println("Length of str:", len(str))
    fmt.Println("Substring:", str[0:5])
    fmt.Println("Concatenation:", str + " Welcome")
    fmt.Println("Split:", strings.Split(str, ","))
}

```

## Booleans

Booleans represent logical values. There are two possible values for a boolean variable: true and false. Booleans are frequently used in conditional statements and loops to control program flow.

Go supports various boolean operators, including `&&` for logical AND, `||` for logical OR, and `!` for logical NOT. Here's an example of using booleans in Go:

```
package main

import "fmt"

func main() {
    var a bool = true
    var b bool = false

    fmt.Println("a && b:", a && b)
    fmt.Println("a || b:", a || b)
    fmt.Println("!a:", !a)
}

```

## Arrays

An array is a collection of elements of the same type. In Go, arrays are fixed-size, meaning that the length of an array cannot be changed once it is defined. Here's an example of using arrays in Go:

```
package main

import "fmt"

func main() {
    var a [5]int
    a[0] = 1
    a[1] = 2
    a[2] = 3
    a[3] = 4
    a[4] = 5

    fmt.Println("Array:", a)
}

```

## Slices

A slice is a segment of an array. Unlike arrays, slices are dynamic and can be resized. Here's an example of using slices in Go:

```
package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5}

    fmt.Println("Slice:", a)
}

```

## Maps

A map is a collection of key-value pairs. In Go, maps are used to represent associative arrays, which are arrays that use keys instead of indexes to access elements. Here's an example of using maps in Go:

```
package main

import "fmt"

func main() {
    a := make(map[string]int)
    a["key1"] = 1
    a["key2"] = 2
    a["key3"] = 3

    fmt.Println("Map:", a)
}

```

## Pointers

A pointer is a variable that stores the memory address of another variable. In Go, pointers are used to pass variables by reference, which can improve performance and reduce memory usage. Here's an example of using pointers in Go:

```
package main

import "fmt"

func main() {
    var a int = 10
    var p *int

    p = &a

    fmt.Println("Value of a:", a)
    fmt.Println("Value of p:", *p)
}

```

In conclusion, Go's basic data types include integers, floating-point numbers, strings, and booleans, as well as arrays, slices, maps, and pointers. Understanding these data types is critical for any Go programmer to write correct and efficient code. By utilizing these data types effectively, programmers can write concise and robust code that can perform complex operations with ease.