К плану
Урок
0+

Операторы адресации и разыменования (& и *)

В React и TypeScript управление ссылками скрыто под капотом. Когда вы передаете объект в компонент, JavaScript сам решает, как с ним работать. В Go вы берете управление памятью на себя. Вы сами определяете: передать копию данных или «адрес», по которому они лежат.

В Go у каждой переменной есть Zero value. Для указателей это всегда nil. Работа с адресами требует дисциплины: важно точно знать, куда именно «смотрит» ваш указатель.

Pointer и оператор адресации

Pointer (указатель) — это переменная, которая хранит адрес другой переменной, а не само значение.

Чтобы получить этот адрес, используйте Address operator (оператор адресации) — символ амперсанда &. Представьте, что переменная — это дом, а значение — его жильцы. Указатель — это записка с адресом дома.

package main

import "fmt"

func main() {
    age := 30
    // Получаем адрес переменной age
    addr := &age 

    fmt.Println(age)  // Выведет: 30
    fmt.Println(addr) // Выведет адрес в памяти, например: 0xc000012088
}

Тип переменной addr — *int. Звездочка перед типом означает «указатель на этот тип». В Go строгая типизация: *string и *int — разные типы, их нельзя смешивать или сравнивать.

Dereferencing: доступ к данным по адресу

Чтобы прочитать или изменить значение, на которое указывает адрес, используйте Dereferencing (разыменование). Для этого перед именем переменной-указателя ставится оператор *.

Как показано в Сравнении 1, работа с указателем принципиально отличается от работы с обычным значением.

Здесь мы меняем данные в первоисточнике через указатель:

func main() {
    score := 100
    p := &score // p хранит адрес score

    fmt.Println(*p) // Dereferencing: читаем значение (100)

    *p = 200 // Записываем новое значение по адресу
    fmt.Println(score) // score изменился на 200
}

Зачем это нужно в бэкенде

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

Указатели решают две задачи:

  1. Экономия памяти: вы передаете адрес структуры (8 байт) вместо копирования мегабайтов данных.
  2. Мутация: вы позволяете функции изменять оригинал объекта.

Пример с обновлением профиля пользователя:

Изменения не сохранятся, так как функция updateName получает копию данных. Оригинал в main не изменится.

type User struct {
    Name string
}

func updateName(u User, newName string) {
    u.Name = newName
}

func main() {
    user := User{Name: "Alex"}
    updateName(user, "Dmitry")
    // user.Name все еще "Alex"
}

С указателем функция получает доступ к той же области памяти, где лежит оригинал.

func updateName(u *User, newName string) {
    // Go автоматически разыменовывает указатель при обращении к полю структуры
    u.Name = newName 
}

func main() {
    user := User{Name: "Alex"}
    updateName(&user, "Dmitry")
    // user.Name теперь "Dmitry"
}

Опасность nil-указателей

Попытка разыменовать указатель, равный nil, вызовет немедленную остановку программы — panic. В TypeScript это напоминает Cannot read property of null, но в Go падает весь процесс. ⚡️

var p *int
if p != nil {
    fmt.Println(*p)
} else {
    fmt.Println("Указатель пуст")
}

Напишите программу, которая:

  1. Создает переменную int со значением 42.
  2. Создает указатель на эту переменную.
  3. Меняет значение на 21 через указатель.
  4. Выводит результат в консоль.

Мы разобрались, как управлять данными через адреса. Но где именно в памяти они хранятся? В следующей теме мы изучим Escape analysis и узнаем, как компилятор Go выбирает между быстрым «стеком» и долгоживущей «кучей».

Сохраните прогресс в Telegram.Продолжить в Telegram