Вариабельные и константные понятия являются основными в большинстве языков программирования. Они являются строительными блоками для хранения и управления данными.

В этой статье мы рассмотрим, как работают переменные и константы в Go.

Содержание:

Что такое переменные?

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

Пример:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

Мы создали переменную с идентификатором myName, которая содержит строковое значение.

Если вы заметили, мы изменили значение на другую строку, и можем делать это несколько раз, поскольку переменные позволяют это делать.

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

Как создавать переменную в Go

В Go существует два основных способа создания переменной: явное объявление и короткое объявление.

Явное объявление

Это традиционный способ создания переменной в Go. Он работает с использованием ключевого слова var и определением типа переменной, что делает ваш код более читабельным и ясным.

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

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

output:
25 Temitope 5.7

Ключевое слово var и тип данных также можно использовать без инициального значения:

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

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

Короткое объявление переменной

Синтаксис краткой декларации переменных (:=) представляет собой более компактный способ объявления переменных. Этот метод позволяет объявить и инициализировать переменную в одной строке без явного указания ее типа, так как тип выводится из присваиваемого значения.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

В этом случае каждая переменная была объявлена вместе с ее значением, и Go выводит тип данных. Например, age была объявлена и инициализирована с значением 25, и Go угадал ее тип как int. name была объявлена с значением “Temitope”, и Go угадал ее тип как string. В конце концов, height была объявлена с 5.7, и Go угадал ее тип как float64.

output:
25 Temitope 5.7

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

Множественные объявления переменных

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

package main

import "fmt"

func main() {

    var age, height int = 25, 180

    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)

    fmt.Println(name, city)
}

В этом случае переменные age и height объявлены как целые числа и инициализированы значениями 25 и 180, соответственно. Переменные name и city также объявлены как строки и инициализированы значениями “Temitope” и “New York”:

Output:
25 180
Temitope New York

Вы также можете объявить несколько переменных в блоке, например так:

package main

import "fmt"

func main() {

    var (
        age int = 25

        name string = "Temitope"

        height int = 180

        city string = "New York"
    )

    fmt.Println(age, name, height, city)

}

Здесь переменные age, name, height и city объявлены внутри одного блока var, каждая переменная на своей строке.

Output:
25 Temitope 180 New York

Значения нуля

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

package main

import "fmt"

func main() {

    var intValue int

    var floatValue float64

    var boolValue bool

    var stringValue string

    var ptrValue *int

    var sliceValue []int

    var mapValue map[string]int

    fmt.Println("Zero values:")

    fmt.Println("int:", intValue)

    fmt.Println("float64:", floatValue)

    fmt.Println("bool:", boolValue)

    fmt.Println("string:", stringValue)

    fmt.Println("pointer:", ptrValue)

    fmt.Println("slice:", sliceValue)

    fmt.Println("map:", mapValue)

}

В указанном выше коде произойдет следующее:

  • 整数 intValue будет иметь нулевое значение 0.

  • 浮点数 floatValue будет иметь нулевое значение 0.

  • 布尔值 boolValue будет иметь нулевое значение false.

  • 字符串 stringValue будет иметь нулевое значение “” (пустая строка).

  • Ссылка ptrValue, слайс sliceValue и карта mapValue все будут иметь нулевое значение nil.

Вывод:

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

Что такое область видимости переменной?

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

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

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

    fmt.Println("Initial Counter:", globalCounter)

    incrementCounter()

    fmt.Println("After Increment:", globalCounter)

}

В вышеуказанном примере globalCounter является глобальной переменной, и она доступна как функции incrementCounter, так и функции main.

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

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

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

В указанном выше коде у нас есть localCounter как локальная переменная внутри функции incrementCounter. Каждый раз, когда вызывается incrementCounter, создается новая localCounter, инициализируется с 0 и увеличивается.

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

Соглашения о именовании в Go

Правильное именование переменных критически важно для написания чистого, читаемого и поддерживаемого кода. В Go есть особые соглашения и правила для именования переменных. Ниже приведены некоторые из них:

  • Использование описательных имён: Используйте имена, которые четко описывают цель или содержимое переменной. Например, вместо неясных имён, таких как x или y, используйте имена, такие как age, totalPrice или userName, которые ясно выражают, что представляет собой переменная.
  • Использование CamelCase для имён с несколькими словами: В Go принято использовать CamelCase для имён переменных, состоящих из нескольких слов. Первое слово начертано маленьким字母, а в начале каждого следующего слова находится большая буква.
  • Отказаться от использования подчерки: Unlike some other languages, Go prefers camelCase over using underscores to separate words in variable names. Stick to camelCase to adhere to Go’s idiomatic style.
  • Используйте краткие имена для переменных кратковременного использования: Для переменных кратковременного использования, таких как счетчики циклов или индексы, можно использовать краткие имена, такие как i, j или k.

Что такое константы в Go?

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

Представьте себе, что вы строите онлайн-магазин, где стандартная стоимость доставки всегда составляет $10. Вы можете объявить это как константу, чтобы использовать ее в вашей программе каждый раз, когда нужно применять стоимость доставки. Если ставки доставки изменятся, вам нужно будет обновить значение только в одном месте.

Как объявлять константы в Go

Вы можете объявлять константы, используя ключевое слово const, за которым следует имя, тип (необязательно, если значение подразумевает тип) и значение константы. Вот как это делается:

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

Если вы попытаетесь изменить константу после ее объявления, то получите ошибку компиляции.

Типы констант в Go

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

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

package main

import "fmt"

const gravity = 9.81

func main() {

    var height int = 10

    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)

}

В этом месте gravity является нетипизированной константой. Это意味着 Go может инFERнтить ее тип на основании того, как она используется. когда gravity используется в вычислениях с float64, Go автоматически третит ее как float64.

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

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

В этом месте speedOfLight является типизированной константой с типом int.

Она может использоваться только в операциях с другими значениями int или явно преобразована к другому типу.

Итак, все

В этой статье мы посмотрели, что таковы переменные и константы и как их декларировать в Go.

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

Поделитесь, если это вам помогло.