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

Это крат­кое руко­вод­ство по основ­ным кон­струк­ци­ям язы­ка 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 < 8; i++ {

        sum += 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())
}

Текст:

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

Редак­ту­ра:

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

Худож­ник:

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

Кор­рек­тор:

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

Вёрст­ка:

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

Соц­се­ти:

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