Go example

package main

import "fmt"

func main() {
    // Название := Значение
    v := "1"

    // var Название = Значение
    var v1 = "2"

    // var Название Тип = Значение
    var v2 string = "3"

    // var Название Тип
    var v3 string

    /*
        Простые типы

        int - целое число
        float64 - дробное число
        string - текст (строка)
        bool - логический тип (да/нет) (булка)
    */

    fmt.Println(v, v1, v2, v3)

    // if Условие {Блок кода если условие истино}
    if v == "1" {
        fmt.Println(`v=="1"`)
    }

    // if Условие (Тип bool) {Блок кода если условие истино} else {Блок кода если условие ложно}
    if v1 == "1" {
        fmt.Println(`v1=="1"`)
    } else {
        fmt.Println(`v1!="1"`)
    }

    // switch Переменная (Имя) {}
    switch v2 {
    case "1": // case Значение: Код
        fmt.Println(`v2=="1"`)
    case "3":
        fmt.Println(`v2=="3"`)
    default:
        fmt.Println(`v2??`)
    }

    // switch {}
    switch {
    case v1 == "1": // case Условие (Тип bool): Код
        fmt.Println(`v1=="1"`)
    case v1 == "2":
        fmt.Println(`v1=="2"`)
    default:
        fmt.Println(`v1??`)
    }

    /*
        Арифметические операции над числами (int float64)
        a + b - складывает a и b
        a - b - вычитает из a b
        a * b - умножает a на b
        a / b - делит a на b (если у обоих тип int то выполняет целочисленое деление)
        a % b - остаток от деления a на b (только для типа int)

        Операции над строками
        a + b - возвращает новыую строку в начале которой будет a которой будет дописана b
        a * b - дублирует строку a b раз (только для a типа string b типа int)
    */

    /*
        Как получить bool

        МОЖНО ИСПОЛЬЗОВАТЬ ДЛЯ ЛЮБЫХ a и b ОДНОГО ТИПА
        a == b - вернет истину если a равно b
        a != b - вернет истину если a не равно b
        a < b - вернет истину если a меньше b
        a > b - вернет истину если a больше b
        a <= b - вернет истину если a меньше или равно b
        a >= b - вернет истину если a больше или равно b

        МОЖНО ИСПОЛЬЗОВАТЬ ДЛЯ a и b ТИПА bool
        a || b - вернет истину если a или b истина, где a и b Могут быть только логическим типом (bool)
        a && b - вернет истину если a и b истина, где a и b Могут быть только логическим типом (bool)
    */

    /*
        Сложные типы

        Массивы (срезы) и карты
    */

    // Название := []Тип{}
    sl := []int{}

    // Название := []Тип{Значения через запятую}
    sl1 := []int{1, 6, 897}

    // Название := make([]Тип, Длина, Емкость)
    /*
        Чем длина отличается от емкости

        Длина это то сколько элеменетов есть сейчас в массиве
        Емкость это то сколько можно положить элементов в массив по быстрому

        Емкость это необязательный параметр

        Этот формат объявления переменной использовать только когда тебе надо установить емкость
    */
    sl2 := make([]int, 0, 2)

    // Добавляем элемент в конец массива (УВЕЛИЧИВАЕТ ДЛИННУ)
    // Переменная = append(Переменная, Значение)
    sl = append(sl, 5)

    // Получение Значения по Индексу
    // Пременная[Индекс]
    // Индекс начинается с 0 и ВСЕГДА меньше длины массива
    fmt.Println(sl[0])

    sl2 = append(sl2, sl1[2])

    fmt.Println(sl, sl1, sl2)

    // Переменная1 (Слайс) = Перменную2 (Слайс/Массив) [Индекс начала: Индекс конца НЕВКЛЮЧИТЕЛЬНО]
    // Оба индекса опциональны
    sl2 = sl1[1:3]
    sl = sl1[:]
    fmt.Println(sl, sl1, sl2)

    // Название := map[Тип ключа]Тип значения{}
    mp := map[int]string{}

    // Название := make(map[Тип ключа(Простой тип или Структура)]Тип значения)
    mp1 := make(map[int]string)

    // НЕ ИСПОЛЬЗУЙ
    // var mp2 map[int]string

    mp[1] = "asdas"

    mpEx := map[string][]string{}

    mpEx["zuzu"] = append(mpEx["zuzu"], "Vasya")
    mpEx["zuzu"] = append(mpEx["zuzu"], "Petyia")
    mpEx["."] = append(mpEx["."], "Vodku")

    mpEx1 := map[string]bool{
        "Vasy": false,
        "Pety": true,
    }

    isGood := mpEx1["Pety"]

    if isGood {
        fmt.Println("Петя хороший")
    } else {
        fmt.Println("Петя плохой")
    }

    fmt.Println(mp, mp1, mpEx)

    // Цикл по элементам Мапы/Массива/Слайса
    // for Название ключа, Название значения := range Переменная{Код}
    // Если это массив то ключ это индекс
    for name, isGood := range mpEx1 {
        if isGood {
            fmt.Println(name, " хороший")
        } else {
            fmt.Println(name, " плохой")
        }
    }

    a, b, c := 1, "asda", false
    /*
        То же что и это
        a := 1
        b := "asda"
        c := false
    */
    fmt.Println(a, b, c)

    // Цикл по изменению переменной
    // for Название := Начальное значение; Название <= Конечное значение; Название ++ { Код }
    // for Объявление переменной; Условие продолжение цикла; Действие в конце цикла {
    for i := 0; i <= 10; i++ {
        fmt.Println(i)
    }

    // for Услование {Код}
    // for {Код} ЭТО БЕСКОНЕЧНЫЙ ЦИКЛ
    for len(sl) < 5 {
        sl = append(sl, 0)
    }
    fmt.Println(sl)

    /*
        Для циклов есть 2 команды

        continue - перейти на следующий шаг цикла (текущий после команды не будет выполнен)
        break - завершить цикл (текущий после команды не будет выполнен)
    */

    // вызов функции
    test()

    hello()

    // вызов функции с аргументами
    helloName("Snamer")

    fmt.Println(doubled(5))
    fmt.Println(doubledDouble(5, 3.3))

    registration("Vasa", "Moscow", 33)
    registration("Petu", "MurmAmisk", 12)

    // Создаем новый тип данных
    // type Название типа struct{}
    type MyType struct{}

    // Объявление переменный своего типа
    // Название := Свой тип{}
    // Объявление переменной с значением
    mt := MyType{}

    // Объявление переменный своего типа
    // Название := &Свой тип{}
    // Объявление переменной со ССЫЛКОЙ на значением
    mt1 := &MyType{}

    fmt.Println(mt, mt1)

    /*
        Название := &Свой тип{
            Поле1: Значение1,
            Поле2: Значение2,
        }
    */
    vasya := Employee{
        Name:    "Vasya 1",
        Work:    "Чистить унитиазы",
        Exp:     10,
        Age:     31,
        Payment: 1.2,
        // IsOff: false,
    }

    fmt.Println(vasya.Age, vasya.Name)

    avtovaz := Zavod{Money: 5000}

    avtovaz.Staff = append(avtovaz.Staff, vasya)

    /*
        \n - перенос строки
        \t - табуляция (как нажать tab)
        %s - вывод строки
        %d - вывод целого числа
        %f - вывод дробного числа
        %+v - вывод структур
    */

    fmt.Printf("%+v\n", avtovaz)

    // передача в функцию по значению
    avtovaz = zarplataV1(avtovaz)

    fmt.Printf("%+v\n", avtovaz)

    // передача в функцию по ссылке
    zarplataV2(&avtovaz)

    fmt.Printf("%+v\n", avtovaz)

}

func zarplataV1(z Zavod) Zavod {
    for _, e := range z.Staff {
        z.Money -= e.Payment
    }
    return z
}

func zarplataV2(z *Zavod) {
    for _, e := range z.Staff {
        z.Money -= e.Payment
    }
}

// func Название(){Код}
func test() {}

// func Название(){Код}
func hello() {
    fmt.Println("Hello")
}

// func Название(Название аргумента Тип аргумента){Код}
func helloName(name string) {
    fmt.Println("Hello ", name)
}

// func Название(Название аргумента Тип аргумента) Тип возвращаемого значения {Код}
func doubled(a int) int {
    return a * 2
}

// func Название(Название аргумента Тип аргумента) (Тип возвращаемого значения через запятую) {Код}
func doubledDouble(a int, b float64) (int, float64) {
    return a * 2, b * 2
}

func registration(name, city string, age int) bool {
    if age > 18 {
        fmt.Printf("Пользователь %s зарегистрирован в городе %s\n", name, city)
        return true
    }
    return false
}

type Zavod struct {
    Staff []Employee
    Money float64
}

type Employee struct {
    Name    string // Навзание поля Тип поля
    Work    string
    Exp     int
    Age     int
    Payment float64
    IsOff   bool
}