1. Организационный этап (2 мин)

УУД:

- Личностные

- Коммуникативные

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

2. Вводная часть (5 мин)

УУД:

- Личностные

- Познавательные

- Коммуникативные

Язык программирования Go, также известный как Golang, был разработан в Google в 2007 году Робертом Гриземером, Робом Пайком и Кеном Томпсоном. Он стал открытым исходным кодом в 2009 году.

Go (или Golang) — это компилируемый, статически типизированный язык программирования, разработанный в Google. Он был создан для упрощения разработки масштабируемых и эффективных программ, особенно в многопоточной среде. Go обладает минималистичным синтаксисом, что делает его легким для изучения и использования. В языке отсутствуют сложные конструкции, такие как наследование и исключения, что также упрощает код.

В этой статье вы узнаете, как написать простое CLI-приложение (интерфейс командной строки) на Go. Сначала мы кратко разберём ключевые особенности языка. Затем обсудим базовую структуру файла в Go. Рассмотрим основные типы данных и конструкции языка.

3. Практическая работа на компьютерах (20 мин)

УУД:

- Личностные

- Познавательные

- Знаково-символические

- Коммуникативные

Установка на Windows

1. Скачайте установщик
   Перейдите на официальный сайт Go и скачайте файл с расширением .msi для Windows.
2. Запустите установщик
   Дважды кликните на скачанный файл (например, go1.21.1.windows-amd64.msi).
   Следуйте инструкциям мастера установки (рекомендуется использовать путь по умолчанию C:\Go).
3. Проверьте переменную PATH
   Установщик автоматически добавляет Go в системную переменную PATH.
   Чтобы проверить, откройте командную строку и выполните:

go version

Если команда не работает, перезагрузите систему или проверьте PATH вручную:

• Панель управления → Система → Дополнительные параметры системы → Переменные среды → Path.

2. Проверьте установку

go version

Пример вывода: go version go1.21.1 linux/amd64.

3. Настройка рабочей директории (опционально)
   Создайте папку для проектов и добавьте в ~/.profile:
4. export GOPATH=$HOME/go

export PATH=$PATH:$GOPATH/bin

Первая программа

Откройте папку «go-projects» (или как вы ее назвали) с помощью VS Code (или вашего редактора кода на выбор). Создайте папку «hello-go» и создайте файл main.go. Вы можете дать обсолютно лубое название этому файлу.

Далее напишите классический код, с которого многие начинали свой путь в IT.

package main

import "fmt"

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

Ниже разберём что делает этот код.

• Объявление пакета (package main): Каждая программа на Go начинается с объявления пакета, указывающего, к какому пакету принадлежит файл. Пакет main - особый пакет, так как он является точкой входа для исполняемых программ.
• Импорт пакета fmt (import "fmt"): В Go вы импортируете пакеты, чтобы использовать их функции и возможности. Здесь мы импортируем пакет fmt, который означает «формат» и используется для операций ввода и вывода.
• Функция main(func main()): Каждая исполняемая программа на Go должна иметь main функцию. Когда вы запускаете свою программу, она выполняется первой.
• Вывод теста в консоль (fmt.Println(«Hello World»)): В этой строке используется функция Println из пакета fmt для печати текста «Hello World» в консоли. Функция Println используется для печати с символом новой строки в конце, поэтому следующий вывод появляется на новой строке.

Пакеты в Go

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

Программы запускаются в пакете main. Пример программы, использующей пакет с путем импорта "fmt":

package main

import "fmt"

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

Пути импорта

В Go путь импорта - это уникальный идентификатор пакета. Он указывает расположение пакета в системе модулей Go и используется в операторе import для подключения внешних зависимостей.

Типы пакетов:

1. Стандартные пакеты
2. Пакеты из стандартной библиотеки Go подключаются по их имени:

import "fmt"

3. Удаленные пакеты (из репозиториев)
   Go позволяет импортировать пакеты напрямую из репозиториев (GitHub, GitLab и др.):

import "github.com/che1nov/hello-go"

Пакет main

Объявление package main всегда указывается в начале файла, как показано в примере выше. Функция main() внутри этого пакета является точкой входа программы.

Модули в Go

Модуль - это коллекция пакетов. Он содержит информацию о проекте: зависимости, версию Go, метаданные пакетов. Все проекты на Go имеют файл go.mod.

Команда для инициализации файла go.mod через терминал:

go mod init

Где module-path соответствует пути импорта пакета.

Инициализация go.mod через терминал

Содержимое файла go.mod

Команда go
«Команда Go» (go)  это инструмент командной строки в языке программирования Go. Позволяет использовать инструменты для разработки такие как:

• Для запуска кода применяется go run, который компилирует и сразу выполняет программу.
• Чтобы собрать исполняемый файл, используется go build, преобразующий исходный код в бинарный файл.
• Тестирование кода осуществляется через go test для текущего пакета или go test ./... для всех поддиректорий.
• Управление зависимостями с модулями включает команды: go mod init для создания нового модуля и файла go.mod, go get для загрузки пакетов, go mod tidy для очистки неиспользуемых зависимостей и go list -m all для просмотра списка зависимостей.
• Документацию можно просматривать через go doc, указав пакет или элемент.
• Анализ зависимостей выполняется с помощью go list для информации о пакетах и go list -m -versions  для списка версий модуля.
• Форматирование кода автоматизирует go fmt,
• Информация о среде Go доступна через go env.

Эти команды упрощают разработку, сборку, тестирование и поддержку проектов.

Переменные в Go

Переменная - это именованное значение. Переменные обеспечивают способ хранения и доступа к данным в вашей программе.

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

