В этом посте мы поговорим о типах в Go.

В этом посте мы поговорим о типах в Go. У нас есть настроенная среда разработчика, поэтому мы готовы погрузиться в код Golang.

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

  • Какие виды доступны нам?
  • Присвоение значений в Go
  • Константы в Go

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

Какие виды доступны нам?

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

  • Логические значения (истинные или ложные значения)
  • Целые числа (например, 1, 2, 3)
  • Поплавки (например, 1.0, 2.0, 3.0)
  • Строки (например, «Привет!»)

С целыми числами у нас есть обычные операторы, которые мы нашли бы в других языках: +, *, /, - и % для операций модуля. Мы также можем комбинировать любой из этих операторов с = для изменения значения переменной. Например:

var myNumber int = 10
myNumber *= 2
// myNumber is now 20

Нулевое значение (или значение по умолчанию) для всех целочисленных типов равно 0. Мы также можем выполнять операции сравнения с целыми числами, используя ==, !=, >, >=, <, <=.

Теперь обратимся к поплавкам. Поплавки в Go похожи на поплавки в других языках программирования, и Go поддерживает два разных типа поплавков: float32 и float64. Литералы с плавающей запятой имеют тип по умолчанию float64. Чтобы использовать поплавки, мы можем сделать это следующим образом:

var number3 float64 = 5.0
number4 := 3.0

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

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

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

var greeting string = "This is a string!"
fmt.Println(greeting)
// This prints out "This is a string!"

Подобно целым числам и числам с плавающей запятой, мы можем выполнять операции над нашими строками. Мы можем сравнить их, используя == или !=, и мы можем упорядочить их, используя >, >=, <, <=. Мы можем объединить строки вместе следующим образом:

fmt.Println("Hello, " + "World")
// Prints out Hello, World

Присвоение значений в Go

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

var greeting string = "Hello!"

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

var number1, number2 int = 10, 20

Мы также можем объявлять переменные без указания типа. Go сделает вывод, к какому типу относится переменная, когда мы ее инициализируем. Таким образом, в следующем фрагменте предполагается, что переменная isTypeSpecified имеет логический тип:

var isTypeSpecified = false

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

number1 := 5

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

Мы также можем объявить наши переменные, используя так называемый список объявлений:

var (
    number1 int
    number2 = 20
    number3 int = 30
    number4, number5 = 40, 50
    number6, number7 int
)

Константы в Go

Go также поддерживает константы. Это постоянные значения, которые не меняются. Мы можем объявить константы так

constant statement string = "This is a constant statement"

Константы могут появляться везде, где мы помещаем наш var statements. Они также могут быть объявлены вне наших функций, поэтому, например, следующий код Go действителен:

const number1 int = 10
func main() {
    const number2 int = 20
}

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

const myNumber int = 10
myNumber = 10 + 1

Заключение

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

Если у вас есть какие-либо вопросы, не стесняйтесь обращаться ко мне в твиттере @willvelida, и я постараюсь помочь, чем смогу.

В следующем посте мы начнем создавать программы на Go, используя операторы If, if/else и else/if.

До следующего раза, счастливого кодирования! 🤓🖥️