Как объявить приватную переменную?

Объявление приватных переменных в Go

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

Основное правило видимости

Публичные идентификаторы (доступные из других пакетов) начинаются с заглавной буквы:

// public.go
package example

// PublicVar доступна из других пакетов
var PublicVar string = "I'm public"

// PublicFunction также доступна извне
func PublicFunction() string {
    return PublicVar
}

Приватные идентификаторы (доступные только внутри текущего пакета) начинаются со строчной буквы:

// private.go
package example

// privateVar недоступна из других пакетов
var privateVar string = "I'm private"

// privateFunction также скрыта от внешнего мира
func privateFunction() string {
    return privateVar
}

// PublicMethod может использовать приватные элементы
func PublicMethod() string {
    // Доступно, потому что мы в том же пакете
    return privateVar + " but accessible here"
}

Практические примеры объявления приватных переменных

1. Приватные переменные уровня пакета

package config

// private константа доступна только внутри пакета config
const privateApiKey = "secret-key-12345"

// private глобальная переменная
var connectionLimit int = 100

// Public функция, использующая приватную переменную
func GetConnectionLimit() int {
    return connectionLimit
}

// Приватная функция для внутреннего использования
func validateKey(key string) bool {
    return key == privateApiKey
}

2. Приватные поля структур

package bank

// Account структура с приватными полями
type Account struct {
    // Публичное поле
    Owner string
    
    // Приватные поля (начинаются со строчной буквы)
    balance float64
    isActive bool
    transactions []string
}

// Конструктор для создания аккаунта
func NewAccount(owner string, initialBalance float64) *Account {
    return &Account{
        Owner:     owner,
        balance:   initialBalance,
        isActive:  true,
        transactions: []string{"Account created"},
    }
}

// Публичные методы для доступа к приватным полям
func (a *Account) Deposit(amount float64) {
    if amount > 0 && a.isActive {
        a.balance += amount
        a.transactions = append(a.transactions, 
            fmt.Sprintf("Deposit: +%.2f", amount))
    }
}

func (a *Account) GetBalance() float64 {
    return a.balance
}

// Приватный метод (доступен только внутри пакета bank)
func (a *Account) addTransaction(description string) {
    a.transactions = append(a.transactions, description)
}

3. Приватные переменные в функциях и методах

package cache

import "sync"

// Cache структура с приватными полями
type Cache struct {
    mu    sync.RWMutex  // приватное поле мьютекса
    items map[string]interface{}
    
    // Приватная переменная-счетчик
    hitCount  int
    missCount int
}

// Публичный метод, использующий приватные поля
func (c *Cache) Get(key string) (interface{}, bool) {
    c.mu.RLock()  // доступ к приватному полю mu
    defer c.mu.RUnlock()
    
    value, exists := c.items[key]
    if exists {
        c.hitCount++  // модификация приватного поля
        return value, true
    }
    
    c.missCount++  // модификация приватного поля
    return nil, false
}

// Приватный метод для внутренней очистки
func (c *Cache) clearExpired() {
    // Логика очистки устаревших записей
    // Доступен только внутри пакета cache
}

Ключевые особенности приватности в Go

Пакет-ориентированная видимость

• Приватные идентификаторы видны во всем пакете, а не только в одном файле
• Все файлы одного пакета имеют доступ ко всем приватным идентификаторам этого пакета

// file1.go
package data

var internalCounter int  // приватная переменная

// file2.go
package data

func IncrementCounter() {
    internalCounter++  // ДОСТУПНО - тот же пакет!
}

Отсутствие модификаторов доступа

В Go нет ключевых слов private, protected, public как в других языках. Вся система основана на регистре первой буквы.

Инкапсуляция на уровне пакета

• При проектировании пакетов важно правильно группировать связанные сущности
• Приватные элементы защищают внутреннюю реализацию пакета
• Публичный API пакета формируется через экспортируемые идентификаторы

Лучшие практики

1. Сокрытие реализации

   package queue
   
   // Приватная структура - реализация скрыта
   type queue struct {
       items []interface{}
       mu    sync.Mutex
   }
   
   // Публичный интерф>ейс
   type Queue interface {
       Enqueue(item interface{})
       Dequeue() interface{}
   }
   
   // Фабричная функция возвращает интерфейс
   func NewQueue() Queue {
       return &queue{items: make([]interface{}, 0)}
   }
   

2. Использование приватных переменных для состояния

   package metrics
   
   var (
       requestCount int
       errorCount   int
       // приватные переменные для внутреннего состояния
   )
   
   func RecordRequest() {
       requestCount++
   }
   
   func GetStats() map[string]int {
       return map[string]int{
           "requests": requestCount,
           "errors":   errorCount,
       }
   }
   

Важные замечания

• Приватность не обеспечивает безопасность в традиционном смысле - это механизм инкапсуляции, а не защиты от злонамеренного доступа
• Тесты в том же пакете имеют доступ к приватным идентификаторам, что позволяет писать unit-тесты для внутренней логики
• Рефлексия (package reflect) может обходить ограничения приватности, но это считается антипаттерном в обычном коде

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