GO has all the basic and advanced data types like other programming languages. Before we dive into the data types, let's first have a look at some conventions in GO.

Filenames in GO

GO code is written and stored in the .go file. The filename itself can consist of lower-case letters by convention. For example codewithab.go is a valid filename by convention. In another case, if file names have multiple words, that word should be separated by _ rather than camel case by convention. Like code_with_ab.go is a valid file name in that case. The main constraints in the filename that cause the filename to be invalid are 👇:

- Including spaces in the filename
- Including special characters like `@`, `#`, `$`

Identifiers in GO

Identifiers are the elements of a program (go program) that are assigned by the user/developer like a variable is defined by the developer. The same is the case for a function name. Below are some examples of NOT valid identifiers 👇

• 1codewithab -> INVALID (Reason❓: identifier name cannot start with a number)
• for -> INVALID (Reason❓: for is a special/reserved keyword in GO use to define for-loops )
  If you want to read about all the GO reserved words, you can have a brief look at them here 👈
• code+with+ab -> INVALID (Reason❓: identifier name connot contain special characters)
• code_with_ab -> VALID

Go Data Types

In this article, we will focus and discuss the details about these data types 👇

• Strings
• Boolean
• Integers
  • int8
  • int16
  • int32
  • int64
  • uint8
  • uint16
  • uint32
  • uint64
  • uintptr
• Complex Numbers

Strings

String type in GO is basically a slice of bytes type. But here is the interesting fact about this type. GO in fact does not have any byte type but the byte type is an alias for the uint8 type. Pretty confusing right 😵?

Okay, so let's simplify it. In short, the string type is basically a collection of byte types where each character of the string is represented separately.

package main

import (  
    "fmt"
)

func printIndividialBytes(fullString string) {  
    fmt.Printf("Bytes: ")
    for i := 0; i < len(fullString); i++ {
        fmt.Printf("%x ", fullString[i])
    }
}

func main() {  
    name := "Code with AB"
    fmt.Printf("String: %s\n", name)
    printIndividialBytes(name)
}

/* Output: 👇
String: Code with AB
Bytes: 43 6f 64 65 20 77 69 74 68 20 41 42 
*/

Run In Playground 🔗

Boolean

Boolean is the same as pretty much any other programming language with true and false as options.

var isPaidCustomer bool = true;

Integers Type

Integer types are differed by the memory allocation of the particular variable. To make it more clear. Let's take an example. Let's define a variable and initialize it with a number and a data type of int8.

var years_of_coding int8 = 3;

In the above example, the variable years_of_coding will take 8 bits of space on memory.

Similarly

re + img¡

package main
import "fmt"

func main(){
    // To declare complex number (real +imaginary(¡))
    var comp complex64 = 5 + 10i 
    fmt.Printf("The value is: %v", comp)
}
/*
OUTPUT 👇
The value is: (5+10i)
*/