10 главных конструкций языка Go

Это краткое руководство по основным конструкциям языка Go для тех, кто только начинает разбираться в языке. Зачем? Чтобы был.

👉 Точка с запятой после команд в Go не ставится.

// Это однострочный комментарий,

который действует только на той строке, где есть два слеша подряд
/* А это многострочный комментарий.

С помощью звёздочки и слеша можно писать

длинные комментарии на несколько строк.

Всё, что между ними, — это комментарий */

Структура программы

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

Начинающим программистам: что такое фреймворки и библиотеки

// название программы (пакета)
package main

// подгружаем нужные пакеты, если команды из этих пакетов понадобятся в нашей программе
import "fmt"

// основная функция — main — означает, что её содержимое и будет выполняться после запуска программы
// кроме неё в программе может быть сколько угодно других функций
func main() {
	// содержимое функции
    fmt.Println("Hello World")
}

Переменные, константы и типы данных

Переменная (может менять значение в любой момент): var.

Константа (не может менять значение после объявления): const.

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

var x string
	// строковая переменная с заданным значением, которое можно менять
	// для этого сразу после объявления переменной можно написать её стартовое значение
	var x1 string = "Привет, это журнал Код"
	// целые числа
	var y int
	var y1 int32 = 42

	// дробное число
	var z float32 = 22.2

Ввод и вывод

Что подключить: библиотеку fmt: import "fmt"

Вывод:

Print() ← выводим что-то и оставляем курсор на этой же строке
Println () ← выводим что-то и переводим курсор на новую строку
Printf() ← чтобы вставлять значения переменных в текст

func main() {
	// оставляем курсор на той же строке
    fmt.Print("Привет,")
    // готовим переменную для вывода
    fmt.Println(" это журнал Код")
    var output int32 = 50
    // Вставляем переменную в середину вывода
	fmt.Printf("За 2010 год я проехал %v городов, ", &output)
}

Ввод:

Scan(&имя_переменной) ← чтобы просто поместить введённое значение в переменную;
Scanf(%формат, &имя_переменной) ← чтобы заранее указать тип данных, которые будем вводить.

func main() {
    fmt.Print("Введите число")
    // готовим переменную для ввода
    var input float64
    // читаем данные с клавиатуры и ждём от пользователя ввода дробного числа
    fmt.Scanf("%f", &input)
    // вторая переменная для ввода
    var input2 string
    // вводим что-то с клавиатуры и кладём это в строковую переменную
    fmt.Scan(&input2)
}

Присваивание и сравнение

Присваивание обозначается одним знаком равно, а проверка на равенство — двумя.

       // присваивание
	y = 10
	var y1 int32 = 42
	// сравнение
	fmt.Print(y1 == 10)

Условный оператор if

При одиночном сравнении скобки можно не ставить. Открывающая скобка остаётся на той же строке, что и условие:

package main
 
import "fmt"
 
func main() {
 	// если условие верное
    if ID == "Apple" {         
    	// то выполняем то, что идёт в скобках
        fmt.Println("Введите свой логин и пароль")
    // если условие не выполнилось, то можно сразу проверить ещё одно условие
    // так можно делать сколько угодно раз
    } else if ID =="Google" { 
    	// выводим второй ответ
        fmt.Println("Ваша операционная система не поддерживается")
    // выполняем то, что относится к последнему if
    } else {                                                       
         fmt.Println("Ошибка ввода")
    }
}

Оператор множественного выбора switch

После первого найденного варианта оператор выполняет нужные действия и прекращает работу.

// перебираем возможные варианты для переменной  ID
switch ID {
	// проверяем одно значение
	case "Apple":
	    fmt.Println("Введите свой логин и пароль")
	// проверяем второе значение
	case "Google":                
	    fmt.Println("Ваша операционная система не поддерживается")
	// если ничего нужного не нашлось
	default:
	    fmt.Println("Ошибка ввода")
}

Цикл с предусловием for

Самый простой цикл — можно объявить только условие, а остальное сделать внутри цикла:

package main
 
import "fmt"
 
func main() {
	// переменная для цикла
    var count = 10          
 	// пока переменная больше 0 — цикл работает
    for count > 0 {    
        // выводим текущее значение переменной
        fmt.Println(count)
        // уменьшаем её на единицу
        count = count - 1          
    }
}

Ещё есть варианты цикла for как в С или С++ — с переменной, условием и шагом цикла:

for i := 0; i Функции

При объявлении функции нужно указать:

какого типа переменные передаются в функцию как параметры;
какого типа данные возвращает функция.

package main
 
import "fmt"
 
// функция, которая перемножает два числа
// у неё два входных параметра — x и y, дробные числа
// функция возвращает тоже дробное число
func multiply(x,y float64) float64 {
    var res
    res = x * y
    // возвращаем результат работы функции
    return res
}
 
// началась основная функция
func main() {
	// множители
    var x float64 = 15
    var y float64 = 120.6

    // переменная для результата
    var mult float64

    // получаем результат работы функции
    mult = multiply(x,y)

    // выводим ответ
    fmt.Print(mult)
 }

Структуры

В Go нет привычных для ООП классов, но есть структуры. Технически можно использовать структуры для объявления класса и через них создавать новые объекты, но нужно следить за синтаксисом.

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

package main
 
import "fmt"

// структура, которая отвечает за круг в программе
type Circle struct {
	// координаты круга
    x float64
    y float64

    // радиус
    r float64
}
 
// началась основная функция
func main() {
	// создаём новый экземпляр структуры (объект)
	var c Circle

	// ещё один способ создать новый экземпляр
	c1 := new(Circle)

	// если мы при создании знаем стартовые значения
	// круг с центром (10,20) и радиусом 5
	c2 := Circle(10,20,5)
}

Методы

Методы в Go не встраиваются в структуры (классы) напрямую, а прописываются отдельно. Чтобы понять, какой метод к чему относится, в него добавляют ссылку на структуру, с которой этот метод будет работать.

package main
 
import "fmt"

type Circle struct {
    x float64
    y float64
    r float64
}

// метод для структуры, который вернёт нам площадь круга
// при объявлении метода мы обязательно указываем имя структуры, с которой метод работает
func (c *Circle) area() float64 {
	// считаем и возвращаем площадь круга
    return math.Pi * c.r*c.r
}

 
// началась основная функция
func main() {
	// создаём новый круг
	c2 := Circle(10,20,5)
	// выводим площадь круга
	fmt.Println(c.area())
}

Текст:

Михаил Полянин

Редактура:

Максим Ильяхов

Художник:

Даня Берковский

Корректор:

Ирина Михеева

Вёрстка:

Мария Дронова

Соцсети:

Олег Вешкурцев