Let's Learn with Go technology
If you read you get no knowledge, but if you read and type you get infinite experience.

Go can be called a technology or programming language developed by Google. These developers include Robert Griesemer, Rob Pike and Ken Thomson. Go was first introduced to the public in 2009.

Advantages of using the GO programming language

1. supports concurrency with very easy implementation
2. Supports data processing with multiple processors at the same time (Parallel Processing)
3. Has a Garbage Collector
4. Very fast compilation process
5. Not a programming language in general which is usually called hierarchical and is not classified as an OOP programming language
6. The dependencies provided are quite complete and meet backend needs
7. Support for the Community

Go stable installation for Windows users

1.Langka First go to the installer page https://golang.org/dl/ . Select Installer for the Windows Operating system

1. After you download, run the installer, click next until the installation process is complete. By default, if you don't change the path, c:\go.The path will be registered automatically in the PATH environment variable.
2. Open Command Prompt / CMD, execute the command to check the version of Go

go version

1. If the output is the same as the installed Go command, it indicates the installation process was successful.

Initialize the First Project using Go Modules

The go mod init command is used to initialize a new project
Let's just get straight to practice

mkdir first-Project
cd first-Project 
go mod init first-Project
dir

we can see in the section above that the first-Project directory is created after entering that directory, the go mod init first-Project command is executed by a go project with the name first-Project.

Go Path Variabel

Gopath is a variable used by go as a reference location where all go project folders are stored, except for those initialized using go Modules. GOPATH contains 3 sub folders src, bin and pkg.

Go projects can be placed in $GOPATH/src, for example you want to create a project with the name learning folder. then you have to create a learning folder, placed in the src directory ($GOPATH/learning).

Variable Declaration with Data Type

Go is designed and has quite strict rules regarding writing variables. When declaring the data type used, it must be written down. Another term for this concept is manifest typing.

The following is an example of a variable and its data type that must be written.

package main 


//Import package
import "fmt"

func main(){
var firstName string= "john"
var lastName string

lastname = "wick"
fmt.Printf("Halo %s %s!\n",firstName,lastName)

}

The var keyword above is used for variable declarations, an example can be seen
on firstName and lastName .
The value of the firstName variable is filled directly when it is declared, different from comparison
lastName whose value is filled in after the declaration line of code, something like this
allowed in Go.

Variable declarations use the var keyword

In the code above you can see how the code is declared and its value contents. The var keyword is used to create a new variable
keyword usage scheme:
var
var =

Example
var firstName string
var firstName string = "John"

Variable values can be filled in directly during declaration.

Function

In Go, a function is a block of code that performs a specific task. Functions in Go are defined using the func keyword followed by the function name, parameters (if any), return types (if any), and the body of the function.

package main

import "fmt"

// The entry point of the programs
func main() {
    fmt.Println("Hello world!")
    say("Hello Go!")
}

func say(message string) {
    fmt.Println("You said: ", message)
}

Go Basic Types

Strings Example

s1 := "Hello" + "World"

s2 := `A "raw" string literal
can include line breaks.`

// Outputs: 10
fmt.Println(len(s1))

// Outputs: Hello
fmt.Println(string(s1[0:5]))

Numbers Example

num := 3         // int
num := 3.        // float64
num := 3 + 4i    // complex128
num := byte('a') // byte (alias: uint8)

var u uint = 7        // uint (unsigned)
var p float32 = 22.7  // 32-bit float

Operators

x := 5
x++
fmt.Println("x + 4 =", x + 4)
fmt.Println("x * 4 =", x * 4) 

Boolean

x := 5
x++
fmt.Println("x + 4 =", x + 4)
fmt.Println("x * 4 =", x * 4) 

Arrays Examples

┌────┬────┬────┬────┬─────┬─────┐
| 2  | 3  | 5  | 7  | 11  | 13  |
└────┴────┴────┴────┴─────┴─────┘
  0    1    2    3     4     5
primes := [...]int{2, 3, 5, 7, 11, 13}
fmt.Println(len(primes)) // => 6

// Outputs: [2 3 5 7 11 13]
fmt.Println(primes)

// Same as [:3], Outputs: [2 3 5]
fmt.Println(primes[0:3])

Pointers

func main () {
  b := *getPointer()
  fmt.Println("Value is", b)
}
func getPointer () (myPointer *int) {
  a := 234
  return &a
}

Examples Slices

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s = append(s, "d")
s = append(s, "e", "f")

fmt.Println(s)
fmt.Println(s[1])
fmt.Println(len(s))
fmt.Println(s[1:3])

slice := []int{2, 3, 4}

Constans

const s string = "constant"
const Phi = 1.618
const n = 500000000
const d = 3e20 / n
fmt.Println(d)

Type Conversions

i := 90
f := float64(i)
u := uint(i)

// Will be equal to the character Z
s := string(i)
// How to get string
i := 90

// need import "strconv"
s := strconv.Itoa(i)
fmt.Println(s) // Outputs: 90

I need criticism and suggestions if there are any shortcomings in my writing. If you have any questions, please leave them in the comments.