# Overview of Data Types in Go

In this lesson, we'll explore the different types of data Go can handle and how to work with them.

### Types in Go

In Go, variables can hold different kinds of data, known as data types. Since Go is a statically typed language, the compiler needs to know the type of every variable either explicitly or through inference. A **type** defines both the possible values a variable can hold and the operations you can perform on that data.

Here’s a quick breakdown of the main types in Go:

* **Elementary (Primitive) Types**: Basic types such as `int`, `float`, `bool`, and `string`.
    
* **Structured (Composite) Types**: More complex types like `struct`, `array`, `slice`, `map`, and `channel`.
    
* **Interfaces**: These describe the behaviour of a type by defining a set of methods.
    

For structured types that haven’t been assigned a value yet, they default to `nil`.

### Declaring Variables

To declare a variable in Go, you use the `var` keyword followed by the variable name and its type:

```go
var var1 type1
```

Here, `var1` is the variable, and `type1` is its type.

#### Function Types

Functions also have types, specifically a return type. The type of the function’s return value is declared after the function’s parameters:

```go
func FunctionName(a typeA, b typeB) typeFunc
```

In this example, `typeFunc` is the return type of the function. If the function returns multiple values, their types are listed in parentheses:

```go
func FunctionName(a typeA, b typeB) (t1 type1, t2 type2)
```

The return statement would then look like this:

```go
return var1, var2
```

### User-Defined Data Types

Go allows you to define custom data types. For example, you can create an alias for a type:

```go
type IZ int
```

Now, instead of declaring an `int`, you can use `IZ`:

```go
var a IZ = 5
```

You can also declare multiple type aliases in a factored format:

```go
type (
  IZ  int
  FZ  float32
  STR string
)
```

In this example, `IZ`, `FZ`, and `STR` are aliases for `int`, `float32`, and `string` respectively.

### Type Conversion

Sometimes, you’ll need to convert a value from one type to another. Go does not perform implicit type conversions, so all conversions must be done explicitly. Here's an example of type-casting:

```go
valueOfTypeB = typeB(valueOfTypeA)
```

If you have a floating-point variable and want to convert it to an integer, you would do this:

```go
number := 5.2
intValue := int(number)
```

After converting, the value of `number` changes from `5.2` to `5` as the decimal is truncated.

---

Now that we've covered the basics of data types in Go, it's time to move on to storing data in the next lesson.