2.2 ➕ Операции с переменными

После того как ты познакомился с типами данных и переменными, пора научиться выполнять над ними операции. Go поддерживает арифметические, логические, побитовые и строковые операции.

🔢 Арифметические операции

Работают с числами (int, float, и т.д.):

💡 Деление целых чисел всегда возвращает целое число. Например, 5 / 2 = 2, а не 2.5. Для дробного результата нужно использовать float.

var a = 10
var b = 3
fmt.Println(a / b) // 3 (int)
fmt.Println(float64(a) / float64(b)) // 3.3333 (float)

✅ Операторы присваивания

Позволяют изменять значение переменной:

x := 5
x = x + 1  // Обычное присваивание | x = 6
x += 2     // Увеличить на 2 | x = 8
x -= 1     // Уменьшить на 1 | x = 7
x *= 3     // Умножить на 3 | x = 21
x /= 2     // Разделить на 2 | x = 10
x %= 3     // Остаток от деления на 3 | x = 1

🧠 Инкремент и декремент

x++ // увеличивает на 1 | эквевалетна записи x = x + 1
x-- // уменьшает на 1 | эквевалетна записи x = x - 1

⚠️ В Go эти операторы — отдельные инструкции. Нельзя писать y = x++, как в C++ или Java.

🔁 Сравнения (bool-выражения)

Операции сравнения возвращают true или false:

🔗 Логические операции

Логические операторы используются для работы с булевыми значениями (true или false):

• && — логическое И (AND)
  Выражение возвращает true, только если оба условия истинны.
  Пример: x > 5 && x < 10 вернёт true, если x больше 5 и меньше 10 одновременно.

• || — логическое ИЛИ (OR)
  Выражение возвращает true, если хотя бы одно из условий истинно.
  Пример: x < 0 || x > 100 вернёт true, если x меньше 0 или больше 100.

• ! — логическое НЕ (NOT)
  Инвертирует логическое значение.
  Пример: !isReady вернёт true, если isReady равно false.

  ---

📋 Таблица истинности

📚 Операции со строками

• Конкатенация (сложение строк):

first := "Hello, "
second := "world!"
greeting := first + second
fmt.Println(greeting) // Hello, world!

💡 В Go строки можно только складывать. Умножать или вычитать нельзя.

🧮 Побитовые операции

Побитовые операции работают с целыми числами на уровне отдельных битов. Это может быть полезно, когда нужно экономить память, управлять флагами или взаимодействовать с низкоуровневыми структурами (например, сетевые протоколы, работа с оборудованием, сжатие данных и т.д.).

📋 Основные побитовые операторы

• & — И (AND): устанавливает бит в 1, если он установлен в обоих операндах
• | — ИЛИ (OR): устанавливает бит в 1, если он установлен хотя бы в одном операнде
• ^ — исключающее ИЛИ (XOR): устанавливает бит в 1, если он установлен только в одном из операндов
• &^ — очистка бита (AND NOT): обнуляет биты, установленные в правом операнде
• << — сдвиг влево: сдвигает биты влево на указанное число позиций (умножение на 2ⁿ)
• >> — сдвиг вправо: сдвигает биты вправо (деление на 2ⁿ)

🔍 Примеры

a := 12        // 1100 в двоичной системе
b := 10        // 1010

result1 := a & b   // 1000 = 8
result2 := a | b   // 1110 = 14
result3 := a ^ b   // 0110 = 6
result4 := a &^ b  // 0100 = 4
result5 := a << 1  // 11000 = 24
result6 := b >> 1  // 0101 = 5

🛠 Примеры использования

• Флаги и маски

  const (
      FlagRead  = 1 << 0 // 0001
      FlagWrite = 1 << 1 // 0010
      FlagExec  = 1 << 2 // 0100
  )
  
  var perms uint8 = FlagRead | FlagWrite // 0011
  
  if perms&FlagWrite != 0 {
      fmt.Println("Запись разрешена")
  }
  

• Оптимизация по памяти Побитовые флаги позволяют хранить до 8 независимых булевых значений в одном uint8.

• Низкоуровневые вычисления Часто используются в криптографии, коде для микроконтроллеров и сетевых протоколов.

🧠 Побитовые операции — мощный инструмент, но применяются в основном в системном и высокопроизводительном коде. В повседневной разработке на Go они встречаются нечасто, но полезно понимать, как они работают.

🧪 Пример

package main

import "fmt"

func main() {
    x := 10
    y := 3

    fmt.Println("x + y =", x + y)
    fmt.Println("x % y =", x % y)
    fmt.Println("x > y:", x > y)
    fmt.Println("x < 20 && y > 1:", x < 20 && y > 1)

    greeting := "Привет, " + "Go!"
    fmt.Println(greeting)

    // Побитовые операции
    fmt.Println("x & y =", x & y)   // Побитовое И
    fmt.Println("x | y =", x | y)   // Побитовое ИЛИ
    fmt.Println("x ^ y =", x ^ y)   // Побитовое исключающее ИЛИ
    fmt.Println("x &^ y =", x &^ y) // Побитовое AND NOT
    fmt.Println("x << 1 =", x << 1) // Сдвиг влево на 1 (умножение на 2)
    fmt.Println("y >> 1 =", y >> 1) // Сдвиг вправо на 1 (деление на 2)
}

🔍 Вопросы для самопроверки

1. Чем отличается x++ от x += 1?
2. Что произойдёт при делении 5 / 2?
3. Можно ли использовать x = y++ в Go?
4. Какие логические операторы ты знаешь?
5. Как соединить две строки в Go?

📌 Главное из главы

• Go поддерживает арифметические, логические, строковые и побитовые операции.
• Деление целых чисел — всегда целочисленное. Для дробного результата нужно привести к float.
• Операторы ++ и -- работают как отдельные инструкции.
• Логические выражения возвращают булевы значения.
• Строки можно складывать с помощью +, но нельзя умножать или вычитать.