1. Переменные и константы

В Golang переменные и константы - это два фундаментальных понятия, играющих очень важную роль в программе.

  • Переменная - это именованный идентификатор, используемый для хранения данных в программе. В Golang ключевое слово var используется для объявления переменных.
  • Константа - это идентификатор, значение которого нельзя изменить в программе. В Golang для объявления констант используется ключевое слово const.

2. Объявление и инициализация переменных в Golang

2.1. Объявление и присвоение значения одной переменной

В языке Go ключевое слово var используется для объявления переменной в формате var имя_переменной тип. После объявления переменной ей может быть присвоено значение в последующем коде, либо она может быть непосредственно инициализирована в момент объявления. Например:

var возраст int // Объявить переменную типа integer под названием возраст
возраст = 25    // Присвоить значение переменной

var имя string = "Алиса" // Объявление и инициализация переменной имени

2.2. Объявление нескольких переменных

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

var (
    Имя, Фамилия string
    возраст       int
)

Имя = "Джон"
Фамилия = "Доу"
возраст = 30

В вышеприведенном массовом объявлении Имя и Фамилия объявлены как строки, а возраст как целое число.

2.3. Вывод типа и краткое объявление переменных

В языке Go не всегда необходимо явно указывать тип переменной. Если предоставлено выражение инициализации при объявлении переменной, Go может вывести тип переменной. Это известно как вывод типа. Краткое объявление переменных с помощью := может упростить объявление и инициализацию переменных на основе вывода типа. Например:

город := "Пекин" // Использование краткого объявления переменной для одновременного объявления и инициализации города
страна := "Китай" // тип переменной страна выводится как string

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

2.4. Объявление переменных за пределами функций

Переменные, объявленные за пределами функций, имеют область видимости на уровне пакета. Они видимы и доступны на протяжении всего пакета. Например:

var глобальнаяПеременная string = "Я глобальная" // Объявление глобальной переменной

func печатьГлобальнойПеременной() {
    fmt.Println(глобальнаяПеременная) // Доступ к глобальной переменной внутри функции
}

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

Совет: Достаточно понимания основного кода функций, более подробные объяснения функций будут предоставлены в последующих разделах.

3. Основные типы данных и нулевые значения

3.1. Основные типы данных в Golang

В языке Go каждый тип переменной предоставляет явные семантические и поведенческие характеристики. Вот некоторые распространенные основные типы данных:

  • int, int8, int16, int32, int64: Различные диапазоны целых чисел
  • uint, uint8, uint16, uint32, uint64: Беззнаковые целые числа
  • float32, float64: Числа с плавающей точкой
  • bool: Булевы значения (true или false)
  • string: Строки

3.2. Понятие нулевых значений

В языке Go переменные автоматически инициализируются нулевым значением своего типа после объявления. Нулевое значение относится к стандартному значению соответствующего типа, когда переменная не явно инициализирована. Это необычно для некоторых других языков, но в Go это гарантирует, что все переменные всегда имеют действительное начальное значение. Вот нулевые значения для каждого основного типа данных:

  • Нулевое значение для целого числа - 0
  • Нулевое значение для числа с плавающей точкой - 0.0
  • Нулевое значение для булевого значения - false
  • Нулевое значение для строки - пустая строка ""

Например:

var i int     // Нулевое значение - 0
var f float64 // Нулевое значение - 0.0
var b bool    // Нулевое значение - false
var s string  // Нулевое значение - ""

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

4. Область видимости переменных

4.1 Локальные переменные

Локальные переменные - это переменные, определенные внутри функции, и к ним можно обратиться только внутри этой функции. Параметры функции также относятся к локальным переменным. С момента создания до завершения выполнения функции локальные переменные исчезают. Каждый раз, когда вызывается функция, локальные переменные создаются заново.

func localVariableExample() {
    var localVariable int = 10 // Это локальная переменная
    fmt.Println(localVariable)
}

func main() {
    localVariableExample() // Вывод: 10
    // fmt.Println(localVariable) // Это вызовет ошибку компиляции, потому что localVariable здесь не видна
}

В приведенном выше примере localVariable может быть доступна только внутри функции localVariableExample.

4.2 Глобальные переменные

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

package main

import "fmt"

var globalVariable int = 20 // Это глобальная переменная

func main() {
    fmt.Println(globalVariable) // Вывод: 20
    changeGlobal()
    fmt.Println(globalVariable) // Вывод: 30
}

func changeGlobal() {
    globalVariable = 30 // Изменить значение глобальной переменной
}

В этом примере globalVariable видна как в функции main, так и в функции changeGlobal.

5 Объявление и использование констант

5.1 Ключевое слово const

Мы используем ключевое слово const для определения констант. Константы - это значения, которые нельзя изменить, и после определения их значение нельзя изменить. Константы могут быть любого базового типа данных, такого как целые числа, числа с плавающей запятой, булевы значения или строки.

const Pi = 3.14 // Объявить вещественную константу
const StrConst string = "Привет, мир!" // Объявить строковую константу

func main() {
    fmt.Println(Pi)
    fmt.Println(StrConst)
}

5.2 Перечисление констант

В языке Go нет специального типа перечислений, но вы можете использовать ключевое слово iota для создания перечислений. В пределах блока const каждое дополнительное объявление константы увеличит значение iota на 1.

const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

func main() {
    fmt.Println(Sunday)    // Вывод: 0
    fmt.Println(Saturday)  // Вывод: 6
}

В приведенном выше коде объявляется перечисление для дней недели, где iota инициализируется значением 0 в пределах блока const и увеличивается на 1 для каждого последующего объявления.

5.3 Область видимости констант

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

Управление областью видимости констант помогает уменьшить загрязнение глобальной области видимости и улучшает поддерживаемость и читаемость программы.

const GlobalConst = "Это глобальная константа"

func main() {
    const LocalConst = "Это локальная константа"
    fmt.Println(GlobalConst)  // Это допустимо
    fmt.Println(LocalConst)   // Это допустимо
}

func anotherFunction() {
    // fmt.Println(LocalConst) // Это вызовет ошибку компиляции: LocalConst не видна в этой функции
    fmt.Println(GlobalConst)  // Это допустимо
}

В этом примере LocalConst может быть доступна только внутри функции main, в то время как GlobalConst может быть доступна во всем пакете.