<h6>Основные команды и VSCode</h6>
Необходимо создать директорию для Go-окружения и добавить путь к ней в переменные среды.
```go
$ go mod init my-app // создание файла go.mod для отладки и запуска
$ go run main.go // запуск приложения
$ go build -o my.exe main.go // создание исполняемого файла
$ go get -t github.com/... // скачать и добавить библиотеку
```
<h6>Точка входа в приложение:</h6>
```go
func main() {
}
```
<h6>Типы данных:</h6>
```go
var a int8, uint8
var b int16, uint16
var c int32, uint32
var d int64, uint64
var e byte // = uint8
var f rune // int32
var j int //
var k uint
var a float32 
var b float64
var x complex64
var x complex128

var x bool = true
var x bool = false

var name string = "Dmitry"
```
<h6>Инициализация переменных:</h6>
```go
var name string
var name string = "Dmitry"
name := "Dmitry"

var (
	name = "Dmitry"
	age = 32
)

var name, age = "Dmitry", 32
```
<h6>Функции:</h6>
```go
// Функция может возвращать несколько значений
func test() (string, string) {
	a := "hello"
	b := "world"
	return a, b
}

// Именные выходные параметры
// В данном случае выходные переменные уже проинициализированы
// Можно просто присваивать значения
func test() (a string, b string) {
	a = "hello"
	b = "world"
	return a, b
}


// Получить значения
s1, s2 := test()

// Или одно
func test() string {
	return "empty"
}

// Передать функцию как параметр
func test(callback func(int, int) int, s string) int {
	result := callback(5, 1)
	fmt.Println(s)
	return result
}
```
<h6>Структуры</h6>
```go
type Point struct {
	X int
	Y int
}

p := Point {
	X: 1,
	Y: 2,
}

p.X = 123

// добавить метод к структуре
func (p *Point) movePointPtr(x, y int) {
	p.X += x
	p.Y += y
}
```
<h6>Массивы и срезы</h6>
Срезы не имеют фиксированной длины. Слайсы не хранят данные, а ссылаются на массив.
```go
var a[2]string
a[0] = "hello"
a[1] = "world"

// Компилятор посчитает размер массива
nmbers := [...]int{1, 2, 3}

// Слайсы. Не имеют фиксированной длины
letters := []string{"a", "b", "c"}
    
// Пустой слайс
createSlice := make([]string, 3)
    
```
<h6>Циклы</h6>
```go
// Обычная запись
sum := 0
for i := 0; i < 10; i++ {
	sum += i
}

// Цикл с условием
sum := 0
for ; sum < 1000 {
	sum += 10
}

// Более короткая запись
sum := 0
for sum < 1000 {
	sum += 10
}
```
<h6>Ветвление</h6>
```go
if a < 1000 {

}
else if {

}
else {

}

// Сокращенная запись
if i := isTest(): i == 1 {

}

//
switch i {
case 1:

case 2:

case 3:

default:

}

// Короткая запись
switch i := isTest() {
}

// switch можно записать без условия
switch {
case i == 1: // true/false
case i == 2:
}
```
<h6>Отложенное выполнение</h6>
```go
// несколько defer выполняются по принципу стека
func main() {
	defer fmt.Println("world") // Вызвов будет после
	fmt.Println("Hello")
}
```
<h6>Ссылки и указатели</h6>
```go
a := "hellow world"
p := &a // ссылка
fmt.Printlt(*p) // * получить значение (hello world)
*p = "new string"
fmt.Printlt(*p) // * получить значение (new string)
```
<h6>Замыкание</h6>
```go
func totalPrice(initPrice int) func(int) int {
	sum := initPrice
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	orderPrice := totalPrice(1)
	fmt.Println(orderPrice(1))
	fmt.Println(orderPrice(1))
	fmt.Println(orderPrice(1))
	fmt.Println(orderPrice(1))
}
```
<h6>Итератор range. Структура map</h6>
```go
func test6() {
    arr := []string{"a", "b", "c"}
    for i, l := range arr {
        fmt.Println(i, l)
    }
}

func test7() {

    pointMap := map[string]Point{}
    // otherMap := map[string]int{}
    // otherPointMap := make(map[int]Point)

    pointMap["a"] = Point{
        X: 1,
        Y: 2,
    }
  

    fmt.Println(pointMap)

    fmt.Println(pointMap["a"])

}
```