Одиночное объявление

package main

import "fmt"

func main() {
   var singleVariable int //обьявление переменной
   singleVariable = 10 //присвоение значения 10
   fmt.Println(singleVariable)
}

В примере объявляется переменная singleVariable с явным указанием типа int.

package main

import "fmt"

func main() {
   createAndAssignVar := 42 //обьявление и присвоение значения
   fmt.Println(createAndAssignVar)
}

Но вы ещё можете создать переменную без явного указания типа данных с помощью := , в таком случае тип определится автоматически.

Именование переменных в Go

При именовании переменных в Go используется верблюжий регистр(CamelCase). Например:

const myVariable = 20

Когда вы придумываете имя переменной, рекомендуется давать ей описательное имя, например conferenceName := "Linux" вместо conference := "Linux".

Разница между ключевыми словами var и const в Go

В Go есть два способа объявления переменных: var и const. Для тех, кто знаком с JavaScript, С и С++, это может показаться знакомым.

• var используется для объявления переменных, и их значения могут быть изменены после объявления.
• const используется для объявления констант, и их значения не могут быть изменены после объявления.
  Вот пример использования var и const для объявления переменных:

package main

import «fmt»

func main() {
   // использование var
   var variable1 int = 5
   variable1 = 10 // значение variable1 может быть изменено

   // Использование const
   const constant1 int = 5
   constant1 = 10 // ошибка, константы не могут быть переназначены

   fmt.Println(variable1, constant1)
}

В приведенном выше примере variable1 может быть переназначена на новое значение, в то время как constant1 не может быть переназначена и выдаст ошибку при компиляции.

Операторы в Go

В Go существует 3 основных типа операторов: арифметические операторы, логические операторы и реляционные операторы.

Теперь давайте пройдемся по каждой категории операторов и посмотрим, как они работают, на примерах.

Арифметические операторы

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

package main

import "fmt"

func main() {
   a := 15
   b := 4

   // Арифметические операции
   sum := a + b       // Сложение
   difference := a - b // Вычитание
   product := a * b    // Умножение
   quotient := a / b   // Деление (целочисленное)
   remainder := a % b  // Остаток от деления

   // Вывод результатов
   fmt.Printf("%d + %d = %d\n", a, b, sum)
   fmt.Printf("%d - %d = %d\n", a, b, difference)
   fmt.Printf("%d * %d = %d\n", a, b, product)
   fmt.Printf("%d / %d = %d (целочисленное деление)\n", a, b, quotient)
   fmt.Printf("%d %% %d = %d (остаток)\n", a, b, remainder)
}

Реляционные операторы

Реляционные операторы используются для сравнения значений и принятия решений на основе результатов сравнения. Пример:

package main
import "fmt"
func main() {
   a := 15
   b := 4
   c := 15
   d := "apple"
   e := "banana"

   // Реляционные операторы для чисел
   greater := a > b       // Больше
   less := b < a          // Меньше
   greaterOrEqual := a >= c // Больше или равно
   lessOrEqual := b <= a  // Меньше или равно
   equal := a == c        // Равно
   notEqual := a != b     // Не равно

   // Реляционные операторы для строк (лексикографическое сравнение)
   strCompare := d < e

   // Вывод результатов
   fmt.Printf("Числовые сравнения:\n")
   fmt.Printf("%d > %d → %t\n", a, b, greater)
   fmt.Printf("%d < %d → %t\n", b, a, less)
   fmt.Printf("%d >= %d → %t\n", a, c, greaterOrEqual)
   fmt.Printf("%d <= %d → %t\n", b, a, lessOrEqual)
   fmt.Printf("%d == %d → %t\n", a, c, equal)
   fmt.Printf("%d != %d → %t\n\n", a, b, notEqual)

   fmt.Printf("Строковые сравнения:\n")
   fmt.Printf("%q < %q → %t (лексикографическое сравнение)\n", d, e, strCompare)
}

Запустим программу, выведет:

Числовые сравнения:
15 > 4 → true
4 < 15 → true
15 >= 15 → true
4 <= 15 → true
15 == 15 → true
15 != 4 → true

Строковые сравнения:
"apple" < "banana" → true (лексикографическое сравнение)

Логические операторы

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

package main

import "fmt"

func main() {
   // Исходные значения для операций
   a := true
   b := false
   c := true
   d := false

   // Логические операции
   andResult := a && b     // Логическое И
   orResult := b || c      // Логическое ИЛИ
   notResult := !d         // Логическое НЕ
   // Комбинированная операция
   combined := (a || b) && !(c == d)
   // Специфика Go: короткие вычисления (short-circuiting)
   shortCircuit := b && someFunc()  // someFunc() не будет вызвана

   // Вывод результатов
   fmt.Printf("Логические операторы:\n")
   fmt.Printf("%t && %t → %t\n", a, b, andResult)
   fmt.Printf("%t || %t → %t\n", b, c, orResult)
   fmt.Printf("!%t → %t\n", d, notResult)
   fmt.Printf("(%t || %t) && !(%t == %t) → %t\n", a, b, c, d, combined)
   fmt.Printf("Short-circuit: %t (someFunc не вызывалась)\n", shortCircuit)
   // Особенность Go: строгая типизация
   // x := 1 || 0 // Ошибка: invalid operation
}
// Вспомогательная функция для демонстрации short-circuit
func someFunc() bool {
   fmt.Println("Эта функция не должна вызываться!")
   return true
}

4. Домашнее задание (5 мин)

УУД:

- Личностные

- Коммуникативные

Домашнее задание:

Написать программы:

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