Начало работы с Go: основы

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

Go, также известный как Golang, был разработан Google как язык программирования с открытым исходным кодом. Он был разработан, чтобы быть простым в освоении и использовании, с упором на простоту и удобочитаемость. Go — это язык со статической типизацией. Это означает, что переменные должны быть объявлены с определенным типом, например string или int, прежде чем их можно будет использовать. Это может помочь выявить ошибки на ранней стадии и сделать код более надежным.

Синтаксис

Давайте углубимся в синтаксис Go. Go использует фигурные скобки для заключения блоков кода, а строки не заканчиваются точкой с запятой. Вот простой пример, который выводит на консоль Hello, World!:

package main

import "fmt"

func main() {
  fmt.Println("Hello, 世界!")
}

В этом примере у нас есть пакет с именем main, который представляет собой специальный пакет в Go, определяющий точку входа для программы. Оператор import позволяет нам использовать функции из других пакетов, в данном случае fmt package, который предоставляет функции ввода/вывода. Основная функция является отправной точкой для программы и содержит код, который мы хотим выполнить. Функция fmt.Println используется для вывода строки на консоль.

Мы также можем использовать оператор import для импорта нескольких пакетов в одну строку:

import (
  "fmt"
  "math"
)

Типы данных

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

var i int = 42
var f float64 = 3.14
var s string = "Hello, Go!"
var b bool = true

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

i := 42
f := 3.14
s := "Hello, Go!"
b := true

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

Вот пример того, как объявить и инициализировать константу в Go:

const pi = 3.14159265

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

var a [3]int = [3]int{1, 2, 3}

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

s := []int{1, 2, 3}

Чтобы добавить элемент в конец массива или среза, вы можете использовать функцию append. Например:

var arr [5]int
// Append the value 10 to the end of the array
arr = append(arr, 10)

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

arr := [5]int{1, 2, 3, 4, 5}
// Create a new array without the element at index 2
newArr := append(arr[:2], arr[3:]...)
fmt.Println(newArr) // Output: [1 2 4 5]

Структуры управления

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

if x > 0 {
  fmt.Println("x is positive")
}

Мы также можем использовать предложение else для выполнения другого блока кода, если условие ложно:

if x > 0 {
  fmt.Println("x is positive")
} else {
  fmt.Println("x is not positive")
}

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

switch x {
case 1:
  fmt.Println("x is 1")
case 2:
  fmt.Println("x is 2")
default:
  fmt.Println("x is not 1 or 2")
}

В этом фрагменте оператор switch проверит значение x и выполнит соответствующий блок кода. Если x равно 1, будет напечатано «x равно 1». Если x равно 2, будет напечатано «x равно 2». Если x не является ни 1, ни 2, будет напечатано «x не равно 1 или 2».

В Go есть несколько вариантов цикла for. Классическая версия for позволяет выполнять блок кода несколько раз. Вот пример использования цикла for:

for i := 0; i < 10; i++ {
  fmt.Println(i)
}

В этом примере цикл for будет повторяться 10 раз, начиная с 0 и заканчивая 9. На каждой итерации он выводит текущее значение i на консоль.

Другая версия — это цикл range, который позволяет нам перебирать элементы массива, среза, строки или другой коллекции:

a := [3]int{1, 2, 3}

for i, v := range a {
  fmt.Printf("index %d, value %d\n", i, v)
}

Здесь цикл for range будет перебирать каждый элемент в массиве a, и на каждой итерации он будет присваивать текущий индекс переменной i и текущее значение переменной v. Затем он выведет индекс и значение на консоль.

Цикл for range — это удобный способ перебора элементов коллекции и выполнения действия над каждым элементом. Это особенно полезно для работы со срезами и строками, так как позволяет нам легко получить доступ как к индексу, так и к значению каждого элемента.

Имейте в виду, что цикл for range является циклом только для чтения, что означает, что мы не можем изменять элементы коллекции внутри цикла. Если нам нужно изменить элементы коллекции, мы можем использовать обычный цикл for или синтаксис присвоения индекса и значения для прямого доступа и изменения элементов. Подробнее об этом в следующей статье.

Другим вариантом цикла for является пустой цикл for, в котором нет инициализатора, условия или оператора приращения. Пустой цикл for часто используется как бесконечный цикл, поскольку он не имеет условия выхода. Вот пример пустого цикла for:

for {
  fmt.Println("Enter a number:")
  var n int
  fmt.Scanln(&n)
  if n == 0 {
    break
  }
  fmt.Println("You entered:", n)
}

В этом примере цикл for будет выполняться бесконечно, предлагая пользователю ввести число на каждой итерации. Если пользователь введет 0, будет выполнен оператор break, и цикл будет закрыт. Если пользователь вводит ненулевое число, цикл продолжится и выведет введенное число на консоль.

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

for i := 0; i < 10; i++ {
  if i%2 == 0 {
    continue
  }

  fmt.Println(i)
}

На каждой итерации оператор if будет проверять, является ли текущее значение i четным. Если это так, будет выполнен оператор continue, а остальные операторы в цикле будут пропущены.

Функции

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

func add(x int, y int) int {
  return x + y
}

Мы можем вызвать функцию add следующим образом:

result := add(1, 2)

В этом фрагменте функция add будет вызываться с аргументами 1 и 2, а результат будет сохранен в переменной result.

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

func add(x, y int) int {
  return x + y
}

В этой версии функции add мы можем опустить тип параметров x и y, потому что Go может вывести их тип из типа возвращаемого значения.

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

func sumAndDiff(x, y int) (int, int) {
  return x + y, x - y
}

Мы можем вызвать эту функцию и присвоить возвращаемые значения переменным следующим образом:

sum, diff := sumAndDiff(1, 2)

Функции Go также могут иметь именованные возвращаемые значения, что упрощает чтение и понимание кода. Вот пример функции с именованными возвращаемыми значениями:

func sumAndDiff(x, y int) (sum int, diff int) {
  sum = x + y
  diff = x - y
  return
}

В этой версии функции sumAndDiff мы определили переменные sum и diff как возвращаемые значения функции. Когда мы вызываем функцию и присваиваем возвращаемые значения переменным, Go автоматически присваивает значения соответствующим переменным.

Функции в Go также могут иметь параметры variadic, что позволяет им принимать переменное количество аргументов. Чтобы определить переменный параметр, мы используем синтаксис ..., за которым следует тип параметра. Вот пример функции, которая вычисляет сумму переменного количества целых чисел:

func sum(numbers ...int) int {
  result := 0
  for _, n := range numbers {
    result += n
  }
  return result
}

В этом примере функция sum имеет переменный параметр numbers типа int. Когда мы вызываем функцию, мы можем передать столько целых чисел, сколько захотим, а Go создаст слайс со всеми аргументами и назначит его параметру numbers.

Это обертка

Это краткий обзор некоторых основных концепций Go. В следующей статье мы рассмотрим больше тем, таких как структуры, указатели и интерфейсы.

Вы можете узнать больше о Evendyne здесь.